feat: add filter helper to dispatch assets per-minimizer

Each built-in minimizer now exposes a `filter(name, info)` helper based on
file extension. When `minify` is an array, each asset is dispatched only to
the minimizers whose `filter` accepts it; chain semantics still apply when
multiple minimizers claim the same asset. The `test` option defaults to
`undefined` for the array form so that filters can decide. This lets a
single `TerserPlugin` instance handle JS/CSS/HTML/JSON with one shared
worker pool instead of forcing a separate plugin instance per type.

Author: claude

README.md

@@ -321,7 +321,34 @@ Allows you to override the default minify function.
 By default plugin uses [terser](https://github.com/terser/terser) package.
 Useful for using and testing unpublished versions or forks.
 
-An array of functions can also be provided to chain multiple minimizers — the output of each minimizer is fed as input to the next. When an array is used, the [`minimizerOptions`](#minimizeroptions) option may also be an array (index-paired with `minify`) or a single object that is reused for every minimizer.
+An array of functions can also be provided. Each minimizer can expose a
+`filter(name, info)` helper that decides whether it should run on a given
+asset; the plugin dispatches each asset only to the minimizers whose `filter`
+accepts it (or runs them all when no filter is set). All built-in minimizers
+ship with a `filter` that matches their natural extension, so a single plugin
+instance and a single worker pool can handle JS, CSS, HTML and JSON together
+without juggling multiple `TerserPlugin` instances:
+
+```js
+new TerserPlugin({
+  minify: [
+    TerserPlugin.terserMinify,
+    TerserPlugin.cssnanoMinify,
+    TerserPlugin.htmlMinifierTerser,
+    TerserPlugin.jsonMinify,
+  ],
+});
+```
+
+When more than one minimizer in the array claims the same asset, the chain
+semantic still applies: the output of each accepting minimizer is fed as
+input to the next. The [`minimizerOptions`](#minimizeroptions) option may
+be an array (index-paired with `minify`) or a single object reused by every
+minimizer.
+
+When `minify` is an array, the `test` option defaults to `undefined` so each
+minimizer's `filter` decides which assets it processes. With a single `minify`
+function, `test` keeps its JS-only default of `/\.[cm]?js(\?.*)?$/i`.
 
 > **Warning**
 >
@@ -362,6 +389,12 @@ minify.getMinimizerVersion = () => {
   return packageJson && packageJson.version;
 };
 
+// Restrict the minimizer to the assets it can actually handle. The plugin
+// skips assets for which `filter` returns `false` and (when an array of
+// minimizers is used) dispatches each asset only to the minimizers that
+// accept it. Returning `undefined` is treated as accept.
+minify.filter = (name) => /\.[cm]?js(\?.*)?$/i.test(name);
+
 module.exports = {
   optimization: {
     minimize: true,
@@ -379,11 +412,13 @@ module.exports = {
 
 #### `array`
 
-If an array of functions is passed to the `minify` option, the output of each
-minimizer is fed as input to the next one. The `minimizerOptions` option can be
-either an array of option objects (index-paired with `minify`) or a single
-object that will be shared by all minimizers. Warnings, errors and extracted
-comments from all minimizers are merged together.
+If an array of functions is passed to the `minify` option, each asset is
+dispatched to the minimizers whose `filter` accepts it. When more than one
+minimizer accepts the same asset the output of each is fed as input to the
+next one (the chain semantic). The `minimizerOptions` option can be either an
+array of option objects (index-paired with `minify`) or a single object that
+will be shared by all minimizers. Warnings, errors and extracted comments
+from all running minimizers are merged together.
 
 **webpack.config.js**
 
@@ -407,6 +442,30 @@ module.exports = {
 };
 ```
 
+A single plugin instance can also handle multiple asset types — the built-in
+minimizers each ship with a `filter` matching their natural extension, so JS,
+CSS, HTML and JSON can all be minified by one shared worker pool:
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new TerserPlugin({
+        // `test` defaults to `undefined` here so each filter decides which
+        // assets it handles. Override `test` to narrow further if needed.
+        minify: [
+          TerserPlugin.terserMinify,
+          TerserPlugin.cssnanoMinify,
+          TerserPlugin.htmlMinifierTerser,
+          TerserPlugin.jsonMinify,
+        ],
+      }),
+    ],
+  },
+};
+```
+
 ### `minimizerOptions`
 
 Type:

src/index.js

@@ -124,6 +124,7 @@ const {
  * @property {() => string | undefined=} getMinimizerVersion function that returns version of minimizer
  * @property {() => boolean | undefined=} supportsWorkerThreads true when minimizer support worker threads, otherwise false
  * @property {() => boolean | undefined=} supportsWorker true when minimizer support worker, otherwise false
+ * @property {(name: string, info?: AssetInfo) => boolean | undefined=} filter return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely.
  */
 
 /**
@@ -189,13 +190,17 @@ class TerserPlugin {
 
     // TODO handle json and etc in the next major release
     // TODO make `minimizer` option instead `minify` and `terserOptions` in the next major release, also rename `terserMinify` to `terserMinimize`
+    // When an array of minimizers is supplied, leave `test` undefined so that
+    // each minimizer's own `filter` decides which assets it processes;
+    // otherwise fall back to the JS-only default.
+    const isMinifyArray = Array.isArray(options && options.minify);
     const {
       minify = /** @type {MinimizerImplementation<T>} */ (
         /** @type {unknown} */ (terserMinify)
       ),
       minimizerOptions,
       terserOptions,
-      test = /\.[cm]?js(\?.*)?$/i,
+      test = isMinifyArray ? undefined : /\.[cm]?js(\?.*)?$/i,
       extractComments = true,
       parallel = true,
       include,
@@ -377,6 +382,37 @@ class TerserPlugin {
   async optimize(compiler, compilation, assets, optimizeOptions) {
     const cache = compilation.getCache("TerserWebpackPlugin");
     let numberOfAssets = 0;
+    const allImplementations = Array.isArray(
+      this.options.minimizer.implementation,
+    )
+      ? this.options.minimizer.implementation
+      : null;
+    /**
+     * Apply each minimizer's `filter` helper. For array form, an asset is
+     * accepted when at least one configured minimizer accepts it; for the
+     * single form, the asset must be accepted by that minimizer.
+     * @param {string} name asset name
+     * @param {AssetInfo} info asset info
+     * @returns {boolean} whether at least one minimizer accepts this asset
+     */
+    const isAcceptedByAnyMinimizer = (name, info) => {
+      if (allImplementations) {
+        return allImplementations.some(
+          (impl) =>
+            typeof impl.filter !== "function" ||
+            // eslint-disable-next-line unicorn/no-array-method-this-argument
+            impl.filter(name, info) !== false,
+        );
+      }
+      const single =
+        /** @type {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} */
+        (this.options.minimizer.implementation);
+      return (
+        typeof single.filter !== "function" ||
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        single.filter(name, info) !== false
+      );
+    };
     const assetsForMinify = await Promise.all(
       Object.keys(assets)
         .filter((name) => {
@@ -400,6 +436,10 @@ class TerserPlugin {
             return false;
           }
 
+          if (!isAcceptedByAnyMinimizer(name, info)) {
+            return false;
+          }
+
           return true;
         })
         .map(async (name) => {
@@ -523,11 +563,45 @@ class TerserPlugin {
             input = input.toString();
           }
 
-          const clonedMinimizerOptions = Array.isArray(
-            this.options.minimizer.options,
-          )
-            ? this.options.minimizer.options.map((item) => ({ ...item }))
-            : { .../** @type {T} */ (this.options.minimizer.options) };
+          // Dispatch to only the minimizers whose `filter` accepts this asset.
+          // For the single-implementation form `assetImplementation` matches
+          // the original; for the array form it's the matching subset (still
+          // an array, even when only one entry remains, so chained behavior
+          // is preserved when multiple match).
+          let assetImplementation = this.options.minimizer.implementation;
+          let assetMinimizerOptions = this.options.minimizer.options;
+
+          if (allImplementations) {
+            const matchedIndices = [];
+
+            for (let i = 0; i < allImplementations.length; i++) {
+              const impl = allImplementations[i];
+
+              if (
+                typeof impl.filter !== "function" ||
+                // eslint-disable-next-line unicorn/no-array-method-this-argument
+                impl.filter(name, info) !== false
+              ) {
+                matchedIndices.push(i);
+              }
+            }
+
+            assetImplementation =
+              /** @type {MinimizerImplementation<T>} */
+              (matchedIndices.map((i) => allImplementations[i]));
+
+            if (Array.isArray(this.options.minimizer.options)) {
+              const sourceOptions = this.options.minimizer.options;
+
+              assetMinimizerOptions =
+                /** @type {MinimizerOptions<T>} */
+                (matchedIndices.map((i) => sourceOptions[i] || {}));
+            }
+          }
+
+          const clonedMinimizerOptions = Array.isArray(assetMinimizerOptions)
+            ? assetMinimizerOptions.map((item) => ({ ...item }))
+            : { .../** @type {T} */ (assetMinimizerOptions) };
 
           /**
            * @type {InternalOptions<T>}
@@ -537,7 +611,7 @@ class TerserPlugin {
             input,
             inputSourceMap,
             minimizer: {
-              implementation: this.options.minimizer.implementation,
+              implementation: assetImplementation,
               options:
                 /** @type {MinimizerOptions<T>} */
                 (clonedMinimizerOptions),