fix: keep the shebang, report a throwing banner helper, and key the cache on it

An end banner now keeps the shebang it was split from, a formatBanner or
getBannerPosition that throws becomes an error of that asset rather than
rejecting processAssets, and a declared helper's source joins the cache
and chunk-hash identity.

Author: alexander-akait

src/index.js

@@ -1188,20 +1188,32 @@ class MinimizerPlugin {
                 const positioned = helpers.find(
                   (fn) => typeof fn.getBannerPosition === "function",
                 );
-                const comment = formatter
-                  ? formatter(String(banner))
-                  : `/*! ${banner} */`;
-
-                output.source =
-                  positioned &&
-                  /** @type {() => "start" | "end" | undefined} */
-                  (positioned.getBannerPosition)() === "end"
-                    ? new ConcatSource(output.source, comment)
-                    : new ConcatSource(
-                        shebang ? `${shebang}\n` : "",
-                        `${comment}\n`,
-                        output.source,
-                      );
+
+                // The helpers are the minimizer's code, so one that throws is
+                // reported against this asset like a failed minify.
+                try {
+                  const comment = formatter
+                    ? formatter(String(banner))
+                    : `/*! ${banner} */`;
+                  const head = shebang ? `${shebang}\n` : "";
+
+                  output.source =
+                    positioned &&
+                    /** @type {() => "start" | "end" | undefined} */
+                    (positioned.getBannerPosition)() === "end"
+                      ? new ConcatSource(head, output.source, comment)
+                      : new ConcatSource(head, `${comment}\n`, output.source);
+                } catch (error) {
+                  compilation.errors.push(
+                    MinimizerPlugin.buildError(
+                      /** @type {Error | ErrorObject | string} */
+                      (error),
+                      name,
+                    ),
+                  );
+
+                  return;
+                }
               }
             }
 
@@ -2482,8 +2494,17 @@ class MinimizerPlugin {
             ? fn.getMinimizerVersion() || "0.0.0"
             : "0.0.0";
 
+        // A banner helper changes the bytes written, so its source joins the
+        // identity; only where one is declared, so no other key moves.
+        const banner =
+          fn &&
+          (typeof fn.formatBanner === "function" ||
+            typeof fn.getBannerPosition === "function")
+            ? `|${String(fn.formatBanner)}|${String(fn.getBannerPosition)}`
+            : "";
+
         if (!ref) {
-          return version;
+          return `${version}${banner}`;
         }
 
         // Which module it is, read against the build rather than the disk: two
@@ -2496,7 +2517,7 @@ class MinimizerPlugin {
           )
           .replace(/\\/g, "/");
 
-        return `${version}|${where}|${ref.export || ""}`;
+        return `${version}|${where}|${ref.export || ""}${banner}`;
       };
       const data = getSerializeJavascript()({
         minimizer: Array.isArray(this.options.minimizer.implementation)

test/minify-option.test.js

@@ -280,6 +280,82 @@ describe("minify option", () => {
     expect(getWarnings(stats)).toMatchSnapshot("warnings");
   });
 
+  it("should keep the shebang first when the banner goes at the end", async () => {
+    const compiler = getCompiler({
+      entry: path.resolve(__dirname, "./fixtures/minify/es6.js"),
+    });
+
+    const minify = async () => ({
+      code: "#!/usr/bin/env node\nrun()",
+      extractedComments: ["/*! @license MIT */"],
+    });
+
+    minify.formatBanner = (banner) => `/* ${banner} */`;
+    minify.getBannerPosition = () => "end";
+
+    new MinimizerPlugin({ parallel: false, minify }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(readAsset("main.js", compiler, stats)).toBe(
+      "#!/usr/bin/env node\nrun()/* For license information please see main.js.LICENSE.txt */",
+    );
+  });
+
+  it("should report a banner helper that throws as an error of the asset", async () => {
+    const compiler = getCompiler({
+      entry: path.resolve(__dirname, "./fixtures/minify/es6.js"),
+      bail: false,
+    });
+
+    const minify = async () => ({
+      code: "run()",
+      extractedComments: ["/*! @license MIT */"],
+    });
+
+    minify.formatBanner = () => {
+      throw new Error("no banner");
+    };
+
+    new MinimizerPlugin({ parallel: false, minify }).apply(compiler);
+
+    const stats = await compile(compiler);
+
+    expect(stats.compilation.errors).toHaveLength(1);
+    expect(stats.compilation.errors[0].message).toMatch(
+      /main\.js from minimizer-webpack-plugin[\s\S]*no banner/,
+    );
+  });
+
+  it("should name a chunk apart when only its minimizer's banner helper differs", async () => {
+    /**
+     * @param {(banner: string) => string} formatBanner the helper
+     * @returns {Promise<string[]>} the emitted script names
+     */
+    const build = async (formatBanner) => {
+      const compiler = getCompiler({
+        entry: path.resolve(__dirname, "./fixtures/minify/es6.js"),
+        output: { filename: "[name].[chunkhash].js" },
+      });
+
+      const minify = async () => ({ code: "run()" });
+
+      minify.formatBanner = formatBanner;
+
+      new MinimizerPlugin({ parallel: false, minify }).apply(compiler);
+
+      const stats = await compile(compiler);
+
+      return Object.keys(stats.compilation.assets).filter((name) =>
+        name.endsWith(".js"),
+      );
+    };
+
+    expect(await build((banner) => `/* ${banner} */`)).not.toEqual(
+      await build((banner) => `<!-- ${banner} -->`),
+    );
+  });
+
   it("should work with source maps", async () => {
     const compiler = getCompiler({
       devtool: "source-map",