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}