// Recursively gathers the identifying names of a node.
function gatherNodeParts(node: Object, parts: Array) {
if (t.isModuleDeclaration(node)) {
if (node.source) {
gatherNodeParts(node.source, parts);
} else if (node.specifiers && node.specifiers.length) {
for (const specifier of (node.specifiers: Array)) {
gatherNodeParts(specifier, parts);
}
} else if (node.declaration) {
gatherNodeParts(node.declaration, parts);
}
} else if (t.isModuleSpecifier(node)) {
gatherNodeParts(node.local, parts);
} else if (t.isMemberExpression(node)) {
gatherNodeParts(node.object, parts);
gatherNodeParts(node.property, parts);
} else if (t.isIdentifier(node)) {
parts.push(node.name);
} else if (t.isLiteral(node)) {
parts.push(node.value);
} else if (t.isCallExpression(node)) {
gatherNodeParts(node.callee, parts);
} else if (t.isObjectExpression(node) || t.isObjectPattern(node)) {
for (const prop of (node.properties: Array)) {
gatherNodeParts(prop.key || prop.argument, parts);
}
} else if (t.isPrivateName(node)) {
gatherNodeParts(node.id, parts);
} else if (t.isThisExpression(node)) {
parts.push("this");
} else if (t.isSuper(node)) {
parts.push("super");
}
}
function getVariableDeclarators(node: Object): Object[] | Object {
if (t.isIdentifier(node)) {
return t.variableDeclarator(t.identifier(node.name));
}
if (t.isObjectProperty(node)) {
return getVariableDeclarators(node.value);
}
if (t.isRestElement(node)) {
return getVariableDeclarators(node.argument);
}
if (t.isAssignmentPattern(node)) {
return getVariableDeclarators(node.left);
}
if (t.isArrayPattern(node)) {
return node.elements.reduce(
(acc, element) => acc.concat(getVariableDeclarators(element)),
[]
);
}
if (t.isObjectPattern(node)) {
return node.properties.reduce(
(acc, property) => acc.concat(getVariableDeclarators(property)),
[]
);
}
return [];
}
export function AssignmentExpression(node: Object): boolean {
if (t.isObjectPattern(node.left)) {
return true;
} else {
return ConditionalExpression(...arguments);
}
}
items.forEach(function(item) {
if (t.isObjectPattern(item) || t.isArrayPattern(item)) {
ids = ids.concat(getPatternIdentifiers(item));
} else if (t.isIdentifier(item)) {
const { start, end } = item.loc;
ids.push({
name: item.name,
expression: item.name,
location: { start, end },
});
}
});
export function getPatternIdentifiers(pattern: Node) {
let items = [];
if (t.isObjectPattern(pattern)) {
items = pattern.properties.map(({ value }) => value);
}
if (t.isArrayPattern(pattern)) {
items = pattern.elements;
}
return getIdentifiers(items);
}
/**
* Convert
* let { a } = require('b');
* to
* import { a } from 'b';
*/
function rewriteDeconstructedImportRequire(path: Path, module: Module): boolean {
let declaration = extractSingleDeclaration(path.node);
if (!declaration) {
return false;
}
let { id, init } = declaration;
if (!t.isObjectPattern(id)) {
return false;
}
let bindings = [];
for (let { key, value } of id.properties) {
if (!t.isIdentifier(value)) {
return false;
}
bindings.push(new Binding(value.name, key.name));
}
let pathNode = extractRequirePathNode(init);
if (!pathNode) {
return false;
}
rewriteRequireAsImport('named-import', path, module, bindings, pathNode);
path.replaceWith(
t.importDeclaration(
bindings.map(binding => t.importSpecifier(
t.identifier(binding.localName),
t.identifier(binding.exportName)
)),
pathNode
)
);
return true;
}
function getAssignmentTarget(node, bindings) {
if (t.isObjectPattern(node)) {
for (const property of node.properties) {
if (t.isRestElement(property)) {
property.argument = getAssignmentTarget(property.argument, bindings);
} else {
property.value = getAssignmentTarget(property.value, bindings);
}
}
return node;
}
if (t.isArrayPattern(node)) {
for (const [i, element] of node.elements.entries()) {
node.elements[i] = getAssignmentTarget(element, bindings);
}
return node;
}
if (t.isAssignmentPattern(node)) {
node.left = getAssignmentTarget(node.left, bindings);
return node;
}
if (t.isRestElement(node)) {
node.argument = getAssignmentTarget(node.argument, bindings);
return node;
}
if (t.isIdentifier(node)) {
return bindings.includes(node.name)
? node
: t.memberExpression(t.identifier("self"), node);
}
return node;
}
function getSnippet(
path: SimplePath | null,
prevPath?: SimplePath,
expression?: string = ""
): string {
if (!path) {
return expression;
}
if (t.isVariableDeclaration(path)) {
const node = path.node.declarations[0];
const name = node.id.name;
return extendSnippet(name, expression, path, prevPath);
}
if (t.isVariableDeclarator(path)) {
const node = path.node.id;
if (t.isObjectPattern(node)) {
return expression;
}
const name = node.name;
const prop = extendSnippet(name, expression, path, prevPath);
return prop;
}
if (t.isAssignmentExpression(path)) {
const node = path.node.left;
const name = t.isMemberExpression(node)
? getMemberSnippet(node)
: node.name;
const prop = extendSnippet(name, expression, path, prevPath);
return prop;
}
if (isFunction(path)) {
return expression;
}
if (t.isIdentifier(path)) {
const node = path.node;
return `${node.name}.${expression}`;
}
if (t.isObjectProperty(path)) {
return getObjectSnippet(path, prevPath, expression);
}
if (t.isObjectExpression(path)) {
const parentPath = prevPath && prevPath.parentPath;
return getObjectSnippet(parentPath, prevPath, expression);
}
if (t.isMemberExpression(path)) {
return getMemberSnippet(path.node, expression);
}
if (t.isArrayExpression(path)) {
if (!prevPath) {
throw new Error("Assertion failure - path should exist");
}
return getArraySnippet(path, prevPath, expression);
}
return "";
}