1"use strict"; 2 3exports.__esModule = true; 4 5var _maxSafeInteger = require("babel-runtime/core-js/number/max-safe-integer"); 6 7var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger); 8 9var _stringify = require("babel-runtime/core-js/json/stringify"); 10 11var _stringify2 = _interopRequireDefault(_stringify); 12 13var _getIterator2 = require("babel-runtime/core-js/get-iterator"); 14 15var _getIterator3 = _interopRequireDefault(_getIterator2); 16 17exports.toComputedKey = toComputedKey; 18exports.toSequenceExpression = toSequenceExpression; 19exports.toKeyAlias = toKeyAlias; 20exports.toIdentifier = toIdentifier; 21exports.toBindingIdentifierName = toBindingIdentifierName; 22exports.toStatement = toStatement; 23exports.toExpression = toExpression; 24exports.toBlock = toBlock; 25exports.valueToNode = valueToNode; 26 27var _isPlainObject = require("lodash/isPlainObject"); 28 29var _isPlainObject2 = _interopRequireDefault(_isPlainObject); 30 31var _isRegExp = require("lodash/isRegExp"); 32 33var _isRegExp2 = _interopRequireDefault(_isRegExp); 34 35var _index = require("./index"); 36 37var t = _interopRequireWildcard(_index); 38 39function _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; } } 40 41function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 42 43function toComputedKey(node) { 44 var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key || node.property; 45 46 if (!node.computed) { 47 if (t.isIdentifier(key)) key = t.stringLiteral(key.name); 48 } 49 return key; 50} 51 52function gatherSequenceExpressions(nodes, scope, declars) { 53 var exprs = []; 54 var ensureLastUndefined = true; 55 56 for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { 57 var _ref; 58 59 if (_isArray) { 60 if (_i >= _iterator.length) break; 61 _ref = _iterator[_i++]; 62 } else { 63 _i = _iterator.next(); 64 if (_i.done) break; 65 _ref = _i.value; 66 } 67 68 var node = _ref; 69 70 ensureLastUndefined = false; 71 72 if (t.isExpression(node)) { 73 exprs.push(node); 74 } else if (t.isExpressionStatement(node)) { 75 exprs.push(node.expression); 76 } else if (t.isVariableDeclaration(node)) { 77 if (node.kind !== "var") return; 78 79 for (var _iterator2 = node.declarations, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) { 80 var _ref2; 81 82 if (_isArray2) { 83 if (_i2 >= _iterator2.length) break; 84 _ref2 = _iterator2[_i2++]; 85 } else { 86 _i2 = _iterator2.next(); 87 if (_i2.done) break; 88 _ref2 = _i2.value; 89 } 90 91 var declar = _ref2; 92 93 var bindings = t.getBindingIdentifiers(declar); 94 for (var key in bindings) { 95 declars.push({ 96 kind: node.kind, 97 id: bindings[key] 98 }); 99 } 100 101 if (declar.init) { 102 exprs.push(t.assignmentExpression("=", declar.id, declar.init)); 103 } 104 } 105 106 ensureLastUndefined = true; 107 } else if (t.isIfStatement(node)) { 108 var consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode(); 109 var alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode(); 110 if (!consequent || !alternate) return; 111 112 exprs.push(t.conditionalExpression(node.test, consequent, alternate)); 113 } else if (t.isBlockStatement(node)) { 114 var body = gatherSequenceExpressions(node.body, scope, declars); 115 if (!body) return; 116 117 exprs.push(body); 118 } else if (t.isEmptyStatement(node)) { 119 ensureLastUndefined = true; 120 } else { 121 return; 122 } 123 } 124 125 if (ensureLastUndefined) { 126 exprs.push(scope.buildUndefinedNode()); 127 } 128 129 if (exprs.length === 1) { 130 return exprs[0]; 131 } else { 132 return t.sequenceExpression(exprs); 133 } 134} 135 136function toSequenceExpression(nodes, scope) { 137 if (!nodes || !nodes.length) return; 138 139 var declars = []; 140 var result = gatherSequenceExpressions(nodes, scope, declars); 141 if (!result) return; 142 143 for (var _iterator3 = declars, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) { 144 var _ref3; 145 146 if (_isArray3) { 147 if (_i3 >= _iterator3.length) break; 148 _ref3 = _iterator3[_i3++]; 149 } else { 150 _i3 = _iterator3.next(); 151 if (_i3.done) break; 152 _ref3 = _i3.value; 153 } 154 155 var declar = _ref3; 156 157 scope.push(declar); 158 } 159 160 return result; 161} 162 163function toKeyAlias(node) { 164 var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key; 165 166 var alias = void 0; 167 168 if (node.kind === "method") { 169 return toKeyAlias.increment() + ""; 170 } else if (t.isIdentifier(key)) { 171 alias = key.name; 172 } else if (t.isStringLiteral(key)) { 173 alias = (0, _stringify2.default)(key.value); 174 } else { 175 alias = (0, _stringify2.default)(t.removePropertiesDeep(t.cloneDeep(key))); 176 } 177 178 if (node.computed) { 179 alias = "[" + alias + "]"; 180 } 181 182 if (node.static) { 183 alias = "static:" + alias; 184 } 185 186 return alias; 187} 188 189toKeyAlias.uid = 0; 190 191toKeyAlias.increment = function () { 192 if (toKeyAlias.uid >= _maxSafeInteger2.default) { 193 return toKeyAlias.uid = 0; 194 } else { 195 return toKeyAlias.uid++; 196 } 197}; 198 199function toIdentifier(name) { 200 name = name + ""; 201 202 name = name.replace(/[^a-zA-Z0-9$_]/g, "-"); 203 204 name = name.replace(/^[-0-9]+/, ""); 205 206 name = name.replace(/[-\s]+(.)?/g, function (match, c) { 207 return c ? c.toUpperCase() : ""; 208 }); 209 210 if (!t.isValidIdentifier(name)) { 211 name = "_" + name; 212 } 213 214 return name || "_"; 215} 216 217function toBindingIdentifierName(name) { 218 name = toIdentifier(name); 219 if (name === "eval" || name === "arguments") name = "_" + name; 220 return name; 221} 222 223function toStatement(node, ignore) { 224 if (t.isStatement(node)) { 225 return node; 226 } 227 228 var mustHaveId = false; 229 var newType = void 0; 230 231 if (t.isClass(node)) { 232 mustHaveId = true; 233 newType = "ClassDeclaration"; 234 } else if (t.isFunction(node)) { 235 mustHaveId = true; 236 newType = "FunctionDeclaration"; 237 } else if (t.isAssignmentExpression(node)) { 238 return t.expressionStatement(node); 239 } 240 241 if (mustHaveId && !node.id) { 242 newType = false; 243 } 244 245 if (!newType) { 246 if (ignore) { 247 return false; 248 } else { 249 throw new Error("cannot turn " + node.type + " to a statement"); 250 } 251 } 252 253 node.type = newType; 254 255 return node; 256} 257 258function toExpression(node) { 259 if (t.isExpressionStatement(node)) { 260 node = node.expression; 261 } 262 263 if (t.isExpression(node)) { 264 return node; 265 } 266 267 if (t.isClass(node)) { 268 node.type = "ClassExpression"; 269 } else if (t.isFunction(node)) { 270 node.type = "FunctionExpression"; 271 } 272 273 if (!t.isExpression(node)) { 274 throw new Error("cannot turn " + node.type + " to an expression"); 275 } 276 277 return node; 278} 279 280function toBlock(node, parent) { 281 if (t.isBlockStatement(node)) { 282 return node; 283 } 284 285 if (t.isEmptyStatement(node)) { 286 node = []; 287 } 288 289 if (!Array.isArray(node)) { 290 if (!t.isStatement(node)) { 291 if (t.isFunction(parent)) { 292 node = t.returnStatement(node); 293 } else { 294 node = t.expressionStatement(node); 295 } 296 } 297 298 node = [node]; 299 } 300 301 return t.blockStatement(node); 302} 303 304function valueToNode(value) { 305 if (value === undefined) { 306 return t.identifier("undefined"); 307 } 308 309 if (value === true || value === false) { 310 return t.booleanLiteral(value); 311 } 312 313 if (value === null) { 314 return t.nullLiteral(); 315 } 316 317 if (typeof value === "string") { 318 return t.stringLiteral(value); 319 } 320 321 if (typeof value === "number") { 322 return t.numericLiteral(value); 323 } 324 325 if ((0, _isRegExp2.default)(value)) { 326 var pattern = value.source; 327 var flags = value.toString().match(/\/([a-z]+|)$/)[1]; 328 return t.regExpLiteral(pattern, flags); 329 } 330 331 if (Array.isArray(value)) { 332 return t.arrayExpression(value.map(t.valueToNode)); 333 } 334 335 if ((0, _isPlainObject2.default)(value)) { 336 var props = []; 337 for (var key in value) { 338 var nodeKey = void 0; 339 if (t.isValidIdentifier(key)) { 340 nodeKey = t.identifier(key); 341 } else { 342 nodeKey = t.stringLiteral(key); 343 } 344 props.push(t.objectProperty(nodeKey, t.valueToNode(value[key]))); 345 } 346 return t.objectExpression(props); 347 } 348 349 throw new Error("don't know how to turn this value into a node"); 350}