| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.replaceWithMultiple = replaceWithMultiple; |
| exports.replaceWithSourceString = replaceWithSourceString; |
| exports.replaceWith = replaceWith; |
| exports._replaceWith = _replaceWith; |
| exports.replaceExpressionWithStatements = replaceExpressionWithStatements; |
| exports.replaceInline = replaceInline; |
| |
| function _codeFrame() { |
| const data = require("@babel/code-frame"); |
| |
| _codeFrame = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| var _index = _interopRequireDefault(require("../index")); |
| |
| var _index2 = _interopRequireDefault(require("./index")); |
| |
| function _parser() { |
| const data = require("@babel/parser"); |
| |
| _parser = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| function t() { |
| const data = _interopRequireWildcard(require("@babel/types")); |
| |
| t = function () { |
| return data; |
| }; |
| |
| return data; |
| } |
| |
| 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)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| const hoistVariablesVisitor = { |
| Function(path) { |
| path.skip(); |
| }, |
| |
| VariableDeclaration(path) { |
| if (path.node.kind !== "var") return; |
| const bindings = path.getBindingIdentifiers(); |
| |
| for (const key of Object.keys(bindings)) { |
| path.scope.push({ |
| id: bindings[key] |
| }); |
| } |
| |
| const exprs = []; |
| |
| for (const declar of path.node.declarations) { |
| if (declar.init) { |
| exprs.push(t().expressionStatement(t().assignmentExpression("=", declar.id, declar.init))); |
| } |
| } |
| |
| path.replaceWithMultiple(exprs); |
| } |
| |
| }; |
| |
| function replaceWithMultiple(nodes) { |
| this.resync(); |
| nodes = this._verifyNodeList(nodes); |
| t().inheritLeadingComments(nodes[0], this.node); |
| t().inheritTrailingComments(nodes[nodes.length - 1], this.node); |
| this.node = this.container[this.key] = null; |
| const paths = this.insertAfter(nodes); |
| |
| if (this.node) { |
| this.requeue(); |
| } else { |
| this.remove(); |
| } |
| |
| return paths; |
| } |
| |
| function replaceWithSourceString(replacement) { |
| this.resync(); |
| |
| try { |
| replacement = `(${replacement})`; |
| replacement = (0, _parser().parse)(replacement); |
| } catch (err) { |
| const loc = err.loc; |
| |
| if (loc) { |
| err.message += " - make sure this is an expression.\n" + (0, _codeFrame().codeFrameColumns)(replacement, { |
| start: { |
| line: loc.line, |
| column: loc.column + 1 |
| } |
| }); |
| err.code = "BABEL_REPLACE_SOURCE_ERROR"; |
| } |
| |
| throw err; |
| } |
| |
| replacement = replacement.program.body[0].expression; |
| |
| _index.default.removeProperties(replacement); |
| |
| return this.replaceWith(replacement); |
| } |
| |
| function replaceWith(replacement) { |
| this.resync(); |
| |
| if (this.removed) { |
| throw new Error("You can't replace this node, we've already removed it"); |
| } |
| |
| if (replacement instanceof _index2.default) { |
| replacement = replacement.node; |
| } |
| |
| if (!replacement) { |
| throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead"); |
| } |
| |
| if (this.node === replacement) { |
| return [this]; |
| } |
| |
| if (this.isProgram() && !t().isProgram(replacement)) { |
| throw new Error("You can only replace a Program root node with another Program node"); |
| } |
| |
| if (Array.isArray(replacement)) { |
| throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`"); |
| } |
| |
| if (typeof replacement === "string") { |
| throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`"); |
| } |
| |
| let nodePath = ""; |
| |
| if (this.isNodeType("Statement") && t().isExpression(replacement)) { |
| if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) { |
| replacement = t().expressionStatement(replacement); |
| nodePath = "expression"; |
| } |
| } |
| |
| if (this.isNodeType("Expression") && t().isStatement(replacement)) { |
| if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) { |
| return this.replaceExpressionWithStatements([replacement]); |
| } |
| } |
| |
| const oldNode = this.node; |
| |
| if (oldNode) { |
| t().inheritsComments(replacement, oldNode); |
| t().removeComments(oldNode); |
| } |
| |
| this._replaceWith(replacement); |
| |
| this.type = replacement.type; |
| this.setScope(); |
| this.requeue(); |
| return [nodePath ? this.get(nodePath) : this]; |
| } |
| |
| function _replaceWith(node) { |
| if (!this.container) { |
| throw new ReferenceError("Container is falsy"); |
| } |
| |
| if (this.inList) { |
| t().validate(this.parent, this.key, [node]); |
| } else { |
| t().validate(this.parent, this.key, node); |
| } |
| |
| this.debug(`Replace with ${node && node.type}`); |
| this.node = this.container[this.key] = node; |
| } |
| |
| function replaceExpressionWithStatements(nodes) { |
| this.resync(); |
| const toSequenceExpression = t().toSequenceExpression(nodes, this.scope); |
| |
| if (toSequenceExpression) { |
| return this.replaceWith(toSequenceExpression)[0].get("expressions"); |
| } |
| |
| const functionParent = this.getFunctionParent(); |
| const isParentAsync = functionParent && functionParent.is("async"); |
| const container = t().arrowFunctionExpression([], t().blockStatement(nodes)); |
| this.replaceWith(t().callExpression(container, [])); |
| this.traverse(hoistVariablesVisitor); |
| const completionRecords = this.get("callee").getCompletionRecords(); |
| |
| for (const path of completionRecords) { |
| if (!path.isExpressionStatement()) continue; |
| const loop = path.findParent(path => path.isLoop()); |
| |
| if (loop) { |
| let uid = loop.getData("expressionReplacementReturnUid"); |
| |
| if (!uid) { |
| const callee = this.get("callee"); |
| uid = callee.scope.generateDeclaredUidIdentifier("ret"); |
| callee.get("body").pushContainer("body", t().returnStatement(t().cloneNode(uid))); |
| loop.setData("expressionReplacementReturnUid", uid); |
| } else { |
| uid = t().identifier(uid.name); |
| } |
| |
| path.get("expression").replaceWith(t().assignmentExpression("=", t().cloneNode(uid), path.node.expression)); |
| } else { |
| path.replaceWith(t().returnStatement(path.node.expression)); |
| } |
| } |
| |
| const callee = this.get("callee"); |
| callee.arrowFunctionToExpression(); |
| |
| if (isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", t().FUNCTION_TYPES)) { |
| callee.set("async", true); |
| this.replaceWith(t().awaitExpression(this.node)); |
| } |
| |
| return callee.get("body.body"); |
| } |
| |
| function replaceInline(nodes) { |
| this.resync(); |
| |
| if (Array.isArray(nodes)) { |
| if (Array.isArray(this.container)) { |
| nodes = this._verifyNodeList(nodes); |
| |
| const paths = this._containerInsertAfter(nodes); |
| |
| this.remove(); |
| return paths; |
| } else { |
| return this.replaceWithMultiple(nodes); |
| } |
| } else { |
| return this.replaceWith(nodes); |
| } |
| } |