add some packages

node_modules/babel-traverse/lib/path/inference/index.js

@@ -0,0 +1,142 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.getTypeAnnotation = getTypeAnnotation;
+exports._getTypeAnnotation = _getTypeAnnotation;
+exports.isBaseType = isBaseType;
+exports.couldBeBaseType = couldBeBaseType;
+exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
+exports.isGenericType = isGenericType;
+
+var _inferers = require("./inferers");
+
+var inferers = _interopRequireWildcard(_inferers);
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+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 getTypeAnnotation() {
+  if (this.typeAnnotation) return this.typeAnnotation;
+
+  var type = this._getTypeAnnotation() || t.anyTypeAnnotation();
+  if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
+  return this.typeAnnotation = type;
+}
+
+function _getTypeAnnotation() {
+  var node = this.node;
+
+  if (!node) {
+    if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+      var declar = this.parentPath.parentPath;
+      var declarParent = declar.parentPath;
+
+      if (declar.key === "left" && declarParent.isForInStatement()) {
+        return t.stringTypeAnnotation();
+      }
+
+      if (declar.key === "left" && declarParent.isForOfStatement()) {
+        return t.anyTypeAnnotation();
+      }
+
+      return t.voidTypeAnnotation();
+    } else {
+      return;
+    }
+  }
+
+  if (node.typeAnnotation) {
+    return node.typeAnnotation;
+  }
+
+  var inferer = inferers[node.type];
+  if (inferer) {
+    return inferer.call(this, node);
+  }
+
+  inferer = inferers[this.parentPath.type];
+  if (inferer && inferer.validParent) {
+    return this.parentPath.getTypeAnnotation();
+  }
+}
+
+function isBaseType(baseName, soft) {
+  return _isBaseType(baseName, this.getTypeAnnotation(), soft);
+}
+
+function _isBaseType(baseName, type, soft) {
+  if (baseName === "string") {
+    return t.isStringTypeAnnotation(type);
+  } else if (baseName === "number") {
+    return t.isNumberTypeAnnotation(type);
+  } else if (baseName === "boolean") {
+    return t.isBooleanTypeAnnotation(type);
+  } else if (baseName === "any") {
+    return t.isAnyTypeAnnotation(type);
+  } else if (baseName === "mixed") {
+    return t.isMixedTypeAnnotation(type);
+  } else if (baseName === "empty") {
+    return t.isEmptyTypeAnnotation(type);
+  } else if (baseName === "void") {
+    return t.isVoidTypeAnnotation(type);
+  } else {
+    if (soft) {
+      return false;
+    } else {
+      throw new Error("Unknown base type " + baseName);
+    }
+  }
+}
+
+function couldBeBaseType(name) {
+  var type = this.getTypeAnnotation();
+  if (t.isAnyTypeAnnotation(type)) return true;
+
+  if (t.isUnionTypeAnnotation(type)) {
+    for (var _iterator = type.types, _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 type2 = _ref;
+
+      if (t.isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+        return true;
+      }
+    }
+    return false;
+  } else {
+    return _isBaseType(name, type, true);
+  }
+}
+
+function baseTypeStrictlyMatches(right) {
+  var left = this.getTypeAnnotation();
+  right = right.getTypeAnnotation();
+
+  if (!t.isAnyTypeAnnotation(left) && t.isFlowBaseAnnotation(left)) {
+    return right.type === left.type;
+  }
+}
+
+function isGenericType(genericName) {
+  var type = this.getTypeAnnotation();
+  return t.isGenericTypeAnnotation(type) && t.isIdentifier(type.id, { name: genericName });
+}

node_modules/babel-traverse/lib/path/inference/inferer-reference.js

@@ -0,0 +1,185 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.default = function (node) {
+  if (!this.isReferenced()) return;
+
+  var binding = this.scope.getBinding(node.name);
+  if (binding) {
+    if (binding.identifier.typeAnnotation) {
+      return binding.identifier.typeAnnotation;
+    } else {
+      return getTypeAnnotationBindingConstantViolations(this, node.name);
+    }
+  }
+
+  if (node.name === "undefined") {
+    return t.voidTypeAnnotation();
+  } else if (node.name === "NaN" || node.name === "Infinity") {
+    return t.numberTypeAnnotation();
+  } else if (node.name === "arguments") {}
+};
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+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 getTypeAnnotationBindingConstantViolations(path, name) {
+  var binding = path.scope.getBinding(name);
+
+  var types = [];
+  path.typeAnnotation = t.unionTypeAnnotation(types);
+
+  var functionConstantViolations = [];
+  var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+
+  var testType = getConditionalAnnotation(path, name);
+  if (testType) {
+    var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+
+    constantViolations = constantViolations.filter(function (path) {
+      return testConstantViolations.indexOf(path) < 0;
+    });
+
+    types.push(testType.typeAnnotation);
+  }
+
+  if (constantViolations.length) {
+    constantViolations = constantViolations.concat(functionConstantViolations);
+
+    for (var _iterator = constantViolations, _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 violation = _ref;
+
+      types.push(violation.getTypeAnnotation());
+    }
+  }
+
+  if (types.length) {
+    return t.createUnionTypeAnnotation(types);
+  }
+}
+
+function getConstantViolationsBefore(binding, path, functions) {
+  var violations = binding.constantViolations.slice();
+  violations.unshift(binding.path);
+  return violations.filter(function (violation) {
+    violation = violation.resolve();
+    var status = violation._guessExecutionStatusRelativeTo(path);
+    if (functions && status === "function") functions.push(violation);
+    return status === "before";
+  });
+}
+
+function inferAnnotationFromBinaryExpression(name, path) {
+  var operator = path.node.operator;
+
+  var right = path.get("right").resolve();
+  var left = path.get("left").resolve();
+
+  var target = void 0;
+  if (left.isIdentifier({ name: name })) {
+    target = right;
+  } else if (right.isIdentifier({ name: name })) {
+    target = left;
+  }
+  if (target) {
+    if (operator === "===") {
+      return target.getTypeAnnotation();
+    } else if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return t.numberTypeAnnotation();
+    } else {
+      return;
+    }
+  } else {
+    if (operator !== "===") return;
+  }
+
+  var typeofPath = void 0;
+  var typePath = void 0;
+  if (left.isUnaryExpression({ operator: "typeof" })) {
+    typeofPath = left;
+    typePath = right;
+  } else if (right.isUnaryExpression({ operator: "typeof" })) {
+    typeofPath = right;
+    typePath = left;
+  }
+  if (!typePath && !typeofPath) return;
+
+  typePath = typePath.resolve();
+  if (!typePath.isLiteral()) return;
+
+  var typeValue = typePath.node.value;
+  if (typeof typeValue !== "string") return;
+
+  if (!typeofPath.get("argument").isIdentifier({ name: name })) return;
+
+  return t.createTypeAnnotationBasedOnTypeof(typePath.node.value);
+}
+
+function getParentConditionalPath(path) {
+  var parentPath = void 0;
+  while (parentPath = path.parentPath) {
+    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
+      if (path.key === "test") {
+        return;
+      } else {
+        return parentPath;
+      }
+    } else {
+      path = parentPath;
+    }
+  }
+}
+
+function getConditionalAnnotation(path, name) {
+  var ifStatement = getParentConditionalPath(path);
+  if (!ifStatement) return;
+
+  var test = ifStatement.get("test");
+  var paths = [test];
+  var types = [];
+
+  do {
+    var _path = paths.shift().resolve();
+
+    if (_path.isLogicalExpression()) {
+      paths.push(_path.get("left"));
+      paths.push(_path.get("right"));
+    }
+
+    if (_path.isBinaryExpression()) {
+      var type = inferAnnotationFromBinaryExpression(name, _path);
+      if (type) types.push(type);
+    }
+  } while (paths.length);
+
+  if (types.length) {
+    return {
+      typeAnnotation: t.createUnionTypeAnnotation(types),
+      ifStatement: ifStatement
+    };
+  } else {
+    return getConditionalAnnotation(ifStatement, name);
+  }
+}
+module.exports = exports["default"];

node_modules/babel-traverse/lib/path/inference/inferers.js

@@ -0,0 +1,195 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ClassDeclaration = exports.ClassExpression = exports.FunctionDeclaration = exports.ArrowFunctionExpression = exports.FunctionExpression = exports.Identifier = undefined;
+
+var _infererReference = require("./inferer-reference");
+
+Object.defineProperty(exports, "Identifier", {
+  enumerable: true,
+  get: function get() {
+    return _interopRequireDefault(_infererReference).default;
+  }
+});
+exports.VariableDeclarator = VariableDeclarator;
+exports.TypeCastExpression = TypeCastExpression;
+exports.NewExpression = NewExpression;
+exports.TemplateLiteral = TemplateLiteral;
+exports.UnaryExpression = UnaryExpression;
+exports.BinaryExpression = BinaryExpression;
+exports.LogicalExpression = LogicalExpression;
+exports.ConditionalExpression = ConditionalExpression;
+exports.SequenceExpression = SequenceExpression;
+exports.AssignmentExpression = AssignmentExpression;
+exports.UpdateExpression = UpdateExpression;
+exports.StringLiteral = StringLiteral;
+exports.NumericLiteral = NumericLiteral;
+exports.BooleanLiteral = BooleanLiteral;
+exports.NullLiteral = NullLiteral;
+exports.RegExpLiteral = RegExpLiteral;
+exports.ObjectExpression = ObjectExpression;
+exports.ArrayExpression = ArrayExpression;
+exports.RestElement = RestElement;
+exports.CallExpression = CallExpression;
+exports.TaggedTemplateExpression = TaggedTemplateExpression;
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+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 VariableDeclarator() {
+  var id = this.get("id");
+
+  if (id.isIdentifier()) {
+    return this.get("init").getTypeAnnotation();
+  } else {
+    return;
+  }
+}
+
+function TypeCastExpression(node) {
+  return node.typeAnnotation;
+}
+
+TypeCastExpression.validParent = true;
+
+function NewExpression(node) {
+  if (this.get("callee").isIdentifier()) {
+    return t.genericTypeAnnotation(node.callee);
+  }
+}
+
+function TemplateLiteral() {
+  return t.stringTypeAnnotation();
+}
+
+function UnaryExpression(node) {
+  var operator = node.operator;
+
+  if (operator === "void") {
+    return t.voidTypeAnnotation();
+  } else if (t.NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.numberTypeAnnotation();
+  } else if (t.STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.stringTypeAnnotation();
+  } else if (t.BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.booleanTypeAnnotation();
+  }
+}
+
+function BinaryExpression(node) {
+  var operator = node.operator;
+
+  if (t.NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.numberTypeAnnotation();
+  } else if (t.BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t.booleanTypeAnnotation();
+  } else if (operator === "+") {
+    var right = this.get("right");
+    var left = this.get("left");
+
+    if (left.isBaseType("number") && right.isBaseType("number")) {
+      return t.numberTypeAnnotation();
+    } else if (left.isBaseType("string") || right.isBaseType("string")) {
+      return t.stringTypeAnnotation();
+    }
+
+    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
+  }
+}
+
+function LogicalExpression() {
+  return t.createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+}
+
+function ConditionalExpression() {
+  return t.createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+}
+
+function SequenceExpression() {
+  return this.get("expressions").pop().getTypeAnnotation();
+}
+
+function AssignmentExpression() {
+  return this.get("right").getTypeAnnotation();
+}
+
+function UpdateExpression(node) {
+  var operator = node.operator;
+  if (operator === "++" || operator === "--") {
+    return t.numberTypeAnnotation();
+  }
+}
+
+function StringLiteral() {
+  return t.stringTypeAnnotation();
+}
+
+function NumericLiteral() {
+  return t.numberTypeAnnotation();
+}
+
+function BooleanLiteral() {
+  return t.booleanTypeAnnotation();
+}
+
+function NullLiteral() {
+  return t.nullLiteralTypeAnnotation();
+}
+
+function RegExpLiteral() {
+  return t.genericTypeAnnotation(t.identifier("RegExp"));
+}
+
+function ObjectExpression() {
+  return t.genericTypeAnnotation(t.identifier("Object"));
+}
+
+function ArrayExpression() {
+  return t.genericTypeAnnotation(t.identifier("Array"));
+}
+
+function RestElement() {
+  return ArrayExpression();
+}
+
+RestElement.validParent = true;
+
+function Func() {
+  return t.genericTypeAnnotation(t.identifier("Function"));
+}
+
+exports.FunctionExpression = Func;
+exports.ArrowFunctionExpression = Func;
+exports.FunctionDeclaration = Func;
+exports.ClassExpression = Func;
+exports.ClassDeclaration = Func;
+function CallExpression() {
+  return resolveCall(this.get("callee"));
+}
+
+function TaggedTemplateExpression() {
+  return resolveCall(this.get("tag"));
+}
+
+function resolveCall(callee) {
+  callee = callee.resolve();
+
+  if (callee.isFunction()) {
+    if (callee.is("async")) {
+      if (callee.is("generator")) {
+        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
+      } else {
+        return t.genericTypeAnnotation(t.identifier("Promise"));
+      }
+    } else {
+      if (callee.node.returnType) {
+        return callee.node.returnType;
+      } else {}
+    }
+  }
+}