feat(terser): parallel execution

packages/terser/package.json

@@ -61,9 +61,12 @@
     }
   },
   "dependencies": {
+    "serialize-javascript": "^6.0.0",
+    "smob": "^0.0.6",
     "terser": "^5.15.1"
   },
   "devDependencies": {
+    "@types/serialize-javascript": "^5.0.2",
     "rollup": "^3.0.0-7",
     "typescript": "^4.8.3"
   },

packages/terser/src/index.ts

@@ -1,24 +1,8 @@
-import { NormalizedOutputOptions, RenderedChunk } from 'rollup';
-import { minify, MinifyOptions } from 'terser';
+import { runWorker } from './worker';
+import terser from './module';
 
-export default function terser(options?: MinifyOptions) {
-  return {
-    name: 'terser',
+Promise.resolve().then(() => runWorker());
 
-    async renderChunk(code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) {
-      const defaultOptions: MinifyOptions = {
-        sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
-      };
+export * from './type';
 
-      if (outputOptions.format === 'es') {
-        defaultOptions.module = true;
-      }
-
-      if (outputOptions.format === 'cjs') {
-        defaultOptions.toplevel = true;
-      }
-
-      return minify(code, { ...defaultOptions, ...(options || {}) });
-    }
-  };
-}
+export default terser;

packages/terser/src/module.ts

@@ -0,0 +1,67 @@
+import { NormalizedOutputOptions, RenderedChunk } from 'rollup';
+import { hasOwnProperty, isObject, merge } from 'smob';
+
+import { Options } from './type';
+import { callWorker } from './worker';
+
+export default function terser(options: Options = {}) {
+  return {
+    name: 'terser',
+
+    async renderChunk(code: string, chunk: RenderedChunk, outputOptions: NormalizedOutputOptions) {
+      const defaultOptions: Options = {
+        sourceMap: outputOptions.sourcemap === true || typeof outputOptions.sourcemap === 'string'
+      };
+
+      if (outputOptions.format === 'es') {
+        defaultOptions.module = true;
+      }
+
+      if (outputOptions.format === 'cjs') {
+        defaultOptions.toplevel = true;
+      }
+
+      try {
+        const { code: result, nameCache } = await callWorker(__filename, {
+          code,
+          options: merge({}, options || {}, defaultOptions)
+        });
+
+        if (options.nameCache && nameCache) {
+          let vars: Record<string, any> = {
+            props: {}
+          };
+
+          if (hasOwnProperty(options.nameCache, 'vars') && isObject(options.nameCache.vars)) {
+            vars = merge({}, options.nameCache.vars || {}, vars);
+          }
+
+          if (hasOwnProperty(nameCache, 'vars') && isObject(nameCache.vars)) {
+            vars = merge({}, nameCache.vars, vars);
+          }
+
+          // eslint-disable-next-line no-param-reassign
+          options.nameCache.vars = vars;
+
+          let props: Record<string, any> = {};
+
+          if (hasOwnProperty(options.nameCache, 'props') && isObject(options.nameCache.props)) {
+            // eslint-disable-next-line prefer-destructuring
+            props = options.nameCache.props;
+          }
+
+          if (hasOwnProperty(nameCache, 'props') && isObject(nameCache.props)) {
+            props = merge({}, nameCache.props, props);
+          }
+
+          // eslint-disable-next-line no-param-reassign
+          options.nameCache.props = props;
+        }
+
+        return result;
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+  };
+}

packages/terser/src/type.ts

@@ -0,0 +1,20 @@
+import { MinifyOptions } from 'terser';
+
+export interface Options extends MinifyOptions {
+  nameCache?: Record<string, any>;
+}
+
+export interface WorkerContext {
+  code: string;
+  options: Options;
+}
+
+export interface WorkerContextSerialized {
+  code: string;
+  options: string;
+}
+
+export interface WorkerOutput {
+  code: string;
+  nameCache?: Options['nameCache'];
+}

packages/terser/src/worker.ts

@@ -0,0 +1,68 @@
+import process from 'process';
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
+
+import serializeJavascript from 'serialize-javascript';
+
+import { hasOwnProperty, isObject } from 'smob';
+
+import { minify } from 'terser';
+
+import { WorkerContext, WorkerContextSerialized, WorkerOutput } from './type';
+
+/**
+ * Duck typing worker context.
+ *
+ * @param input
+ */
+function isWorkerContextSerialized(input: unknown): input is WorkerContextSerialized {
+  return (
+    isObject(input) &&
+    hasOwnProperty(input, 'code') &&
+    typeof input.code === 'string' &&
+    hasOwnProperty(input, 'options') &&
+    typeof input.options === 'string'
+  );
+}
+
+export async function callWorker(filePath: string, context: WorkerContext) {
+  return new Promise<WorkerOutput>((resolve, reject) => {
+    const worker = new Worker(filePath, {
+      workerData: {
+        code: context.code,
+        options: serializeJavascript(context.options)
+      }
+    });
+
+    worker.on('message', (data) => resolve(data));
+
+    worker.on('error', reject);
+
+    worker.on('exit', (code) => {
+      if (code !== 0) reject(new Error(`Minify worker stopped with exit code ${code}`));
+    });
+  });
+}
+
+export async function runWorker() {
+  if (isMainThread || !parentPort || !isWorkerContextSerialized(workerData)) {
+    return;
+  }
+
+  try {
+    // eslint-disable-next-line no-eval
+    const eval2 = eval;
+
+    const options = eval2(`(${workerData.options})`);
+
+    const result = await minify(workerData.code, options);
+
+    const output: WorkerOutput = {
+      code: result.code || workerData.code,
+      nameCache: options.nameCache
+    };
+
+    parentPort.postMessage(output);
+  } catch (e) {
+    process.exit(1);
+  }
+}

packages/terser/test/test.js

@@ -107,7 +107,7 @@ test.serial('throw error on terser fail', async (t) => {
     await bundle.generate({ format: 'esm' });
     t.falsy(true);
   } catch (error) {
-    t.is(error.toString(), 'SyntaxError: Name expected');
+    t.is(error.toString(), 'Error: Minify worker stopped with exit code 1');
   }
 });
 
@@ -127,7 +127,7 @@ test.serial('throw error on terser fail with multiple outputs', async (t) => {
     await Promise.all([bundle.generate({ format: 'cjs' }), bundle.generate({ format: 'esm' })]);
     t.falsy(true);
   } catch (error) {
-    t.is(error.toString(), 'SyntaxError: Name expected');
+    t.is(error.toString(), 'Error: Minify worker stopped with exit code 1');
   }
 });