| "use strict"; |
| |
| exports.__esModule = true; |
| |
| var _typeof2 = require("babel-runtime/helpers/typeof"); |
| |
| var _typeof3 = _interopRequireDefault(_typeof2); |
| |
| var _getIterator2 = require("babel-runtime/core-js/get-iterator"); |
| |
| var _getIterator3 = _interopRequireDefault(_getIterator2); |
| |
| exports.insertBefore = insertBefore; |
| exports._containerInsert = _containerInsert; |
| exports._containerInsertBefore = _containerInsertBefore; |
| exports._containerInsertAfter = _containerInsertAfter; |
| exports._maybePopFromStatements = _maybePopFromStatements; |
| exports.insertAfter = insertAfter; |
| exports.updateSiblingKeys = updateSiblingKeys; |
| exports._verifyNodeList = _verifyNodeList; |
| exports.unshiftContainer = unshiftContainer; |
| exports.pushContainer = pushContainer; |
| exports.hoist = hoist; |
| |
| var _cache = require("../cache"); |
| |
| var _hoister = require("./lib/hoister"); |
| |
| var _hoister2 = _interopRequireDefault(_hoister); |
| |
| var _index = require("./index"); |
| |
| var _index2 = _interopRequireDefault(_index); |
| |
| 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 insertBefore(nodes) { |
| this._assertUnremoved(); |
| |
| nodes = this._verifyNodeList(nodes); |
| |
| if (this.parentPath.isExpressionStatement() || this.parentPath.isLabeledStatement()) { |
| return this.parentPath.insertBefore(nodes); |
| } else if (this.isNodeType("Expression") || this.parentPath.isForStatement() && this.key === "init") { |
| if (this.node) nodes.push(this.node); |
| this.replaceExpressionWithStatements(nodes); |
| } else { |
| this._maybePopFromStatements(nodes); |
| if (Array.isArray(this.container)) { |
| return this._containerInsertBefore(nodes); |
| } else if (this.isStatementOrBlock()) { |
| if (this.node) nodes.push(this.node); |
| this._replaceWith(t.blockStatement(nodes)); |
| } else { |
| throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?"); |
| } |
| } |
| |
| return [this]; |
| } |
| |
| function _containerInsert(from, nodes) { |
| this.updateSiblingKeys(from, nodes.length); |
| |
| var paths = []; |
| |
| for (var i = 0; i < nodes.length; i++) { |
| var to = from + i; |
| var node = nodes[i]; |
| this.container.splice(to, 0, node); |
| |
| if (this.context) { |
| var path = this.context.create(this.parent, this.container, to, this.listKey); |
| |
| if (this.context.queue) path.pushContext(this.context); |
| paths.push(path); |
| } else { |
| paths.push(_index2.default.get({ |
| parentPath: this.parentPath, |
| parent: this.parent, |
| container: this.container, |
| listKey: this.listKey, |
| key: to |
| })); |
| } |
| } |
| |
| var contexts = this._getQueueContexts(); |
| |
| for (var _iterator = paths, _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; |
| |
| _path.setScope(); |
| _path.debug(function () { |
| return "Inserted."; |
| }); |
| |
| for (var _iterator2 = contexts, _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 context = _ref2; |
| |
| context.maybeQueue(_path, true); |
| } |
| } |
| |
| return paths; |
| } |
| |
| function _containerInsertBefore(nodes) { |
| return this._containerInsert(this.key, nodes); |
| } |
| |
| function _containerInsertAfter(nodes) { |
| return this._containerInsert(this.key + 1, nodes); |
| } |
| |
| function _maybePopFromStatements(nodes) { |
| var last = nodes[nodes.length - 1]; |
| var isIdentifier = t.isIdentifier(last) || t.isExpressionStatement(last) && t.isIdentifier(last.expression); |
| |
| if (isIdentifier && !this.isCompletionRecord()) { |
| nodes.pop(); |
| } |
| } |
| |
| function insertAfter(nodes) { |
| this._assertUnremoved(); |
| |
| nodes = this._verifyNodeList(nodes); |
| |
| if (this.parentPath.isExpressionStatement() || this.parentPath.isLabeledStatement()) { |
| return this.parentPath.insertAfter(nodes); |
| } else if (this.isNodeType("Expression") || this.parentPath.isForStatement() && this.key === "init") { |
| if (this.node) { |
| var temp = this.scope.generateDeclaredUidIdentifier(); |
| nodes.unshift(t.expressionStatement(t.assignmentExpression("=", temp, this.node))); |
| nodes.push(t.expressionStatement(temp)); |
| } |
| this.replaceExpressionWithStatements(nodes); |
| } else { |
| this._maybePopFromStatements(nodes); |
| if (Array.isArray(this.container)) { |
| return this._containerInsertAfter(nodes); |
| } else if (this.isStatementOrBlock()) { |
| if (this.node) nodes.unshift(this.node); |
| this._replaceWith(t.blockStatement(nodes)); |
| } else { |
| throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?"); |
| } |
| } |
| |
| return [this]; |
| } |
| |
| function updateSiblingKeys(fromIndex, incrementBy) { |
| if (!this.parent) return; |
| |
| var paths = _cache.path.get(this.parent); |
| for (var i = 0; i < paths.length; i++) { |
| var path = paths[i]; |
| if (path.key >= fromIndex) { |
| path.key += incrementBy; |
| } |
| } |
| } |
| |
| function _verifyNodeList(nodes) { |
| if (!nodes) { |
| return []; |
| } |
| |
| if (nodes.constructor !== Array) { |
| nodes = [nodes]; |
| } |
| |
| for (var i = 0; i < nodes.length; i++) { |
| var node = nodes[i]; |
| var msg = void 0; |
| |
| if (!node) { |
| msg = "has falsy node"; |
| } else if ((typeof node === "undefined" ? "undefined" : (0, _typeof3.default)(node)) !== "object") { |
| msg = "contains a non-object node"; |
| } else if (!node.type) { |
| msg = "without a type"; |
| } else if (node instanceof _index2.default) { |
| msg = "has a NodePath when it expected a raw object"; |
| } |
| |
| if (msg) { |
| var type = Array.isArray(node) ? "array" : typeof node === "undefined" ? "undefined" : (0, _typeof3.default)(node); |
| throw new Error("Node list " + msg + " with the index of " + i + " and type of " + type); |
| } |
| } |
| |
| return nodes; |
| } |
| |
| function unshiftContainer(listKey, nodes) { |
| this._assertUnremoved(); |
| |
| nodes = this._verifyNodeList(nodes); |
| |
| var path = _index2.default.get({ |
| parentPath: this, |
| parent: this.node, |
| container: this.node[listKey], |
| listKey: listKey, |
| key: 0 |
| }); |
| |
| return path.insertBefore(nodes); |
| } |
| |
| function pushContainer(listKey, nodes) { |
| this._assertUnremoved(); |
| |
| nodes = this._verifyNodeList(nodes); |
| |
| var container = this.node[listKey]; |
| var path = _index2.default.get({ |
| parentPath: this, |
| parent: this.node, |
| container: container, |
| listKey: listKey, |
| key: container.length |
| }); |
| |
| return path.replaceWithMultiple(nodes); |
| } |
| |
| function hoist() { |
| var scope = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.scope; |
| |
| var hoister = new _hoister2.default(this, scope); |
| return hoister.run(); |
| } |