feat: Normalize asset file names

examples/next-js/next.config.js

@@ -3,7 +3,9 @@ const { codecovWebpackPlugin } = require("@codecov/webpack-plugin");
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   webpack: (config, options) => {
-    config.plugins.push(codecovWebpackPlugin({ enableBundleAnalysis: true }));
+    config.plugins.push(
+      codecovWebpackPlugin({ enableBundleAnalysis: true, dryRun: true }),
+    );
 
     return config;
   },

examples/rollup/rollup.config.ts

@@ -19,6 +19,6 @@ export default defineConfig({
     resolve(), // tells Rollup how to find date-fns in node_modules
     commonjs(), // converts date-fns to ES modules
     production && terser(), // minify, but only in production
-    codecovRollupPlugin({ enableBundleAnalysis: true }),
+    codecovRollupPlugin({ enableBundleAnalysis: true, dryRun: true }),
   ],
 });

examples/vite/vite.config.ts

@@ -4,5 +4,20 @@ import { codecovVitePlugin } from "@codecov/vite-plugin";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [react(), codecovVitePlugin({ enableBundleAnalysis: true })],
+  build: {
+    rollupOptions: {
+      output: {
+        assetFileNames: "[name].[hash].js",
+        chunkFileNames: "[name]-[hash].js",
+      },
+    },
+  },
+  plugins: [
+    react(),
+    codecovVitePlugin({
+      enableBundleAnalysis: true,
+      dryRun: true,
+      globalUploadToken: "super-cool-token",
+    }),
+  ],
 });

examples/webpack/webpack.config.js

@@ -11,6 +11,7 @@ module.exports = {
   plugins: [
     codecovWebpackPlugin({
       enableBundleAnalysis: true,
+      dryRun: true,
     }),
   ],
 };

packages/bundler-plugin-core/src/index.ts

@@ -11,8 +11,8 @@ import {
   type UploadOverrides,
   type Output,
 } from "./types.ts";
-
 import { red } from "./utils/logging.ts";
+import { normalizePath } from "./utils/normalizePath.ts";
 import { bundleAnalysisPluginFactory } from "./bundle-analysis/bundleAnalysisPluginFactory.ts";
 
 const NODE_VERSION_RANGE = ">=18.18.0";
@@ -48,8 +48,6 @@ function codecovUnpluginFactory({
   });
 }
 
-export { red, codecovUnpluginFactory };
-
 export type {
   BundleAnalysisUploadPlugin,
   Asset,
@@ -60,3 +58,5 @@ export type {
   UploadOverrides,
   Output,
 };
+
+export { normalizePath, codecovUnpluginFactory, red };

packages/bundler-plugin-core/src/types.ts

@@ -8,21 +8,21 @@ export interface Dependency {
 export interface Asset {
   name: string;
   size: number;
+  normalized: string;
 }
 
 export interface Chunk {
   id: string;
   uniqueId: string;
   entry: boolean;
   initial: boolean;
-  files: string[];
   names: string[];
+  files: string[];
 }
 
 export interface Module {
   name: string;
   size?: number;
-  chunks: (string | number)[];
   chunkUniqueIds: string[];
 }
 

packages/bundler-plugin-core/src/utils/__tests__/normalizePath.test.ts

@@ -0,0 +1,68 @@
+import { normalizePath } from "../normalizePath";
+
+interface Test {
+  name: string;
+  input: {
+    path: string;
+    format: string;
+  };
+  expected: string;
+}
+
+const tests: Test[] = [
+  {
+    name: "should replace '[hash]' with '*'",
+    input: {
+      path: "test.123.chunk.js",
+      format: "[name].[hash].chunk.js",
+    },
+    expected: "test.*.chunk.js",
+  },
+  {
+    name: "should replace '[contenthash]' with '*'",
+    input: {
+      path: "test.123.chunk.js",
+      format: "[name].[contenthash].chunk.js",
+    },
+    expected: "test.*.chunk.js",
+  },
+  {
+    name: "should replace '[fullhash]' with '*'",
+    input: {
+      path: "test.123.chunk.js",
+      format: "[name].[fullhash].chunk.js",
+    },
+    expected: "test.*.chunk.js",
+  },
+  {
+    name: "should replace '[chunkhash]' with '*'",
+    input: {
+      path: "test.123.chunk.js",
+      format: "[name].[chunkhash].chunk.js",
+    },
+    expected: "test.*.chunk.js",
+  },
+  {
+    name: "should replace multiple hash format occurrences '*'",
+    input: {
+      path: "test.123.456.chunk.js",
+      format: "[name].[hash].[chunkhash].chunk.js",
+    },
+    expected: "test.*.*.chunk.js",
+  },
+  {
+    name: "should brute force wildcard if no hash format is found",
+    input: {
+      path: "test.12345678.chunk.js",
+      format: "[name].chunk.js",
+    },
+    expected: "test.*.chunk.js",
+  },
+];
+
+describe("normalizePath", () => {
+  it.each(tests)("$name", ({ input, expected }) => {
+    const expectation = normalizePath(input.path, input.format);
+    expect(expectation).toEqual(expected);
+  });
+});

packages/bundler-plugin-core/src/utils/normalizePath.ts

@@ -0,0 +1,60 @@
+const HASH_REGEX = /[a-f0-9]{8,}/i;
+const POTENTIAL_HASHES = [
+  "[hash]",
+  "[contenthash]",
+  "[fullhash]",
+  "[chunkhash]",
+];
+
+const escapeRegex = (string: string): string =>
+  string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+
+interface HashMatch {
+  hashString: string;
+  hashIndex: number;
+}
+
+export const normalizePath = (path: string, format: string): string => {
+  // grab all potential hashes in the format string
+  const matches: HashMatch[] = [];
+  for (const hash of POTENTIAL_HASHES) {
+    const index = format.indexOf(hash);
+    if (index !== -1) {
+      matches.push({ hashString: hash, hashIndex: index });
+    }
+  }
+
+  let normalizedPath = path;
+  // loop through all the matches and replace the hash with a wildcard
+  for (const match of matches) {
+    // grab the leading delimiter and create a regex group for it
+    const leadingDelimiter = format.at(match.hashIndex - 1) ?? "";
+    const leadingRegex = `(?<leadingDelimiter>${escapeRegex(
+      leadingDelimiter,
+    )})`;
+
+    // grab the ending delimiter and create a regex group for it
+    const endingDelimiter =
+      format.at(match.hashIndex + match.hashString.length) ?? "";
+    const endingRegex = `(?<endingDelimiter>${escapeRegex(endingDelimiter)})`;
+
+    // create a regex that will match the hash
+    const regexString = `(${leadingRegex}(?<hash>[0-9a-f]+)${endingRegex})`;
+    const HASH_REPLACE_REGEX = new RegExp(regexString, "i");
+
+    // replace the hash with a wildcard and the delimiters
+    normalizedPath = normalizedPath.replace(
+      HASH_REPLACE_REGEX,
+      "$<leadingDelimiter>*$<endingDelimiter>",
+    );
+  }
+
+  // if the path is the same as the normalized path, and the path contains a
+  // hash, then we can assume that something went wrong and we should just
+  // replace/brute force the hash with a wildcard
+  if (normalizedPath === path && HASH_REGEX.test(normalizedPath)) {
+    return normalizedPath.replace(HASH_REGEX, "*");
+  }
+
+  return normalizedPath;
+};

packages/rollup-plugin/src/rollup-bundle-analysis/rollupBundleAnalysisPlugin.ts

@@ -5,6 +5,7 @@
   type Module,
   type BundleAnalysisUploadPlugin,
   red,
+  normalizePath,
 } from "@codecov/bundler-plugin-core";
 
 const PLUGIN_NAME = "codecov-rollup-bundle-analysis-plugin";
@@ -31,17 +32,25 @@
         output.bundleName = `${userOptions.bundleName}-${options.name}`;
       }
 
+      const cwd = process.cwd();
+      const assets: Asset[] = [];
+      const chunks: Chunk[] = [];
+      const moduleByFileName = new Map<string, Module>();
+      const items = Object.values(bundle);
       const customOptions = {
         moduleOriginalSize: false,
         ...options,
       };
 
-      const assets: Asset[] = [];
-      const chunks: Chunk[] = [];
-      const moduleByFileName = new Map<string, Module>();
-      const items = Object.values(bundle);
+      let assetFormatString = "";
+      if (typeof customOptions.assetFileNames === "string") {
+        assetFormatString = customOptions.assetFileNames;
+      }
 
-      const cwd = process.cwd();
+      let chunkFormatString = "";
+      if (typeof customOptions.chunkFileNames === "string") {
+        chunkFormatString = customOptions.chunkFileNames;
+      }
 
       let counter = 0;
       for (const item of items) {
@@ -53,6 +62,7 @@
             assets.push({
               name: fileName,
               size: size,
+              normalized: normalizePath(fileName, assetFormatString),
             });
           } else {
             const fileName = item?.fileName ?? "";
@@ -61,6 +71,7 @@
             assets.push({
               name: fileName,
               size: size,
+              normalized: normalizePath(fileName, assetFormatString),
             });
           }
         }
@@ -75,14 +86,15 @@
           assets.push({
             name: fileName,
             size: size,
+            normalized: normalizePath(fileName, chunkFormatString),
           });
 
           chunks.push({
             id: chunkId,
             uniqueId: uniqueId,
             entry: item?.isEntry,
             initial: item?.isDynamicEntry,
-            files: [item?.fileName],
+            files: [fileName],
             names: [item?.name],
           });
 
@@ -103,17 +115,15 @@
             // if the modules exists append chunk ids to the grabbed module
             // else create a new module and create a new entry in the map
             if (moduleEntry) {
-              moduleEntry.chunks.push(chunkId);
               moduleEntry.chunkUniqueIds.push(uniqueId);
             } else {
               const size = customOptions.moduleOriginalSize
                 ? moduleInfo.originalLength
                 : moduleInfo.renderedLength;
 
-              const module = {
+              const module: Module = {
                 name: relativeModulePathWithPrefix,
                 size: size,
-                chunks: [chunkId],
                 chunkUniqueIds: [uniqueId],
               };