"use strict";
|
|
exports.__esModule = true;
|
|
var _maxSafeInteger = require("babel-runtime/core-js/number/max-safe-integer");
|
|
var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
|
|
var _stringify = require("babel-runtime/core-js/json/stringify");
|
|
var _stringify2 = _interopRequireDefault(_stringify);
|
|
var _getIterator2 = require("babel-runtime/core-js/get-iterator");
|
|
var _getIterator3 = _interopRequireDefault(_getIterator2);
|
|
exports.toComputedKey = toComputedKey;
|
exports.toSequenceExpression = toSequenceExpression;
|
exports.toKeyAlias = toKeyAlias;
|
exports.toIdentifier = toIdentifier;
|
exports.toBindingIdentifierName = toBindingIdentifierName;
|
exports.toStatement = toStatement;
|
exports.toExpression = toExpression;
|
exports.toBlock = toBlock;
|
exports.valueToNode = valueToNode;
|
|
var _isPlainObject = require("lodash/isPlainObject");
|
|
var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
|
|
var _isRegExp = require("lodash/isRegExp");
|
|
var _isRegExp2 = _interopRequireDefault(_isRegExp);
|
|
var _index = require("./index");
|
|
var t = _interopRequireWildcard(_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 toComputedKey(node) {
|
var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key || node.property;
|
|
if (!node.computed) {
|
if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
|
}
|
return key;
|
}
|
|
function gatherSequenceExpressions(nodes, scope, declars) {
|
var exprs = [];
|
var ensureLastUndefined = true;
|
|
for (var _iterator = nodes, _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 node = _ref;
|
|
ensureLastUndefined = false;
|
|
if (t.isExpression(node)) {
|
exprs.push(node);
|
} else if (t.isExpressionStatement(node)) {
|
exprs.push(node.expression);
|
} else if (t.isVariableDeclaration(node)) {
|
if (node.kind !== "var") return;
|
|
for (var _iterator2 = node.declarations, _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 declar = _ref2;
|
|
var bindings = t.getBindingIdentifiers(declar);
|
for (var key in bindings) {
|
declars.push({
|
kind: node.kind,
|
id: bindings[key]
|
});
|
}
|
|
if (declar.init) {
|
exprs.push(t.assignmentExpression("=", declar.id, declar.init));
|
}
|
}
|
|
ensureLastUndefined = true;
|
} else if (t.isIfStatement(node)) {
|
var consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
|
var alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
|
if (!consequent || !alternate) return;
|
|
exprs.push(t.conditionalExpression(node.test, consequent, alternate));
|
} else if (t.isBlockStatement(node)) {
|
var body = gatherSequenceExpressions(node.body, scope, declars);
|
if (!body) return;
|
|
exprs.push(body);
|
} else if (t.isEmptyStatement(node)) {
|
ensureLastUndefined = true;
|
} else {
|
return;
|
}
|
}
|
|
if (ensureLastUndefined) {
|
exprs.push(scope.buildUndefinedNode());
|
}
|
|
if (exprs.length === 1) {
|
return exprs[0];
|
} else {
|
return t.sequenceExpression(exprs);
|
}
|
}
|
|
function toSequenceExpression(nodes, scope) {
|
if (!nodes || !nodes.length) return;
|
|
var declars = [];
|
var result = gatherSequenceExpressions(nodes, scope, declars);
|
if (!result) return;
|
|
for (var _iterator3 = declars, _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 declar = _ref3;
|
|
scope.push(declar);
|
}
|
|
return result;
|
}
|
|
function toKeyAlias(node) {
|
var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key;
|
|
var alias = void 0;
|
|
if (node.kind === "method") {
|
return toKeyAlias.increment() + "";
|
} else if (t.isIdentifier(key)) {
|
alias = key.name;
|
} else if (t.isStringLiteral(key)) {
|
alias = (0, _stringify2.default)(key.value);
|
} else {
|
alias = (0, _stringify2.default)(t.removePropertiesDeep(t.cloneDeep(key)));
|
}
|
|
if (node.computed) {
|
alias = "[" + alias + "]";
|
}
|
|
if (node.static) {
|
alias = "static:" + alias;
|
}
|
|
return alias;
|
}
|
|
toKeyAlias.uid = 0;
|
|
toKeyAlias.increment = function () {
|
if (toKeyAlias.uid >= _maxSafeInteger2.default) {
|
return toKeyAlias.uid = 0;
|
} else {
|
return toKeyAlias.uid++;
|
}
|
};
|
|
function toIdentifier(name) {
|
name = name + "";
|
|
name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
|
|
name = name.replace(/^[-0-9]+/, "");
|
|
name = name.replace(/[-\s]+(.)?/g, function (match, c) {
|
return c ? c.toUpperCase() : "";
|
});
|
|
if (!t.isValidIdentifier(name)) {
|
name = "_" + name;
|
}
|
|
return name || "_";
|
}
|
|
function toBindingIdentifierName(name) {
|
name = toIdentifier(name);
|
if (name === "eval" || name === "arguments") name = "_" + name;
|
return name;
|
}
|
|
function toStatement(node, ignore) {
|
if (t.isStatement(node)) {
|
return node;
|
}
|
|
var mustHaveId = false;
|
var newType = void 0;
|
|
if (t.isClass(node)) {
|
mustHaveId = true;
|
newType = "ClassDeclaration";
|
} else if (t.isFunction(node)) {
|
mustHaveId = true;
|
newType = "FunctionDeclaration";
|
} else if (t.isAssignmentExpression(node)) {
|
return t.expressionStatement(node);
|
}
|
|
if (mustHaveId && !node.id) {
|
newType = false;
|
}
|
|
if (!newType) {
|
if (ignore) {
|
return false;
|
} else {
|
throw new Error("cannot turn " + node.type + " to a statement");
|
}
|
}
|
|
node.type = newType;
|
|
return node;
|
}
|
|
function toExpression(node) {
|
if (t.isExpressionStatement(node)) {
|
node = node.expression;
|
}
|
|
if (t.isExpression(node)) {
|
return node;
|
}
|
|
if (t.isClass(node)) {
|
node.type = "ClassExpression";
|
} else if (t.isFunction(node)) {
|
node.type = "FunctionExpression";
|
}
|
|
if (!t.isExpression(node)) {
|
throw new Error("cannot turn " + node.type + " to an expression");
|
}
|
|
return node;
|
}
|
|
function toBlock(node, parent) {
|
if (t.isBlockStatement(node)) {
|
return node;
|
}
|
|
if (t.isEmptyStatement(node)) {
|
node = [];
|
}
|
|
if (!Array.isArray(node)) {
|
if (!t.isStatement(node)) {
|
if (t.isFunction(parent)) {
|
node = t.returnStatement(node);
|
} else {
|
node = t.expressionStatement(node);
|
}
|
}
|
|
node = [node];
|
}
|
|
return t.blockStatement(node);
|
}
|
|
function valueToNode(value) {
|
if (value === undefined) {
|
return t.identifier("undefined");
|
}
|
|
if (value === true || value === false) {
|
return t.booleanLiteral(value);
|
}
|
|
if (value === null) {
|
return t.nullLiteral();
|
}
|
|
if (typeof value === "string") {
|
return t.stringLiteral(value);
|
}
|
|
if (typeof value === "number") {
|
return t.numericLiteral(value);
|
}
|
|
if ((0, _isRegExp2.default)(value)) {
|
var pattern = value.source;
|
var flags = value.toString().match(/\/([a-z]+|)$/)[1];
|
return t.regExpLiteral(pattern, flags);
|
}
|
|
if (Array.isArray(value)) {
|
return t.arrayExpression(value.map(t.valueToNode));
|
}
|
|
if ((0, _isPlainObject2.default)(value)) {
|
var props = [];
|
for (var key in value) {
|
var nodeKey = void 0;
|
if (t.isValidIdentifier(key)) {
|
nodeKey = t.identifier(key);
|
} else {
|
nodeKey = t.stringLiteral(key);
|
}
|
props.push(t.objectProperty(nodeKey, t.valueToNode(value[key])));
|
}
|
return t.objectExpression(props);
|
}
|
|
throw new Error("don't know how to turn this value into a node");
|
}
|
