| "use strict"; |
| |
| exports.__esModule = true; |
| |
| var _getIterator2 = require("babel-runtime/core-js/get-iterator"); |
| |
| var _getIterator3 = _interopRequireDefault(_getIterator2); |
| |
| exports.findParent = findParent; |
| exports.find = find; |
| exports.getFunctionParent = getFunctionParent; |
| exports.getStatementParent = getStatementParent; |
| exports.getEarliestCommonAncestorFrom = getEarliestCommonAncestorFrom; |
| exports.getDeepestCommonAncestorFrom = getDeepestCommonAncestorFrom; |
| exports.getAncestry = getAncestry; |
| exports.isAncestor = isAncestor; |
| exports.isDescendant = isDescendant; |
| exports.inType = inType; |
| exports.inShadow = inShadow; |
| |
| var _babelTypes = require("babel-types"); |
| |
| var t = _interopRequireWildcard(_babelTypes); |
| |
| var _index = require("./index"); |
| |
| var _index2 = _interopRequireDefault(_index); |
| |
| 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 findParent(callback) { |
| var path = this; |
| while (path = path.parentPath) { |
| if (callback(path)) return path; |
| } |
| return null; |
| } |
| |
| function find(callback) { |
| var path = this; |
| do { |
| if (callback(path)) return path; |
| } while (path = path.parentPath); |
| return null; |
| } |
| |
| function getFunctionParent() { |
| return this.findParent(function (path) { |
| return path.isFunction() || path.isProgram(); |
| }); |
| } |
| |
| function getStatementParent() { |
| var path = this; |
| do { |
| if (Array.isArray(path.container)) { |
| return path; |
| } |
| } while (path = path.parentPath); |
| } |
| |
| function getEarliestCommonAncestorFrom(paths) { |
| return this.getDeepestCommonAncestorFrom(paths, function (deepest, i, ancestries) { |
| var earliest = void 0; |
| var keys = t.VISITOR_KEYS[deepest.type]; |
| |
| for (var _iterator = ancestries, _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 ancestry = _ref; |
| |
| var path = ancestry[i + 1]; |
| |
| if (!earliest) { |
| earliest = path; |
| continue; |
| } |
| |
| if (path.listKey && earliest.listKey === path.listKey) { |
| if (path.key < earliest.key) { |
| earliest = path; |
| continue; |
| } |
| } |
| |
| var earliestKeyIndex = keys.indexOf(earliest.parentKey); |
| var currentKeyIndex = keys.indexOf(path.parentKey); |
| if (earliestKeyIndex > currentKeyIndex) { |
| earliest = path; |
| } |
| } |
| |
| return earliest; |
| }); |
| } |
| |
| function getDeepestCommonAncestorFrom(paths, filter) { |
| var _this = this; |
| |
| if (!paths.length) { |
| return this; |
| } |
| |
| if (paths.length === 1) { |
| return paths[0]; |
| } |
| |
| var minDepth = Infinity; |
| |
| var lastCommonIndex = void 0, |
| lastCommon = void 0; |
| |
| var ancestries = paths.map(function (path) { |
| var ancestry = []; |
| |
| do { |
| ancestry.unshift(path); |
| } while ((path = path.parentPath) && path !== _this); |
| |
| if (ancestry.length < minDepth) { |
| minDepth = ancestry.length; |
| } |
| |
| return ancestry; |
| }); |
| |
| var first = ancestries[0]; |
| |
| depthLoop: for (var i = 0; i < minDepth; i++) { |
| var shouldMatch = first[i]; |
| |
| for (var _iterator2 = ancestries, _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 ancestry = _ref2; |
| |
| if (ancestry[i] !== shouldMatch) { |
| break depthLoop; |
| } |
| } |
| |
| lastCommonIndex = i; |
| lastCommon = shouldMatch; |
| } |
| |
| if (lastCommon) { |
| if (filter) { |
| return filter(lastCommon, lastCommonIndex, ancestries); |
| } else { |
| return lastCommon; |
| } |
| } else { |
| throw new Error("Couldn't find intersection"); |
| } |
| } |
| |
| function getAncestry() { |
| var path = this; |
| var paths = []; |
| do { |
| paths.push(path); |
| } while (path = path.parentPath); |
| return paths; |
| } |
| |
| function isAncestor(maybeDescendant) { |
| return maybeDescendant.isDescendant(this); |
| } |
| |
| function isDescendant(maybeAncestor) { |
| return !!this.findParent(function (parent) { |
| return parent === maybeAncestor; |
| }); |
| } |
| |
| function inType() { |
| var path = this; |
| while (path) { |
| for (var _iterator3 = arguments, _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 type = _ref3; |
| |
| if (path.node.type === type) return true; |
| } |
| path = path.parentPath; |
| } |
| |
| return false; |
| } |
| |
| function inShadow(key) { |
| var parentFn = this.isFunction() ? this : this.findParent(function (p) { |
| return p.isFunction(); |
| }); |
| if (!parentFn) return; |
| |
| if (parentFn.isFunctionExpression() || parentFn.isFunctionDeclaration()) { |
| var shadow = parentFn.node.shadow; |
| |
| if (shadow && (!key || shadow[key] !== false)) { |
| return parentFn; |
| } |
| } else if (parentFn.isArrowFunctionExpression()) { |
| return parentFn; |
| } |
| |
| return null; |
| } |