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 examples 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 or JSXIdentifier or JSXAttribute return name;
• if it is any type of Literal or JSXText return value;
• if it is RegExp return pattern;
• if it is TemplateLiteral return qusis[0].value.raw;
• if it is TemplateElement return value.raw;
• if it is ClassMethod return key;
• if it is TSTypeReference return typeName.name;
• if it is TSTypeParameter return name;
• if it is MemberExpression return object.property;
• if it is ArrayExpression return element1,element2,...,elementN;
• if it is TSAsExpression return key.expression;
• 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