0.2.0 - Mid migration

web/node_modules/@babel/plugin-proposal-async-generator-functions/lib/for-await.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _core = require("@babel/core");
+
+const buildForAwait = (0, _core.template)(`
+  async function wrapper() {
+    var ITERATOR_ABRUPT_COMPLETION = false;
+    var ITERATOR_HAD_ERROR_KEY = false;
+    var ITERATOR_ERROR_KEY;
+    try {
+      for (
+        var ITERATOR_KEY = GET_ITERATOR(OBJECT), STEP_KEY;
+        ITERATOR_ABRUPT_COMPLETION = !(STEP_KEY = await ITERATOR_KEY.next()).done;
+        ITERATOR_ABRUPT_COMPLETION = false
+      ) {
+      }
+    } catch (err) {
+      ITERATOR_HAD_ERROR_KEY = true;
+      ITERATOR_ERROR_KEY = err;
+    } finally {
+      try {
+        if (ITERATOR_ABRUPT_COMPLETION && ITERATOR_KEY.return != null) {
+          await ITERATOR_KEY.return();
+        }
+      } finally {
+        if (ITERATOR_HAD_ERROR_KEY) {
+          throw ITERATOR_ERROR_KEY;
+        }
+      }
+    }
+  }
+`);
+
+function _default(path, {
+  getAsyncIterator
+}) {
+  const {
+    node,
+    scope,
+    parent
+  } = path;
+  const stepKey = scope.generateUidIdentifier("step");
+
+  const stepValue = _core.types.memberExpression(stepKey, _core.types.identifier("value"));
+
+  const left = node.left;
+  let declar;
+
+  if (_core.types.isIdentifier(left) || _core.types.isPattern(left) || _core.types.isMemberExpression(left)) {
+    declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, stepValue));
+  } else if (_core.types.isVariableDeclaration(left)) {
+    declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, stepValue)]);
+  }
+
+  let template = buildForAwait({
+    ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
+    ITERATOR_ABRUPT_COMPLETION: scope.generateUidIdentifier("iteratorAbruptCompletion"),
+    ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
+    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
+    GET_ITERATOR: getAsyncIterator,
+    OBJECT: node.right,
+    STEP_KEY: _core.types.cloneNode(stepKey)
+  });
+  template = template.body.body;
+
+  const isLabeledParent = _core.types.isLabeledStatement(parent);
+
+  const tryBody = template[3].block.body;
+  const loop = tryBody[0];
+
+  if (isLabeledParent) {
+    tryBody[0] = _core.types.labeledStatement(parent.label, loop);
+  }
+
+  return {
+    replaceParent: isLabeledParent,
+    node: template,
+    declar,
+    loop
+  };
+}

web/node_modules/@babel/plugin-proposal-async-generator-functions/lib/index.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+
+var _helperRemapAsyncToGenerator = require("@babel/helper-remap-async-to-generator");
+
+var _pluginSyntaxAsyncGenerators = require("@babel/plugin-syntax-async-generators");
+
+var _core = require("@babel/core");
+
+var _forAwait = require("./for-await");
+
+var _default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  const yieldStarVisitor = {
+    Function(path) {
+      path.skip();
+    },
+
+    YieldExpression({
+      node
+    }, state) {
+      if (!node.delegate) return;
+      const callee = state.addHelper("asyncGeneratorDelegate");
+      node.argument = _core.types.callExpression(callee, [_core.types.callExpression(state.addHelper("asyncIterator"), [node.argument]), state.addHelper("awaitAsyncGenerator")]);
+    }
+
+  };
+  const forAwaitVisitor = {
+    Function(path) {
+      path.skip();
+    },
+
+    ForOfStatement(path, {
+      file
+    }) {
+      const {
+        node
+      } = path;
+      if (!node.await) return;
+      const build = (0, _forAwait.default)(path, {
+        getAsyncIterator: file.addHelper("asyncIterator")
+      });
+      const {
+        declar,
+        loop
+      } = build;
+      const block = loop.body;
+      path.ensureBlock();
+
+      if (declar) {
+        block.body.push(declar);
+      }
+
+      block.body = block.body.concat(node.body.body);
+
+      _core.types.inherits(loop, node);
+
+      _core.types.inherits(loop.body, node.body);
+
+      if (build.replaceParent) {
+        path.parentPath.replaceWithMultiple(build.node);
+      } else {
+        path.replaceWithMultiple(build.node);
+      }
+    }
+
+  };
+  const visitor = {
+    Function(path, state) {
+      if (!path.node.async) return;
+      path.traverse(forAwaitVisitor, state);
+      if (!path.node.generator) return;
+      path.traverse(yieldStarVisitor, state);
+      (0, _helperRemapAsyncToGenerator.default)(path, {
+        wrapAsync: state.addHelper("wrapAsyncGenerator"),
+        wrapAwait: state.addHelper("awaitAsyncGenerator")
+      });
+    }
+
+  };
+  return {
+    name: "proposal-async-generator-functions",
+    inherits: _pluginSyntaxAsyncGenerators.default,
+    visitor: {
+      Program(path, state) {
+        path.traverse(visitor, state);
+      }
+
+    }
+  };
+});
+
+exports.default = _default;