fix: preserve entrypoint metadata for appended child compilations

Author: ronakmaheshwari

src/analyzer.js

@@ -197,7 +197,7 @@ function getAssetModulesByChunk(statsAsset, modulesByChunk) {
 /** @typedef {Record<string, Record<string, boolean>>} ChunkToInitialByEntrypoint */
 
 /**
- * @param {StatsCompilation} bundleStats bundle stats
+ * @param {StatsCompilation | undefined} bundleStats bundle stats
  * @returns {ChunkToInitialByEntrypoint} chunk to initial by entrypoint
  */
 function getChunkToInitialByEntrypoint(bundleStats) {
@@ -419,11 +419,16 @@ function getViewerData(bundleStats, bundleDir, opts) {
     }
   }
 
-  /** @typedef {{ size: number, parsedSize?: number, gzipSize?: number, brotliSize?: number, zstdSize?: number, modules: StatsModule[], tree: Folder }} Asset */
+  const rootChunkToInitialByEntrypoint =
+    getChunkToInitialByEntrypoint(bundleStats);
+
+  /** @typedef {{ size: number, parsedSize?: number, gzipSize?: number, brotliSize?: number, zstdSize?: number, modules: StatsModule[], tree: Folder, isInitialByEntrypoint: Record<string, boolean> }} Asset */
 
   const assets = bundleStats.assets.reduce((result, statAsset) => {
     /** @type {StatsModule[]} */
     let assetModules;
+    /** @type {Record<string, boolean>} */
+    let isInitialByEntrypoint;
 
     if (statAsset.isChild) {
       // Preserve child-compilation matching because child assets use a different module list.
@@ -435,10 +440,14 @@ function getViewerData(bundleStats, bundleDir, opts) {
       assetModules = modules.filter((statModule) =>
         assetHasModule(statAsset, statModule),
       );
+      isInitialByEntrypoint =
+        getChunkToInitialByEntrypoint(assetBundles)[statAsset.name] ?? {};
     } else {
       assetModules = /** @type {StatsModule[]} */ (
         rootAssetModules.get(statAsset) || []
       );
+      isInitialByEntrypoint =
+        rootChunkToInitialByEntrypoint[statAsset.name] ?? {};
     }
 
     // A module that is a part of more than one asset is one stats object. Every asset that
@@ -449,6 +458,7 @@ function getViewerData(bundleStats, bundleDir, opts) {
 
     const asset = (result[statAsset.name] = /** @type {Asset} */ ({
       size: statAsset.size,
+      isInitialByEntrypoint,
     }));
     const assetSources =
       bundlesSources && Object.hasOwn(bundlesSources, statAsset.name)
@@ -526,8 +536,6 @@ function getViewerData(bundleStats, bundleDir, opts) {
     return result;
   }, /** @type {Record<string, Asset>} */ ({}));
 
-  const chunkToInitialByEntrypoint = getChunkToInitialByEntrypoint(bundleStats);
-
   return Object.entries(assets).map(([filename, asset]) => ({
     label: filename,
     isAsset: true,
@@ -541,7 +549,7 @@ function getViewerData(bundleStats, bundleDir, opts) {
     brotliSize: asset.brotliSize,
     zstdSize: asset.zstdSize,
     groups: Object.values(asset.tree.children).map((i) => i.toChartData()),
-    isInitialByEntrypoint: chunkToInitialByEntrypoint[filename] ?? {},
+    isInitialByEntrypoint: asset.isInitialByEntrypoint,
   }));
 }
 

test/analyzerUtils.js

@@ -186,6 +186,12 @@ describe("getViewerData", () => {
             chunks: [1],
           },
         ],
+        entrypoints: {
+          firstEntry: {
+            name: "firstEntry",
+            assets: [{ name: "first.js" }],
+          },
+        },
         chunks: [
           {
             id: 1,
@@ -209,6 +215,12 @@ describe("getViewerData", () => {
             chunks: [2],
           },
         ],
+        entrypoints: {
+          secondEntry: {
+            name: "secondEntry",
+            assets: [{ name: "second.js" }],
+          },
+        },
         chunks: [
           {
             id: 2,
@@ -230,7 +242,9 @@ describe("getViewerData", () => {
     const chartData = getViewerData(stats);
     expect(chartData).toHaveLength(2);
     expect(chartData[0].label).toBe("first.js");
+    expect(chartData[0].isInitialByEntrypoint).toEqual({ firstEntry: true });
     expect(chartData[1].label).toBe("second.js");
+    expect(chartData[1].isInitialByEntrypoint).toEqual({ secondEntry: true });
   });
 
   it("maps modules for child compilation assets correctly", () => {
@@ -495,4 +509,83 @@ describe("getViewerData", () => {
     expect(chartData[0].label).toBe("chunk-asset.js");
     expect(chartData[0].groups[0].label).toBe("chunk-mod.js");
   });
+
+  it("preserves entrypoints for both root and child compilations when root also has assets", () => {
+    const stats = {
+      assets: [
+        {
+          name: "root.js",
+          size: 100,
+          chunks: [1],
+        },
+        {
+          name: "unmatched-child.js",
+          size: 50,
+          chunks: [99],
+          isChild: true,
+        },
+      ],
+      entrypoints: {
+        rootEntry: {
+          name: "rootEntry",
+          assets: [{ name: "root.js" }],
+        },
+      },
+      chunks: [
+        {
+          id: 1,
+          modules: [
+            {
+              id: 1,
+              identifier: "./root.js",
+              name: "./root.js",
+              size: 50,
+              chunks: [1],
+            },
+          ],
+        },
+      ],
+      children: [
+        {
+          name: "worker-child",
+          assets: [
+            {
+              name: "worker.js",
+              size: 150,
+              chunks: [2],
+            },
+          ],
+          entrypoints: {
+            workerEntry: {
+              name: "workerEntry",
+              assets: [{ name: "worker.js" }],
+            },
+          },
+          chunks: [
+            {
+              id: 2,
+              modules: [
+                {
+                  id: 2,
+                  identifier: "./worker.js",
+                  name: "./worker.js",
+                  size: 75,
+                  chunks: [2],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    const chartData = getViewerData(stats);
+    expect(chartData).toHaveLength(3);
+    expect(chartData[0].label).toBe("root.js");
+    expect(chartData[0].isInitialByEntrypoint).toEqual({ rootEntry: true });
+    expect(chartData[1].label).toBe("unmatched-child.js");
+    expect(chartData[1].isInitialByEntrypoint).toEqual({});
+    expect(chartData[2].label).toBe("worker.js");
+    expect(chartData[2].isInitialByEntrypoint).toEqual({ workerEntry: true });
+  });
 });