fix: better support worker threads

Author: alexander-akait

src/index.js

@@ -76,6 +76,11 @@ const { minify: minifyWorker } = require("./minify");
  * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
  */
 
+/**
+ * @template T
+ * @typedef {T extends any[] ? { [P in keyof T]?: InferDefaultType<T[P]> } : InferDefaultType<T>} MinimizerOptions
+ */
+
 /**
  * @template T
  * @callback BasicMinimizerImplementation
@@ -86,13 +91,13 @@ const { minify: minifyWorker } = require("./minify");
  */
 
 /**
- * @template T
- * @typedef {T extends any[] ? { [P in keyof T]: BasicMinimizerImplementation<T[P]>; } : BasicMinimizerImplementation<T>} MinimizerImplementation
+ * @typedef {object} MinimizeFunctionHelpers
+ * @property {() => boolean | undefined} [supportsWorkerThreads]
  */
 
 /**
  * @template T
- * @typedef {T extends any[] ? { [P in keyof T]?: InferDefaultType<T[P]> } : InferDefaultType<T>} MinimizerOptions
+ * @typedef {T extends any[] ? { [P in keyof T]: BasicMinimizerImplementation<T[P]> & MinimizeFunctionHelpers; } : BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} MinimizerImplementation
  */
 
 /**
@@ -399,6 +404,18 @@ class CssMinimizerPlugin {
       : Math.min(parallel || 0, cpus.length - 1);
   }
 
+  /**
+   * @private
+   * @template T
+   * @param {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} implementation
+   * @returns {boolean}
+   */
+  static isSupportsWorkerThreads(implementation) {
+    return typeof implementation.supportsWorkerThreads !== "undefined"
+      ? implementation.supportsWorkerThreads() !== false
+      : true;
+  }
+
   /**
    * @private
    * @param {Compiler} compiler
@@ -480,7 +497,15 @@ class CssMinimizerPlugin {
         initializedWorker = /** @type {MinimizerWorker<T>} */ (
           new Worker(require.resolve("./minify"), {
             numWorkers: numberOfWorkers,
-            enableWorkerThreads: true,
+            enableWorkerThreads: Array.isArray(
+              this.options.minimizer.implementation,
+            )
+              ? this.options.minimizer.implementation.every((item) =>
+                  CssMinimizerPlugin.isSupportsWorkerThreads(item),
+                )
+              : CssMinimizerPlugin.isSupportsWorkerThreads(
+                  this.options.minimizer.implementation,
+                ),
           })
         );
 

src/utils.js

@@ -186,6 +186,8 @@ async function cssnanoMinify(
   };
 }
 
+cssnanoMinify.supportsWorkerThreads = () => true;
+
 /* istanbul ignore next */
 /**
  * @param {Input} input
@@ -213,6 +215,8 @@ async function cssoMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+cssoMinify.supportsWorkerThreads = () => true;
+
 /* istanbul ignore next */
 /**
  * @param {Input} input
@@ -256,6 +260,8 @@ async function cleanCssMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+cleanCssMinify.supportsWorkerThreads = () => true;
+
 /* istanbul ignore next */
 /**
  * @param {Input} input
@@ -347,6 +353,8 @@ async function esbuildMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+esbuildMinify.supportsWorkerThreads = () => false;
+
 // TODO remove in the next major release
 /* istanbul ignore next */
 /**
@@ -392,6 +400,8 @@ async function parcelCssMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+parcelCssMinify.supportsWorkerThreads = () => false;
+
 /* istanbul ignore next */
 /**
  * @param {Input} input
@@ -436,6 +446,8 @@ async function lightningCssMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+lightningCssMinify.supportsWorkerThreads = () => false;
+
 /* istanbul ignore next */
 /**
  * @param {Input} input
@@ -490,6 +502,8 @@ async function swcMinify(input, sourceMap, minimizerOptions) {
   };
 }
 
+swcMinify.supportsWorkerThreads = () => false;
+
 /**
  * @template T
  * @param fn {(function(): any) | undefined}

types/index.d.ts

@@ -34,6 +34,13 @@ declare class CssMinimizerPlugin<T = CssNanoOptionsExtended> {
    * @returns {number}
    */
   private static getAvailableNumberOfCores;
+  /**
+   * @private
+   * @template T
+   * @param {BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} implementation
+   * @returns {boolean}
+   */
+  private static isSupportsWorkerThreads;
   /**
    * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>} [options]
    */
@@ -91,9 +98,10 @@ declare namespace CssMinimizerPlugin {
     Input,
     CustomOptions,
     InferDefaultType,
+    MinimizerOptions,
     BasicMinimizerImplementation,
+    MinimizeFunctionHelpers,
     MinimizerImplementation,
-    MinimizerOptions,
     InternalOptions,
     InternalResult,
     Parallel,
@@ -164,17 +172,23 @@ type CustomOptions = {
   [key: string]: any;
 };
 type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
+type MinimizerOptions<T> = T extends any[]
+  ? { [P in keyof T]?: InferDefaultType<T[P]> }
+  : InferDefaultType<T>;
 type BasicMinimizerImplementation<T> = (
   input: Input,
   sourceMap: RawSourceMap | undefined,
   minifyOptions: InferDefaultType<T>,
 ) => Promise<MinimizedResult>;
+type MinimizeFunctionHelpers = {
+  supportsWorkerThreads?: (() => boolean | undefined) | undefined;
+};
 type MinimizerImplementation<T> = T extends any[]
-  ? { [P in keyof T]: BasicMinimizerImplementation<T[P]> }
-  : BasicMinimizerImplementation<T>;
-type MinimizerOptions<T> = T extends any[]
-  ? { [P in keyof T]?: InferDefaultType<T[P]> }
-  : InferDefaultType<T>;
+  ? {
+      [P in keyof T]: BasicMinimizerImplementation<T[P]> &
+        MinimizeFunctionHelpers;
+    }
+  : BasicMinimizerImplementation<T> & MinimizeFunctionHelpers;
 type InternalOptions<T> = {
   name: string;
   input: string;

types/utils.d.ts

@@ -34,6 +34,9 @@ export function cssnanoMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions?: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace cssnanoMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -45,6 +48,9 @@ export function cssoMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace cssoMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -56,6 +62,9 @@ export function cleanCssMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace cleanCssMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -67,6 +76,9 @@ export function esbuildMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace esbuildMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -78,6 +90,9 @@ export function parcelCssMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace parcelCssMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -89,6 +104,9 @@ export function lightningCssMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace lightningCssMinify {
+  function supportsWorkerThreads(): boolean;
+}
 /**
  * @param {Input} input
  * @param {RawSourceMap | undefined} sourceMap
@@ -100,3 +118,6 @@ export function swcMinify(
   sourceMap: RawSourceMap | undefined,
   minimizerOptions: CustomOptions,
 ): Promise<MinimizedResult>;
+export namespace swcMinify {
+  function supportsWorkerThreads(): boolean;
+}