| "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"); |
| } |