@putout/operate

Operate

operate provide you a way to manipulate 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

extract(path)

Extract node value according to it's type::

• if it is Identifier return name;
• if it is any type of Literal 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;
• throw in other cases

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.

getPathAfterImports(body)

Get next path after latest ImportDeclaration:

const programPath =  path.scope.getProgramParent().path;
const afterImportsPath = getPathAfterImports(programPath.get('body'));

getBinding(path, name)

Get binding by name using starting from path and move up.

getBinding(path, 'hello');

getBindingPath(path, name)

Get binding path by name using starting from path and move up.

getBindingPath(path, 'hello');

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'"];
    },
});

License

MIT