You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
350 lines
8.5 KiB
350 lines
8.5 KiB
"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"); |
|
} |