| "use strict"; |
| |
| exports.__esModule = true; |
| exports.is = undefined; |
| |
| var _getIterator2 = require("babel-runtime/core-js/get-iterator"); |
| |
| var _getIterator3 = _interopRequireDefault(_getIterator2); |
| |
| exports.matchesPattern = matchesPattern; |
| exports.has = has; |
| exports.isStatic = isStatic; |
| exports.isnt = isnt; |
| exports.equals = equals; |
| exports.isNodeType = isNodeType; |
| exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression; |
| exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement; |
| exports.isCompletionRecord = isCompletionRecord; |
| exports.isStatementOrBlock = isStatementOrBlock; |
| exports.referencesImport = referencesImport; |
| exports.getSource = getSource; |
| exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore; |
| exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo; |
| exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions; |
| exports.resolve = resolve; |
| exports._resolve = _resolve; |
| |
| var _includes = require("lodash/includes"); |
| |
| var _includes2 = _interopRequireDefault(_includes); |
| |
| var _babelTypes = require("babel-types"); |
| |
| var t = _interopRequireWildcard(_babelTypes); |
| |
| function _interopRequireWildcard(obj) { if (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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function matchesPattern(pattern, allowPartial) { |
| if (!this.isMemberExpression()) return false; |
| |
| var parts = pattern.split("."); |
| var search = [this.node]; |
| var i = 0; |
| |
| function matches(name) { |
| var part = parts[i]; |
| return part === "*" || name === part; |
| } |
| |
| while (search.length) { |
| var node = search.shift(); |
| |
| if (allowPartial && i === parts.length) { |
| return true; |
| } |
| |
| if (t.isIdentifier(node)) { |
| if (!matches(node.name)) return false; |
| } else if (t.isLiteral(node)) { |
| if (!matches(node.value)) return false; |
| } else if (t.isMemberExpression(node)) { |
| if (node.computed && !t.isLiteral(node.property)) { |
| return false; |
| } else { |
| search.unshift(node.property); |
| search.unshift(node.object); |
| continue; |
| } |
| } else if (t.isThisExpression(node)) { |
| if (!matches("this")) return false; |
| } else { |
| return false; |
| } |
| |
| if (++i > parts.length) { |
| return false; |
| } |
| } |
| |
| return i === parts.length; |
| } |
| |
| function has(key) { |
| var val = this.node && this.node[key]; |
| if (val && Array.isArray(val)) { |
| return !!val.length; |
| } else { |
| return !!val; |
| } |
| } |
| |
| function isStatic() { |
| return this.scope.isStatic(this.node); |
| } |
| |
| var is = exports.is = has; |
| |
| function isnt(key) { |
| return !this.has(key); |
| } |
| |
| function equals(key, value) { |
| return this.node[key] === value; |
| } |
| |
| function isNodeType(type) { |
| return t.isType(this.type, type); |
| } |
| |
| function canHaveVariableDeclarationOrExpression() { |
| return (this.key === "init" || this.key === "left") && this.parentPath.isFor(); |
| } |
| |
| function canSwapBetweenExpressionAndStatement(replacement) { |
| if (this.key !== "body" || !this.parentPath.isArrowFunctionExpression()) { |
| return false; |
| } |
| |
| if (this.isExpression()) { |
| return t.isBlockStatement(replacement); |
| } else if (this.isBlockStatement()) { |
| return t.isExpression(replacement); |
| } |
| |
| return false; |
| } |
| |
| function isCompletionRecord(allowInsideFunction) { |
| var path = this; |
| var first = true; |
| |
| do { |
| var container = path.container; |
| |
| if (path.isFunction() && !first) { |
| return !!allowInsideFunction; |
| } |
| |
| first = false; |
| |
| if (Array.isArray(container) && path.key !== container.length - 1) { |
| return false; |
| } |
| } while ((path = path.parentPath) && !path.isProgram()); |
| |
| return true; |
| } |
| |
| function isStatementOrBlock() { |
| if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) { |
| return false; |
| } else { |
| return (0, _includes2.default)(t.STATEMENT_OR_BLOCK_KEYS, this.key); |
| } |
| } |
| |
| function referencesImport(moduleSource, importName) { |
| if (!this.isReferencedIdentifier()) return false; |
| |
| var binding = this.scope.getBinding(this.node.name); |
| if (!binding || binding.kind !== "module") return false; |
| |
| var path = binding.path; |
| var parent = path.parentPath; |
| if (!parent.isImportDeclaration()) return false; |
| |
| if (parent.node.source.value === moduleSource) { |
| if (!importName) return true; |
| } else { |
| return false; |
| } |
| |
| if (path.isImportDefaultSpecifier() && importName === "default") { |
| return true; |
| } |
| |
| if (path.isImportNamespaceSpecifier() && importName === "*") { |
| return true; |
| } |
| |
| if (path.isImportSpecifier() && path.node.imported.name === importName) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| function getSource() { |
| var node = this.node; |
| if (node.end) { |
| return this.hub.file.code.slice(node.start, node.end); |
| } else { |
| return ""; |
| } |
| } |
| |
| function willIMaybeExecuteBefore(target) { |
| return this._guessExecutionStatusRelativeTo(target) !== "after"; |
| } |
| |
| function _guessExecutionStatusRelativeTo(target) { |
| var targetFuncParent = target.scope.getFunctionParent(); |
| var selfFuncParent = this.scope.getFunctionParent(); |
| |
| if (targetFuncParent.node !== selfFuncParent.node) { |
| var status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent); |
| if (status) { |
| return status; |
| } else { |
| target = targetFuncParent.path; |
| } |
| } |
| |
| var targetPaths = target.getAncestry(); |
| if (targetPaths.indexOf(this) >= 0) return "after"; |
| |
| var selfPaths = this.getAncestry(); |
| |
| var commonPath = void 0; |
| var targetIndex = void 0; |
| var selfIndex = void 0; |
| for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) { |
| var selfPath = selfPaths[selfIndex]; |
| targetIndex = targetPaths.indexOf(selfPath); |
| if (targetIndex >= 0) { |
| commonPath = selfPath; |
| break; |
| } |
| } |
| if (!commonPath) { |
| return "before"; |
| } |
| |
| var targetRelationship = targetPaths[targetIndex - 1]; |
| var selfRelationship = selfPaths[selfIndex - 1]; |
| if (!targetRelationship || !selfRelationship) { |
| return "before"; |
| } |
| |
| if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) { |
| return targetRelationship.key > selfRelationship.key ? "before" : "after"; |
| } |
| |
| var targetKeyPosition = t.VISITOR_KEYS[targetRelationship.type].indexOf(targetRelationship.key); |
| var selfKeyPosition = t.VISITOR_KEYS[selfRelationship.type].indexOf(selfRelationship.key); |
| return targetKeyPosition > selfKeyPosition ? "before" : "after"; |
| } |
| |
| function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) { |
| var targetFuncPath = targetFuncParent.path; |
| if (!targetFuncPath.isFunctionDeclaration()) return; |
| |
| var binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name); |
| |
| if (!binding.references) return "before"; |
| |
| var referencePaths = binding.referencePaths; |
| |
| for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { |
| var _ref; |
| |
| if (_isArray) { |
| if (_i >= _iterator.length) break; |
| _ref = _iterator[_i++]; |
| } else { |
| _i = _iterator.next(); |
| if (_i.done) break; |
| _ref = _i.value; |
| } |
| |
| var path = _ref; |
| |
| if (path.key !== "callee" || !path.parentPath.isCallExpression()) { |
| return; |
| } |
| } |
| |
| var allStatus = void 0; |
| |
| for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) { |
| var _ref2; |
| |
| if (_isArray2) { |
| if (_i2 >= _iterator2.length) break; |
| _ref2 = _iterator2[_i2++]; |
| } else { |
| _i2 = _iterator2.next(); |
| if (_i2.done) break; |
| _ref2 = _i2.value; |
| } |
| |
| var _path = _ref2; |
| |
| var childOfFunction = !!_path.find(function (path) { |
| return path.node === targetFuncPath.node; |
| }); |
| if (childOfFunction) continue; |
| |
| var status = this._guessExecutionStatusRelativeTo(_path); |
| |
| if (allStatus) { |
| if (allStatus !== status) return; |
| } else { |
| allStatus = status; |
| } |
| } |
| |
| return allStatus; |
| } |
| |
| function resolve(dangerous, resolved) { |
| return this._resolve(dangerous, resolved) || this; |
| } |
| |
| function _resolve(dangerous, resolved) { |
| if (resolved && resolved.indexOf(this) >= 0) return; |
| |
| resolved = resolved || []; |
| resolved.push(this); |
| |
| if (this.isVariableDeclarator()) { |
| if (this.get("id").isIdentifier()) { |
| return this.get("init").resolve(dangerous, resolved); |
| } else {} |
| } else if (this.isReferencedIdentifier()) { |
| var binding = this.scope.getBinding(this.node.name); |
| if (!binding) return; |
| |
| if (!binding.constant) return; |
| |
| if (binding.kind === "module") return; |
| |
| if (binding.path !== this) { |
| var ret = binding.path.resolve(dangerous, resolved); |
| |
| if (this.find(function (parent) { |
| return parent.node === ret.node; |
| })) return; |
| return ret; |
| } |
| } else if (this.isTypeCastExpression()) { |
| return this.get("expression").resolve(dangerous, resolved); |
| } else if (dangerous && this.isMemberExpression()) { |
| |
| var targetKey = this.toComputedKey(); |
| if (!t.isLiteral(targetKey)) return; |
| |
| var targetName = targetKey.value; |
| |
| var target = this.get("object").resolve(dangerous, resolved); |
| |
| if (target.isObjectExpression()) { |
| var props = target.get("properties"); |
| for (var _iterator3 = props, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) { |
| var _ref3; |
| |
| if (_isArray3) { |
| if (_i3 >= _iterator3.length) break; |
| _ref3 = _iterator3[_i3++]; |
| } else { |
| _i3 = _iterator3.next(); |
| if (_i3.done) break; |
| _ref3 = _i3.value; |
| } |
| |
| var prop = _ref3; |
| |
| if (!prop.isProperty()) continue; |
| |
| var key = prop.get("key"); |
| |
| var match = prop.isnt("computed") && key.isIdentifier({ name: targetName }); |
| |
| match = match || key.isLiteral({ value: targetName }); |
| |
| if (match) return prop.get("value").resolve(dangerous, resolved); |
| } |
| } else if (target.isArrayExpression() && !isNaN(+targetName)) { |
| var elems = target.get("elements"); |
| var elem = elems[targetName]; |
| if (elem) return elem.resolve(dangerous, resolved); |
| } |
| } |
| } |