@putout/operate
v12.15.0
Published
Operate on AST for π Putout
Downloads
84,112
Readme
Operate
Manipulate with path
nodes and keep comments
and loc
information.
Install
npm i @putout/operate
If you write plugin for putout
you already have operator
in putout
, all exampes will get operator
from putout
, but you can use direct require('@putout/operate')
as well.
API
rename
Let's suppose you have code
const {hello} = one;
hello();
You want to change to:
const {world} = one;
world();
Use:
rename(path, 'hello', 'world');
renameProperty
Let's suppose you have code
const {hello: world} = one;
You want to change to:
const {world} = one;
Use:
renameProperty(path, 'hello', 'world');
setLiteralValue(path: Path | Node, value: string)
Set raw
and value
of a literal.
isSimple(path: Path | Node)
Check if path is:
Literal
;Identifier
;MemberExpression
;OptionalMemberExpression
;
extract(path)
Extract node value according to it's type::
- if it is
Identifier
orJSXIdentifier
orJSXAttribute
returnname
; - if it is any type of
Literal
orJSXText
returnvalue
; - if it is
RegExp
returnpattern
; - if it is
TemplateLiteral
returnqusis[0].value.raw
; - if it is
TemplateElement
returnvalue.raw
; - if it is
ClassMethod
returnkey
; - if it is
TSTypeReference
returntypeName.name
; - if it is
TSTypeParameter
returnname
; - if it is
MemberExpression
returnobject.property
; - if it is
ArrayExpression
returnelement1,element2,...,elementN
; throw
in other cases
insertAfter(path, node)
Safe way to insert node
after path
without duplicating comments.
insertBefore(path, node)
Safe way to insert node
before path
.
replaceWith(path, node)
const {operator, types} = require('putout');
const {replaceWith} = operator;
const {ContinueStatement} = types;
replaceWith(path, ContinueStatement());
replaceWithMultiple(path, nodes)
const {operator, types} = require('putout');
const {replaceWithMultiple} = operator;
const {
ExpressionStatement,
ContinueStatement,
} = types;
replaceWithMultiple(path, [
ExpressionStatement(path.node.argument),
ContinueStatement,
]);
isModuleExports(path)
Check if currentPath is module.exports
expression.
toExpression(node)
Can be used to convert node to expression
when building new nodes.
remove(path)
Remove node
, preserve comments.
path.toString();
// returns const [a, b] = c;
remove(path.get('declarations.0.id.0'));
path.toString(); // returns const [, b] = c;
getLiteralRaw(path: Path|Node)
Get raw
or extra.raw
, which can be received from template
methods.
getPathAfterRequires(body)
Get next path
after latest require
:
const programPath = path.scope.getProgramParent().path;
const afterRequirePath = getPathAfterRequires(programPath.get('body'));
getPathAfterImports(body)
Get next path
after latest ImportDeclaration
:
const programPath = path.scope.getProgramParent().path;
const afterImportsPath = getPathAfterImports(programPath.get('body'));
getBinding(path, name: string | Node)
Get binding (declaration of variable) by name using starting from path
and move up.
getBinding(path, 'hello');
getBindingPath(path, name: string | Node)
Get binding path
by name using starting from path
and move up.
const bindingPath = getBindingPath(path, 'hello');
module.exports.match = () => ({
'typeof __a === "__b"': ({__a}, path) => {
// when __a declared proceed to replace
return getBindingPath(path, __a);
},
});
compute(path)
Computes value of expression:
For code
like this:
const bodies = {
function: `typeof __a === 'function'`,
};
module.exports.replace = () => ({
[bodies.function]: 'isFn(__a)',
});
You can compute value of bodies.function
:
const {parse, operator} = require('putout');
const {traverse, compute} = operator;
traverse({
'__a.__b': (path) => {
const [computed, value] = compute(path);
// returns
[true, `typeof __a === 'function'`];
},
});
getExportDefault(path)
Get export default
or null.
isESM(path)
Check if given source is ESM
search for ImportDeclaration
and ExportDeclaration
nodes.
getProperty(path: Path, name: string)
Get property from ObjectExpression
path:
const homepagePath = getProperty(__aPath, 'homepage');
getProperties(path: Path, names: string[])
Get properties from ObjectExpression
path and add a Path
suffix to each result:
const {homepagePath} = getProperties(__aPath, ['homepage']);
traverseProperties(path: Path | Node, name: string, {firstLevel?: false})
Traverse list of properties from ObjectExpression
.
const object = template.ast('x({"a": "b"})');
const [propertyPath] = traverseProperties(object, 'a');
License
MIT