@meteorjs/babel 7.19.0-beta.1 → 7.19.0-beta.3

package/options.js

@@ -186,18 +186,14 @@ function getDefaultsForNode8(features) {
       require("@babel/plugin-syntax-object-rest-spread"),
       require("@babel/plugin-proposal-object-rest-spread")
     );
-    // TODO [fibers]: instead of removing the code below, consider this comment:
-      // https://github.com/meteor/meteor/pull/12471/files#r1089610144
-    const isFiberDisabled = process.env.DISABLE_FIBERS === '1';
-    const ignoreAsyncPlugin = process.env.IGNORE_ASYNC_PLUGIN === '1';
 
-    if (!ignoreAsyncPlugin) {
+    if (features.useNativeAsyncAwait === false) {
       combined.plugins.push([
         require('./plugins/async-await.js'),
         {
-          // Do not transform `await x` to `Promise.await(x)`, since Node
-          // 8 has native support for await expressions.
-          useNativeAsyncAwait: isFiberDisabled,
+          // Even though Node 8 supports native async/await, it is not
+          // compatible with fibers.
+          useNativeAsyncAwait: false,
         },
       ]);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meteorjs/babel",
   "author": "Meteor <dev@meteor.com>",
-  "version": "7.19.0-beta.1",
+  "version": "7.19.0-beta.3",
   "license": "MIT",
   "description": "Babel wrapper package for use with Meteor",
   "keywords": [
@@ -41,13 +41,13 @@
     "@babel/template": "^7.16.7",
     "@babel/traverse": "^7.17.0",
     "@babel/types": "^7.17.0",
-    "@meteorjs/reify": "https://github.com/meteor/reify/tarball/5078da9d0827cc17741504762f3a7f71c3b01448",
+    "@meteorjs/reify": "https://github.com/meteor/reify/tarball/cf61c57c6c4fefcbf164bf63d3c12fda1924b3d2",
     "babel-preset-meteor": "^7.10.0",
     "babel-preset-minify": "^0.5.1",
     "convert-source-map": "^1.6.0",
     "lodash": "^4.17.21",
     "meteor-babel-helpers": "0.0.3",
-    "typescript": "~4.7.4"
+    "typescript": "~4.9.4"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "7.14.5",

package/plugins/async-await.js

@@ -0,0 +1,78 @@
+"use strict";
+
+module.exports = function (babel) {
+  const t = babel.types;
+
+  return {
+    name: "transform-meteor-async-await",
+    visitor: {
+      Function: {
+        exit: function (path) {
+          if (this.opts.useNativeAsyncAwait !== false) {
+            return;
+          }
+
+          const node = path.node;
+          if (!node.async) {
+            return;
+          }
+
+          // The original function becomes a non-async function that
+          // returns a Promise.
+          node.async = false;
+
+          // The inner function should inherit lexical environment items
+          // like `this`, `super`, and `arguments` from the outer
+          // function, and arrow functions provide exactly that behavior.
+          const innerFn = t.arrowFunctionExpression(
+            // The inner function has no parameters of its own, but can
+            // refer to the outer parameters of the original function.
+            [],
+            node.body,
+            // The inner function called by Promise.asyncApply should be
+            // async if we have native async/await support.
+            !!this.opts.useNativeAsyncAwait
+          );
+
+          const promiseResultExpression = t.callExpression(
+            t.memberExpression(
+              t.identifier("Promise"),
+              t.identifier("asyncApply"),
+              false
+            ), [innerFn]
+          );
+
+          // Calling the async function with Promise.asyncApply is
+          // important to ensure that the part before the first await
+          // expression runs synchronously in its own Fiber, even when
+          // there is native support for async/await.
+          if (node.type === "ArrowFunctionExpression") {
+            node.body = promiseResultExpression;
+          } else {
+            node.body = t.blockStatement([
+              t.returnStatement(promiseResultExpression)
+            ]);
+          }
+        }
+      },
+
+      AwaitExpression: function (path) {
+        if (this.opts.useNativeAsyncAwait !== false) {
+          // No need to transform await expressions if we have native
+          // support for them.
+          return;
+        }
+
+        const node = path.node;
+        path.replaceWith(t.callExpression(
+          t.memberExpression(
+            t.identifier("Promise"),
+            t.identifier(node.all ? "awaitAll" : "await"),
+            false
+          ),
+          [node.argument]
+        ));
+      }
+    }
+  };
+};