1. module babel-preset-stage-1
   1. object babel-preset-stage-1.plugins
   2. object babel-preset-stage-1.presets
2. module babel-preset-stage-1.plugins
   1. function babel-preset-stage-1.plugins.0 (_ref)
   2. function babel-preset-stage-1.plugins.1 (_ref)

module babel-preset-stage-1

module babel-preset-stage-1.plugins

function babel-preset-stage-1.plugins.0 (_ref)

• description and source-code

  0 = function (_ref) {
    var t = _ref.types;
  
    var ALREADY_VISITED = (0, _symbol2.default)();
  
    function findConstructorCall(path) {
      var methods = path.get("body.body");
  
      for (var _iterator = methods, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3
  .default)(_iterator);;) {
        var _ref2;
  
        if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref2 = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref2 = _i.value;
        }
  
        var method = _ref2;
  
        if (method.node.kind === "constructorCall") {
          return method;
        }
      }
  
      return null;
    }
  
    function handleClassWithCall(constructorCall, classPath) {
      var _classPath = classPath,
          node = _classPath.node;
  
      var ref = node.id || classPath.scope.generateUidIdentifier("class");
  
      if (classPath.parentPath.isExportDefaultDeclaration()) {
        classPath = classPath.parentPath;
        classPath.insertAfter(t.exportDefaultDeclaration(ref));
      }
  
      classPath.replaceWithMultiple(buildWrapper({
        CLASS_REF: classPath.scope.generateUidIdentifier(ref.name),
        CALL_REF: classPath.scope.generateUidIdentifier(ref.name + "Call"),
        CALL: t.functionExpression(null, constructorCall.node.params, constructorCall.node.body),
        CLASS: t.toExpression(node),
        WRAPPER_REF: ref
      }));
  
      constructorCall.remove();
    }
  
    return {
      inherits: require("babel-plugin-syntax-class-constructor-call"),
  
      visitor: {
        Class: function Class(path) {
          if (path.node[ALREADY_VISITED]) return;
          path.node[ALREADY_VISITED] = true;
  
          var constructorCall = findConstructorCall(path);
  
          if (constructorCall) {
            handleClassWithCall(constructorCall, path);
          } else {
            return;
          }
        }
      }
    };
  }

• example usage

  n/a

function babel-preset-stage-1.plugins.1 (_ref)

• description and source-code

  1 = function (_ref) {
    var t = _ref.types;
  
    function build(node, nodes, scope) {
      var first = node.specifiers[0];
      if (!t.isExportNamespaceSpecifier(first) && !t.isExportDefaultSpecifier(first)) return;
  
      var specifier = node.specifiers.shift();
      var uid = scope.generateUidIdentifier(specifier.exported.name);
  
      var newSpecifier = void 0;
      if (t.isExportNamespaceSpecifier(specifier)) {
        newSpecifier = t.importNamespaceSpecifier(uid);
      } else {
        newSpecifier = t.importDefaultSpecifier(uid);
      }
  
      nodes.push(t.importDeclaration([newSpecifier], node.source));
      nodes.push(t.exportNamedDeclaration(null, [t.exportSpecifier(uid, specifier.exported)]));
  
      build(node, nodes, scope);
    }
  
    return {
      inherits: require("babel-plugin-syntax-export-extensions"),
  
      visitor: {
        ExportNamedDeclaration: function ExportNamedDeclaration(path) {
          var node = path.node,
              scope = path.scope;
  
          var nodes = [];
          build(node, nodes, scope);
          if (!nodes.length) return;
  
          if (node.specifiers.length >= 1) {
            nodes.push(node);
          }
          path.replaceWithMultiple(nodes);
        }
      }
    };
  }

• example usage

  n/a