babel-schmooze-sprockets 0.1.2 → 0.1.3

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/family.js

@@ -0,0 +1,168 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+exports.getStatementParent = getStatementParent;
+exports.getOpposite = getOpposite;
+exports.getCompletionRecords = getCompletionRecords;
+exports.getSibling = getSibling;
+exports.get = get;
+exports._getKey = _getKey;
+exports._getPattern = _getPattern;
+exports.getBindingIdentifiers = getBindingIdentifiers;
+exports.getOuterBindingIdentifiers = getOuterBindingIdentifiers;
+
+var _index = require("./index");
+
+var _index2 = _interopRequireDefault(_index);
+
+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 getStatementParent() {
+  var path = this;
+
+  do {
+    if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
+      break;
+    } else {
+      path = path.parentPath;
+    }
+  } while (path);
+
+  if (path && (path.isProgram() || path.isFile())) {
+    throw new Error("File/Program node, we can't possibly find a statement parent to this");
+  }
+
+  return path;
+} // This file contains methods responsible for dealing with/retrieving children or siblings.
+
+function getOpposite() {
+  if (this.key === "left") {
+    return this.getSibling("right");
+  } else if (this.key === "right") {
+    return this.getSibling("left");
+  }
+}
+
+function getCompletionRecords() {
+  var paths = [];
+
+  var add = function add(path) {
+    if (path) paths = paths.concat(path.getCompletionRecords());
+  };
+
+  if (this.isIfStatement()) {
+    add(this.get("consequent"));
+    add(this.get("alternate"));
+  } else if (this.isDoExpression() || this.isFor() || this.isWhile()) {
+    add(this.get("body"));
+  } else if (this.isProgram() || this.isBlockStatement()) {
+    add(this.get("body").pop());
+  } else if (this.isFunction()) {
+    return this.get("body").getCompletionRecords();
+  } else if (this.isTryStatement()) {
+    add(this.get("block"));
+    add(this.get("handler"));
+    add(this.get("finalizer"));
+  } else {
+    paths.push(this);
+  }
+
+  return paths;
+}
+
+function getSibling(key) {
+  return _index2.default.get({
+    parentPath: this.parentPath,
+    parent: this.parent,
+    container: this.container,
+    listKey: this.listKey,
+    key: key
+  });
+}
+
+function get(key, context) {
+  if (context === true) context = this.context;
+  var parts = key.split(".");
+  if (parts.length === 1) {
+    // "foo"
+    return this._getKey(key, context);
+  } else {
+    // "foo.bar"
+    return this._getPattern(parts, context);
+  }
+}
+
+function _getKey(key, context) {
+  var _this = this;
+
+  var node = this.node;
+  var container = node[key];
+
+  if (Array.isArray(container)) {
+    // requested a container so give them all the paths
+    return container.map(function (_, i) {
+      return _index2.default.get({
+        listKey: key,
+        parentPath: _this,
+        parent: node,
+        container: container,
+        key: i
+      }).setContext(context);
+    });
+  } else {
+    return _index2.default.get({
+      parentPath: this,
+      parent: node,
+      container: node,
+      key: key
+    }).setContext(context);
+  }
+}
+
+function _getPattern(parts, context) {
+  var path = this;
+  for (var _iterator = parts, _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 part = _ref;
+
+    if (part === ".") {
+      path = path.parentPath;
+    } else {
+      if (Array.isArray(path)) {
+        path = path[part];
+      } else {
+        path = path.get(part, context);
+      }
+    }
+  }
+  return path;
+}
+
+function getBindingIdentifiers(duplicates) {
+  return t.getBindingIdentifiers(this.node, duplicates);
+}
+
+function getOuterBindingIdentifiers(duplicates) {
+  return t.getOuterBindingIdentifiers(this.node, duplicates);
+}

data/node_modules/babel-core/node_modules/babel-traverse/lib/path/index.js

@@ -0,0 +1,245 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _virtualTypes = require("./lib/virtual-types");
+
+var virtualTypes = _interopRequireWildcard(_virtualTypes);
+
+var _debug2 = require("debug");
+
+var _debug3 = _interopRequireDefault(_debug2);
+
+var _invariant = require("invariant");
+
+var _invariant2 = _interopRequireDefault(_invariant);
+
+var _index = require("../index");
+
+var _index2 = _interopRequireDefault(_index);
+
+var _assign = require("lodash/assign");
+
+var _assign2 = _interopRequireDefault(_assign);
+
+var _scope = require("../scope");
+
+var _scope2 = _interopRequireDefault(_scope);
+
+var _babelTypes = require("babel-types");
+
+var t = _interopRequireWildcard(_babelTypes);
+
+var _cache = require("../cache");
+
+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 }; }
+
+/* eslint max-len: 0 */
+
+var _debug = (0, _debug3.default)("babel");
+
+var NodePath = function () {
+  function NodePath(hub, parent) {
+    (0, _classCallCheck3.default)(this, NodePath);
+
+    this.parent = parent;
+    this.hub = hub;
+    this.contexts = [];
+    this.data = {};
+    this.shouldSkip = false;
+    this.shouldStop = false;
+    this.removed = false;
+    this.state = null;
+    this.opts = null;
+    this.skipKeys = null;
+    this.parentPath = null;
+    this.context = null;
+    this.container = null;
+    this.listKey = null;
+    this.inList = false;
+    this.parentKey = null;
+    this.key = null;
+    this.node = null;
+    this.scope = null;
+    this.type = null;
+    this.typeAnnotation = null;
+  }
+
+  NodePath.get = function get(_ref) {
+    var hub = _ref.hub;
+    var parentPath = _ref.parentPath;
+    var parent = _ref.parent;
+    var container = _ref.container;
+    var listKey = _ref.listKey;
+    var key = _ref.key;
+
+    if (!hub && parentPath) {
+      hub = parentPath.hub;
+    }
+
+    (0, _invariant2.default)(parent, "To get a node path the parent needs to exist");
+
+    var targetNode = container[key];
+
+    var paths = _cache.path.get(parent) || [];
+    if (!_cache.path.has(parent)) {
+      _cache.path.set(parent, paths);
+    }
+
+    var path = void 0;
+
+    for (var i = 0; i < paths.length; i++) {
+      var pathCheck = paths[i];
+      if (pathCheck.node === targetNode) {
+        path = pathCheck;
+        break;
+      }
+    }
+
+    if (!path) {
+      path = new NodePath(hub, parent);
+      paths.push(path);
+    }
+
+    path.setup(parentPath, container, listKey, key);
+
+    return path;
+  };
+
+  NodePath.prototype.getScope = function getScope(scope) {
+    var ourScope = scope;
+
+    // we're entering a new scope so let's construct it!
+    if (this.isScope()) {
+      ourScope = new _scope2.default(this, scope);
+    }
+
+    return ourScope;
+  };
+
+  NodePath.prototype.setData = function setData(key, val) {
+    return this.data[key] = val;
+  };
+
+  NodePath.prototype.getData = function getData(key, def) {
+    var val = this.data[key];
+    if (!val && def) val = this.data[key] = def;
+    return val;
+  };
+
+  NodePath.prototype.buildCodeFrameError = function buildCodeFrameError(msg) {
+    var Error = arguments.length <= 1 || arguments[1] === undefined ? SyntaxError : arguments[1];
+
+    return this.hub.file.buildCodeFrameError(this.node, msg, Error);
+  };
+
+  NodePath.prototype.traverse = function traverse(visitor, state) {
+    (0, _index2.default)(this.node, visitor, this.scope, state, this);
+  };
+
+  NodePath.prototype.mark = function mark(type, message) {
+    this.hub.file.metadata.marked.push({
+      type: type,
+      message: message,
+      loc: this.node.loc
+    });
+  };
+
+  NodePath.prototype.set = function set(key, node) {
+    t.validate(this.node, key, node);
+    this.node[key] = node;
+  };
+
+  NodePath.prototype.getPathLocation = function getPathLocation() {
+    var parts = [];
+    var path = this;
+    do {
+      var key = path.key;
+      if (path.inList) key = path.listKey + "[" + key + "]";
+      parts.unshift(key);
+    } while (path = path.parentPath);
+    return parts.join(".");
+  };
+
+  NodePath.prototype.debug = function debug(buildMessage) {
+    if (!_debug.enabled) return;
+    _debug(this.getPathLocation() + " " + this.type + ": " + buildMessage());
+  };
+
+  return NodePath;
+}();
+
+exports.default = NodePath;
+
+
+(0, _assign2.default)(NodePath.prototype, require("./ancestry"));
+(0, _assign2.default)(NodePath.prototype, require("./inference"));
+(0, _assign2.default)(NodePath.prototype, require("./replacement"));
+(0, _assign2.default)(NodePath.prototype, require("./evaluation"));
+(0, _assign2.default)(NodePath.prototype, require("./conversion"));
+(0, _assign2.default)(NodePath.prototype, require("./introspection"));
+(0, _assign2.default)(NodePath.prototype, require("./context"));
+(0, _assign2.default)(NodePath.prototype, require("./removal"));
+(0, _assign2.default)(NodePath.prototype, require("./modification"));
+(0, _assign2.default)(NodePath.prototype, require("./family"));
+(0, _assign2.default)(NodePath.prototype, require("./comments"));
+
+var _loop2 = function _loop2() {
+  if (_isArray) {
+    if (_i >= _iterator.length) return "break";
+    _ref2 = _iterator[_i++];
+  } else {
+    _i = _iterator.next();
+    if (_i.done) return "break";
+    _ref2 = _i.value;
+  }
+
+  var type = _ref2;
+
+  var typeKey = "is" + type;
+  NodePath.prototype[typeKey] = function (opts) {
+    return t[typeKey](this.node, opts);
+  };
+
+  NodePath.prototype["assert" + type] = function (opts) {
+    if (!this[typeKey](opts)) {
+      throw new TypeError("Expected node path of type " + type);
+    }
+  };
+};
+
+for (var _iterator = t.TYPES, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
+  var _ref2;
+
+  var _ret2 = _loop2();
+
+  if (_ret2 === "break") break;
+}
+
+var _loop = function _loop(type) {
+  if (type[0] === "_") return "continue";
+  if (t.TYPES.indexOf(type) < 0) t.TYPES.push(type);
+
+  var virtualType = virtualTypes[type];
+
+  NodePath.prototype["is" + type] = function (opts) {
+    return virtualType.checkPath(this, opts);
+  };
+};
+
+for (var type in virtualTypes) {
+  var _ret = _loop(type);
+
+  if (_ret === "continue") continue;
+}
+module.exports = exports["default"];

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

@@ -0,0 +1,151 @@
+"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 }; }
+
+/**
+ * Infer the type of the current `NodePath`.
+ */
+
+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;
+}
+
+/**
+ * todo: split up this method
+ */
+
+function _getTypeAnnotation() {
+  var node = this.node;
+
+  if (!node) {
+    // handle initializerless variables, add in checks for loop initializers too
+    if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
+      var declar = this.parentPath.parentPath;
+      var declarParent = declar.parentPath;
+
+      // for (let NODE in bar) {}
+      if (declar.key === "left" && declarParent.isForInStatement()) {
+        return t.stringTypeAnnotation();
+      }
+
+      // for (let NODE of bar) {}
+      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 === "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 });
+}