'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.isObjectAssignOrExtendsExpression = isObjectAssignOrExtendsExpression;
exports.isObjectAssignExpression = isObjectAssignExpression;
exports.isExtendsHelperExpression = isExtendsHelperExpression;
exports.isImport = isImport;
exports.isIdentifierNamed = isIdentifierNamed;
exports.isCommentBlock = isCommentBlock;
exports.getIdName = getIdName;
exports.findPropertiesOfNode = findPropertiesOfNode;
exports.getInternalStaticThingsOfClass = getInternalStaticThingsOfClass;
exports.getOtherPropertiesOfIdentifier = getOtherPropertiesOfIdentifier;
exports.getPropertiesOfObjectAssignOrExtendHelper = getPropertiesOfObjectAssignOrExtendHelper;
exports.getPropNames = getPropNames;
exports.groupPropertiesByName = groupPropertiesByName;
var _babelTypes = require('babel-types');
var t = _interopRequireWildcard(_babelTypes);
var _arrayFlatten = require('array-flatten');
var _arrayFlatten2 = _interopRequireDefault(_arrayFlatten);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function isObjectAssignOrExtendsExpression(node) {
return isObjectAssignExpression(node) || isExtendsHelperExpression(node);
}
function isObjectAssignExpression(node) {
Iif (!t.isCallExpression(node)) return false;
const callee = node && node.callee;
return !!(callee.object && callee.property && callee.object.name === 'Object' && callee.property.name === 'assign');
}
function isExtendsHelperExpression(node) {
Iif (!t.isCallExpression(node)) return false;
const callee = node && node.callee;
return isIdentifierNamed(callee, '_extends');
}
// t.isImport only exists if the dynamic import syntax plugin is used, so avoid using that to make it optional.
function isImport(node) {
return node && node.type === 'Import';
}
function isIdentifierNamed(node, name) {
return t.isIdentifier(node, { name: name });
}
// This doesn't exist on babel-types
function isCommentBlock(node) {
return node && node.type === 'CommentBlock';
}
function getIdName(node) {
return node.id && node.id.name;
}
function findPropertiesOfNode(blockScopeNode, declaration) {
if (t.isFunctionDeclaration(declaration) || t.isArrowFunctionExpression(declaration)) {
return null;
} else if (t.isObjectExpression(declaration)) {
return declaration.properties;
} else if (t.isClass(declaration)) {
return [...getInternalStaticThingsOfClass(declaration), ...getOtherPropertiesOfIdentifier(blockScopeNode, declaration.id.name)];
} else if (t.isIdentifier(declaration)) {
return getOtherPropertiesOfIdentifier(blockScopeNode, declaration.name);
} else Eif (isObjectAssignOrExtendsExpression(declaration)) {
return getPropertiesOfObjectAssignOrExtendHelper(declaration, blockScopeNode);
}
return null;
}
function getInternalStaticThingsOfClass(classNode) {
return classNode.body.body.filter(item => item.static);
}
/**
* Traverse the top-level of the scope (program or function body) looking for either:
* - ObjectExpression assignments to the object variable.
* - Property assignments directly to our object (but not to nested properties).
*
* @return Array<{key, value}>
*/
function getOtherPropertiesOfIdentifier(blockScopeNode, idName) {
return (0, _arrayFlatten2.default)(blockScopeNode.body.map(node => {
if (t.isExpressionStatement(node)) {
// ID = value | ID.key = value | ID.key.nested = value
const { left, right } = node.expression;
if (t.isAssignmentExpression(node.expression)) {
if (t.isIdentifier(left) && left.name === idName) {
// ID = value
Iif (t.isObjectExpression(right)) {
// ID = {}
return right.properties; // Array<ObjectProperty>
}
} else {
const { object, property: key } = left;
if (t.isIdentifier(object) && object.name === idName) {
// ID.key = value
return { key, value: right }; // ObjectProperty-like (key, value)
}
}
}
} else if (t.isVariableDeclaration(node)) {
// console.log(require('util').inspect(node, { depth: 4 }));
return node.declarations.filter(declaration => declaration.id.name === idName).map(declaration => declaration.init).filter(init => init).filter(init => t.isObjectExpression(init) || isObjectAssignOrExtendsExpression(init)).map(init => t.isObjectExpression(init) ? init.properties : getPropertiesOfObjectAssignOrExtendHelper(init, blockScopeNode));
}
}).filter(item => item));
}
function getPropertiesOfObjectAssignOrExtendHelper(node, blockScopeNode) {
// Check all the args and recursively try to get props of identifiers (although they may be imported)
return (0, _arrayFlatten2.default)(node.arguments.map(arg => {
if (t.isObjectExpression(arg)) {
return arg.properties;
} else Eif (t.isIdentifier(arg)) {
// Recursive, although props will be empty if arg is an imported object
return getOtherPropertiesOfIdentifier(blockScopeNode, arg.name);
}
}));
}
function getPropNames(props) {
return props.map(prop => prop.key.name);
}
function groupPropertiesByName(properties) {
return properties && properties.reduce((accumulator, property) => {
accumulator[property.key.name] = property.value;
return accumulator;
}, {});
} |