fix(worker): preserve regexp options for process workers

Author: xiaoxiaojx

.changeset/fix-regexp-options-in-process-workers.md

@@ -0,0 +1,5 @@
+---
+"minimizer-webpack-plugin": patch
+---
+
+Fallback to the serialized worker path when regular expression options are used with process workers that cannot preserve them.

src/implementation.js

@@ -104,6 +104,36 @@ function holdsFunction(value, seen = new Set()) {
   );
 }
 
+/**
+ * Whether a value holds a regular expression anywhere inside it.
+ * Child-process workers on runtimes without worker threads use the default
+ * process IPC serializer, which does not preserve regular expressions.
+ * @param {unknown} value what a worker would be handed
+ * @param {Set<unknown>=} seen values already walked
+ * @returns {boolean} true when a regular expression is in there
+ */
+function holdsRegExp(value, seen = new Set()) {
+  if (value instanceof RegExp) {
+    return true;
+  }
+  if (!value || typeof value !== "object" || seen.has(value)) {
+    return false;
+  }
+  seen.add(value);
+
+  if (value instanceof Map) {
+    return [...value].some(
+      ([key, one]) => holdsRegExp(key, seen) || holdsRegExp(one, seen),
+    );
+  }
+  if (value instanceof Set) {
+    return [...value].some((one) => holdsRegExp(one, seen));
+  }
+  return Object.values(/** @type {Record<string, unknown>} */ (value)).some(
+    (one) => holdsRegExp(one, seen),
+  );
+}
+
 /**
  * True when every `minimizer.implementation` is a module path (`string` or
  * `{ path, export }`). Inline minify functions keep `transform`. When
@@ -112,9 +142,10 @@ function holdsFunction(value, seen = new Set()) {
  * whole asset task, even if that asset's own matched minimizers are paths.
  * @template T
  * @param {import("./index.js").InternalOptions<T>} options options
+ * @param {{ enableWorkerThreads?: boolean }=} capabilities worker capabilities
  * @returns {boolean} whether `worker.minify` can run without `transform`
  */
-function canMinifyByPath(options) {
+function canMinifyByPath(options, capabilities = {}) {
   /**
    * @param {unknown} implementation implementation
    * @returns {boolean} true when a module path is known
@@ -138,6 +169,13 @@ function canMinifyByPath(options) {
   ) {
     return false;
   }
+  if (
+    capabilities.enableWorkerThreads === false &&
+    (holdsRegExp(options.extractComments) ||
+      holdsRegExp(options.minimizer.options))
+  ) {
+    return false;
+  }
 
   if (!options.embedded) {
     return true;
@@ -146,6 +184,12 @@ function canMinifyByPath(options) {
   if (holdsFunction(options.embedded.options)) {
     return false;
   }
+  if (
+    capabilities.enableWorkerThreads === false &&
+    holdsRegExp(options.embedded.options)
+  ) {
+    return false;
+  }
 
   const embedded = Array.isArray(options.embedded.implementation)
     ? options.embedded.implementation

src/index.js

@@ -44,6 +44,23 @@ const {
   uglifyJsMinify,
 } = require("./utils");
 
+/** @type {boolean | undefined} */
+let _canUseWorkerThreads;
+
+const canUseWorkerThreads = () => {
+  if (_canUseWorkerThreads !== undefined) {
+    return _canUseWorkerThreads;
+  }
+  try {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- feature detection for Node 10
+    require("worker_threads");
+    _canUseWorkerThreads = true;
+  } catch (_error) {
+    _canUseWorkerThreads = false;
+  }
+  return _canUseWorkerThreads;
+};
+
 /** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
 /** @typedef {import("webpack").Compiler} Compiler */
 /** @typedef {import("webpack").Compilation} Compilation */
@@ -840,12 +857,14 @@ class MinimizerPlugin {
       ({ fn }) =>
         typeof fn.supportsBinary === "function" && fn.supportsBinary(),
     );
-    const enableWorkerThreads = minimizerSlots.every(
-      ({ fn }, i) =>
-        !workerCapable[i] ||
-        typeof fn.supportsWorkerThreads === "undefined" ||
-        fn.supportsWorkerThreads() !== false,
-    );
+    const enableWorkerThreads =
+      canUseWorkerThreads() &&
+      minimizerSlots.every(
+        ({ fn }, i) =>
+          !workerCapable[i] ||
+          typeof fn.supportsWorkerThreads === "undefined" ||
+          fn.supportsWorkerThreads() !== false,
+      );
     const needCreateWorker =
       optimizeOptions.availableNumberOfCores > 0 &&
       workerCapable.includes(true);
@@ -908,7 +927,11 @@ class MinimizerPlugin {
       // module paths — including every entry on `embedded`, not just the
       // asset's matched subset. A mixed path + inline-function config keeps
       // the whole asset on `transform`.
-      if (canMinifyByPath(options)) {
+      if (
+        canMinifyByPath(options, {
+          enableWorkerThreads,
+        })
+      ) {
         return getWorker().minify(options);
       }
 

test/implementation.test.js

@@ -164,6 +164,34 @@ describe("canMinifyByPath", () => {
     ).toBe(true);
   });
 
+  it("should reject a RegExp option when the worker cannot transfer it", () => {
+    expect(
+      canMinifyByPath(
+        {
+          minimizer: {
+            implementation: pathImpl,
+            options: { comments: /license/i },
+          },
+        },
+        { enableWorkerThreads: false },
+      ),
+    ).toBe(false);
+  });
+
+  it("should allow a RegExp option when the worker can transfer it", () => {
+    expect(
+      canMinifyByPath(
+        {
+          minimizer: {
+            implementation: pathImpl,
+            options: { comments: /license/i },
+          },
+        },
+        { enableWorkerThreads: true },
+      ),
+    ).toBe(true);
+  });
+
   it("should allow embedded when every implementation is a path", () => {
     expect(
       canMinifyByPath({