@meteorjs/babel 7.18.0-beta.5 → 7.19.0-beta.1

package/options.js

@@ -35,6 +35,10 @@ function getReifyOptions(features) {
       // wrap it with a function to rename the `module` identifier.
       reifyOptions.moduleAlias = "module";
     }
+
+    if (features.topLevelAwait) {
+      reifyOptions.topLevelAwait = true;
+    }
   }
 
   return reifyOptions;
@@ -182,18 +186,20 @@ function getDefaultsForNode8(features) {
       require("@babel/plugin-syntax-object-rest-spread"),
       require("@babel/plugin-proposal-object-rest-spread")
     );
-
-    // Ensure that async functions run in a Fiber, while also taking
-    // full advantage of native async/await support in Node 8.
+    // 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) {
-      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,
-      }]);
+      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,
+        },
+      ]);
     }
     // Enable async generator functions proposal.
     combined.plugins.push(require("@babel/plugin-proposal-async-generator-functions"));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@meteorjs/babel",
   "author": "Meteor <dev@meteor.com>",
-  "version": "7.18.0-beta.5",
+  "version": "7.19.0-beta.1",
   "license": "MIT",
   "description": "Babel wrapper package for use with Meteor",
   "keywords": [
@@ -41,7 +41,7 @@
     "@babel/template": "^7.16.7",
     "@babel/traverse": "^7.17.0",
     "@babel/types": "^7.17.0",
-    "@meteorjs/reify": "0.23.0",
+    "@meteorjs/reify": "https://github.com/meteor/reify/tarball/5078da9d0827cc17741504762f3a7f71c3b01448",
     "babel-preset-meteor": "^7.10.0",
     "babel-preset-minify": "^0.5.1",
     "convert-source-map": "^1.6.0",
@@ -54,7 +54,6 @@
     "@babel/plugin-syntax-decorators": "7.14.5",
     "d3": "4.13.0",
     "fibers": "5.0.0",
-    "meteor-promise": "0.9.0",
     "mocha": "6.2.3",
     "promise": "8.1.0",
     "source-map": "0.6.1"

package/runtime.js

@@ -11,21 +11,3 @@ Module.prototype.resolve = function (id) {
 
 require("@meteorjs/reify/lib/runtime").enable(Module.prototype);
 
-if (!process.env.DISABLE_FIBERS) {
-  require("meteor-promise").makeCompatible(
-      global.Promise = global.Promise ||
-          require("promise/lib/es6-extensions"),
-      require("fibers")
-  );
-
-// If Promise.asyncApply is defined, use it to wrap calls to
-// regeneratorRuntime.async so that the entire async function will run in
-// its own Fiber, not just the code that comes after the first await.
-  if (typeof Promise.asyncApply === "function") {
-    var regeneratorRuntime = require("@babel/runtime/regenerator");
-    var realAsync = regeneratorRuntime.async;
-    regeneratorRuntime.async = function (innerFn) {
-      return Promise.asyncApply(realAsync, regeneratorRuntime, arguments);
-    };
-  }
-}

package/plugins/async-await.js

@@ -1,74 +0,0 @@
-"use strict";
-
-module.exports = function (babel) {
-  const t = babel.types;
-
-  return {
-    name: "transform-meteor-async-await",
-    visitor: {
-      Function: {
-        exit: function (path) {
-          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) {
-          // 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]
-        ));
-      }
-    }
-  };
-};