d2-ui
Version:
309 lines (240 loc) • 9.4 kB
JavaScript
/*istanbul ignore next*/"use strict";
exports.__esModule = true;
var _getIterator2 = require("babel-runtime/core-js/get-iterator");
var _getIterator3 = _interopRequireDefault(_getIterator2);
exports.replaceWithMultiple = replaceWithMultiple;
/*istanbul ignore next*/exports.replaceWithSourceString = replaceWithSourceString;
/*istanbul ignore next*/exports.replaceWith = replaceWith;
/*istanbul ignore next*/exports._replaceWith = _replaceWith;
/*istanbul ignore next*/exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
/*istanbul ignore next*/exports.replaceInline = replaceInline;
var /*istanbul ignore next*/_babelCodeFrame = require("babel-code-frame");
/*istanbul ignore next*/
var _babelCodeFrame2 = _interopRequireDefault(_babelCodeFrame);
var /*istanbul ignore next*/_index = require("../index");
/*istanbul ignore next*/
var _index2 = _interopRequireDefault(_index);
var /*istanbul ignore next*/_index3 = require("./index");
/*istanbul ignore next*/
var _index4 = _interopRequireDefault(_index3);
var /*istanbul ignore next*/_babylon = require("babylon");
var /*istanbul ignore next*/_babelTypes = require("babel-types");
/*istanbul ignore next*/
var t = _interopRequireWildcard(_babelTypes);
/*istanbul ignore next*/
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 }; }
var hoistVariablesVisitor = { /*istanbul ignore next*/
Function: function Function(path) {
path.skip();
},
/*istanbul ignore next*/VariableDeclaration: function VariableDeclaration(path) {
if (path.node.kind !== "var") return;
var bindings = path.getBindingIdentifiers();
for (var key in bindings) {
path.scope.push({ id: bindings[key] });
}
var exprs = [];
for ( /*istanbul ignore next*/var _iterator = path.node.declarations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
/*istanbul ignore next*/
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var declar = _ref;
if (declar.init) {
exprs.push(t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init)));
}
}
path.replaceWithMultiple(exprs);
}
};
/**
* Replace a node with an array of multiple. This method performs the following steps:
*
* - Inherit the comments of first provided node with that of the current node.
* - Insert the provided nodes after the current node.
* - Remove the current node.
*/
/* eslint max-len: 0 */
// This file contains methods responsible for replacing a node with another.
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;
this.insertAfter(nodes);
if (this.node) {
this.requeue();
} else {
this.remove();
}
}
/**
* Parse a string as an expression and replace the current node with the result.
*
* NOTE: This is typically not a good idea to use. Building source strings when
* transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's
* easier to use, your transforms will be extremely brittle.
*/
function replaceWithSourceString(replacement) {
this.resync();
try {
replacement = /*istanbul ignore next*/"(" + replacement + ")";
replacement = /*istanbul ignore next*/(0, _babylon.parse)(replacement);
} catch (err) {
var loc = err.loc;
if (loc) {
err.message += " - make sure this is an expression.";
err.message += "\n" + /*istanbul ignore next*/(0, _babelCodeFrame2.default)(replacement, loc.line, loc.column + 1);
}
throw err;
}
replacement = replacement.program.body[0].expression;
/*istanbul ignore next*/_index2.default.removeProperties(replacement);
return this.replaceWith(replacement);
}
/**
* Replace the current node with another.
*/
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 /*istanbul ignore next*/_index4.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;
}
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()`");
}
if (this.isNodeType("Statement") && t.isExpression(replacement)) {
if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
// replacing a statement with an expression so wrap it in an expression statement
replacement = t.expressionStatement(replacement);
}
}
if (this.isNodeType("Expression") && t.isStatement(replacement)) {
if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
// replacing an expression with a statement so let's explode it
return this.replaceExpressionWithStatements([replacement]);
}
}
var oldNode = this.node;
if (oldNode) {
t.inheritsComments(replacement, oldNode);
t.removeComments(oldNode);
}
// replace the node
this._replaceWith(replacement);
this.type = replacement.type;
// potentially create new scope
this.setScope();
// requeue for visiting
this.requeue();
}
/**
* Description
*/
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(function () /*istanbul ignore next*/{
return "Replace with " + (node && node.type);
});
this.node = this.container[this.key] = node;
}
/**
* This method takes an array of statements nodes and then explodes it
* into expressions. This method retains completion records which is
* extremely important to retain original semantics.
*/
function replaceExpressionWithStatements(nodes) {
this.resync();
var toSequenceExpression = t.toSequenceExpression(nodes, this.scope);
if (t.isSequenceExpression(toSequenceExpression)) {
var exprs = toSequenceExpression.expressions;
if (exprs.length >= 2 && this.parentPath.isExpressionStatement()) {
this._maybePopFromStatements(exprs);
}
// could be just one element due to the previous maybe popping
if (exprs.length === 1) {
this.replaceWith(exprs[0]);
} else {
this.replaceWith(toSequenceExpression);
}
} else if (toSequenceExpression) {
this.replaceWith(toSequenceExpression);
} else {
var container = t.functionExpression(null, [], t.blockStatement(nodes));
container.shadow = true;
this.replaceWith(t.callExpression(container, []));
this.traverse(hoistVariablesVisitor);
// add implicit returns to all ending expression statements
var completionRecords = this.get("callee").getCompletionRecords();
for ( /*istanbul ignore next*/var _iterator2 = completionRecords, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
/*istanbul ignore next*/
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;
if (!path.isExpressionStatement()) continue;
var loop = path.findParent(function (path) /*istanbul ignore next*/{
return path.isLoop();
});
if (loop) {
var callee = this.get("callee");
var uid = callee.scope.generateDeclaredUidIdentifier("ret");
callee.get("body").pushContainer("body", t.returnStatement(uid));
path.get("expression").replaceWith(t.assignmentExpression("=", uid, path.node.expression));
} else {
path.replaceWith(t.returnStatement(path.node.expression));
}
}
return this.node;
}
}
function replaceInline(nodes) {
this.resync();
if (Array.isArray(nodes)) {
if (Array.isArray(this.container)) {
nodes = this._verifyNodeList(nodes);
this._containerInsertAfter(nodes);
return this.remove();
} else {
return this.replaceWithMultiple(nodes);
}
} else {
return this.replaceWith(nodes);
}
}