Support async babel plugins

This allows people to use async babel plugins and babel plugins authored as ES modules.

It's a relatively small change since this package was already async in the right areas, it was just calling the synchronous babel APIs when it could use the async equivalent.

Author: ef4

lib/parallel-api.js

@@ -236,35 +236,36 @@ function serialize(options) {
   return serialized;
 }
 
-function transformString(string, options, buildOptions) {
-  const isParallelizable = transformIsParallelizable(options.babel).isParallelizable;
+async function transformString(string, options, buildOptions) {
+  const isParallelizable = transformIsParallelizable(
+    options.babel
+  ).isParallelizable;
   if (JOBS > 1 && isParallelizable) {
     let pool = getWorkerPool();
-    _logger.info('transformString is parallelizable');
-    let serializedObj = { babel : serialize(options.babel), 'cacheKey': options.cacheKey };
-    return pool
-      .exec('transform', [string, serializedObj])
-      .then((result) => {
-        if (result.error) {
-          // when the worker has an error it still resolves, but it has `error`
-          // and `stack` properties instead of `code` + `metadata`
-          //
-          // throw an error to properly fail the "top level" process as needed
-          throw new Error(result.error + result.stack);
-        }
-
-        return result;
-      });
+    _logger.info("transformString is parallelizable");
+    let serializedObj = {
+      babel: serialize(options.babel),
+      cacheKey: options.cacheKey,
+    };
+    let result = await pool.exec("transform", [string, serializedObj]);
+
+    if (result.error) {
+      // when the worker has an error it still resolves, but it has `error`
+      // and `stack` properties instead of `code` + `metadata`
+      //
+      // throw an error to properly fail the "top level" process as needed
+      throw new Error(result.error + result.stack);
+    }
+
+    return result;
   } else {
     if (JOBS <= 1) {
-      _logger.info('JOBS <= 1, skipping worker, using main thread');
+      _logger.info("JOBS <= 1, skipping worker, using main thread");
     } else {
-      _logger.info('transformString is NOT parallelizable');
+      _logger.info("transformString is NOT parallelizable");
     }
 
-    return new Promise(resolve => {
-      resolve(transpiler.transform(string, deserialize(options)));
-    });
+    return await transpiler.transformAsync(string, deserialize(options));
   }
 }
 

lib/worker.js

@@ -6,22 +6,23 @@ const Promise = require('rsvp').Promise;
 const ParallelApi = require('./parallel-api');
 
 // transpile the input string, using the input options
-function transform(string, options) {
-  return Promise.resolve().then(() => {
-    try {
-      let result = transpiler.transform(string, ParallelApi.deserialize(options));
+async function transform(string, options) {
+  try {
+    let result = await transpiler.transformAsync(
+      string,
+      ParallelApi.deserialize(options)
+    );
 
-      return {
-        code: result.code,
-        metadata: result.metadata
-      };
-    } catch (error) {
-      return {
-        error: error.message,
-        stack: error.stack,
-      };
-    }
-  });
+    return {
+      code: result.code,
+      metadata: result.metadata,
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      stack: error.stack,
+    };
+  }
 }
 
 // create worker and register public functions

tests/test.js

@@ -309,6 +309,27 @@ describe('transpile ES6 to ES5', function() {
     });
   });
 
+  it('supports async babel plugins (non-parallel implementation)', function () {
+    return babel('files', {
+      babel: {
+        inputSourceMap: false,
+        sourceMap: false,
+        plugins: [
+          '@babel/transform-strict-mode',
+          '@babel/transform-block-scoping',
+          async function() { return { visitor: {} }}
+        ]
+      }
+    }).then(results => {
+      let outputPath = results.directory;
+
+      let output = fs.readFileSync(path.join(outputPath, 'fixtures.js'), 'utf8');
+      let input = fs.readFileSync(path.join(expectations, 'expected.js'), 'utf8');
+
+      expect(output).to.eql(input);
+    });
+  });
+
   it('basic - parallel API', function () {
     return babel('files', {
       babel: {
@@ -1577,4 +1598,11 @@ describe('workerpool', function() {
       }
     });
   });
+
+  it("supports async babel plugins (parallel implementation)", async function () {
+    // a plugin whose factory is async is enough to exercise the behavior. Babel
+    // will throw if you use `transform` as opposed to `transformAsync`.
+    options.babel.plugins.push(require.resolve('./utils/parallel-plugin'));
+    await ParallelApi.transformString(stringToTransform, options)
+  });
 });

tests/utils/parallel-plugin.js

@@ -0,0 +1,3 @@
+module.exports = async function() {
+  return { visitor: {} }
+}