ast-utils
Utility library to manipulate ASTs
Install
$ npm install --save ast-utils copy
Usage
const astUtils = require ( 'ast-utils' ); copy
API
astUtils.isStaticRequire(node)
Checks whether node is a call to CommonJS's require function.
Returns true if and only if:
node is a CallExpression
node's callee is an Identifier named require
node has exactly 1 Literal argument whose value is a string
Example:
require ( 'lodash' );
// => true
require (foo);
// => false
foo ( 'lodash' );
// => false copy
Usage example (in the context of an ESLint rule):
function create (context) {
return {
CallExpression (node) {
if (astUtils. isStaticRequire (node)) {
context. report ({
node: node,
message: 'Use import syntax rather than `require`'
});
}
}
};
} copy
astUtils.getRequireSource(node)
Gets the source of a require() call. If node is not a require call (in the definition of isStaticRequire ), it will return undefined.
Example:
require ( 'lodash' );
// => 'lodash'
require ( './foo' );
// => './foo' copy
Usage example (in the context of an ESLint rule):
function create (context) {
return {
CallExpression (node) {
if (astUtils. isStaticRequire (node) && astUtils. getRequireSource (node) === 'underscore' ) {
context. report ({
node: node,
message: 'Use `lodash` instead of `underscore`'
});
}
}
};
} copy
astUtils.containsIdentifier(name, node)
Checks if there is a reference to a variable named name inside of node.
Returns true if and only if:
There is an Identifier named name inside of node
That Identifier is a variable (i.e. not a static property name for instance)
That Identifier does not reference a different variable named name introduced in a sub-scope of node.
Example:
foo (a);
// containsIdentifier('a', node) // => true
// containsIdentifier('b', node) // => true
function foo (fn) {
return function (a) {
return fn (a);
};
}
// containsIdentifier('a', node) // => false copy
Usage example (in the context of an ESLint rule):
function create (context) {
return {
FunctionDeclaration (node) {
node.params. forEach (param => {
if (param.type === 'Identifier' && ! astUtils. containsIdentifier (param.name, node.body)) {
context. report ({
node: node,
message: `${ name } is never used`
});
}
});
}
};
} copy
astUtils.someContainIdentifier(name, nodes)
Checks if there is a reference to a variable named name inside any node of the nodes array. Will return false if nodes is not an array.
This is a shorthand version of containsIdentifier that works for arrays. The following are equivalent:
[node1, node2, node3]. some (node => astUtils. containsIdentifier ( 'a' , node));
// equivalent to
astUtils. someContainIdentifier ( 'a' , [node1, node2, node3]); copy
License
MIT © Jeroen Engels