@atlaspack/bundler-default 3.1.3-typescript-5b4d3ad41.0 → 3.2.0

package/src/{idealGraph.ts → idealGraph.js}

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import path from 'path';
 
 import {getFeatureFlag} from '@atlaspack/feature-flags';
@@ -6,7 +8,7 @@ import {
   BitSet,
   ContentGraph,
   Graph,
-  NodeId,
+  type NodeId,
 } from '@atlaspack/graph';
 import type {
   Asset,
@@ -21,37 +23,38 @@ import {DefaultMap, globToRegex} from '@atlaspack/utils';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 
-import {findMergeCandidates, MergeGroup} from './bundleMerge';
+import {findMergeCandidates, type MergeGroup} from './bundleMerge';
 import type {ResolvedBundlerConfig, MergeCandidates} from './bundlerConfig';
 
 /* BundleRoot - An asset that is the main entry of a Bundle. */
 type BundleRoot = Asset;
 
-export type Bundle = {
-  uniqueKey: string | null | undefined;
-  assets: Set<Asset>;
-  internalizedAssets?: BitSet;
-  bundleBehavior?: BundleBehavior | null | undefined;
-  needsStableName: boolean;
-  mainEntryAsset: Asset | null | undefined;
-  size: number;
-  sourceBundles: Set<NodeId>;
-  target: Target;
-  env: Environment;
-  type: string;
-  manualSharedBundle: string | null | undefined; // for naming purposes;
-};
+export type Bundle = {|
+  uniqueKey: ?string,
+  assets: Set<Asset>,
+  internalizedAssets?: BitSet,
+  bundleBehavior?: ?BundleBehavior,
+  needsStableName: boolean,
+  mainEntryAsset: ?Asset,
+  bundleRoots: Set<Asset>,
+  size: number,
+  sourceBundles: Set<NodeId>,
+  target: Target,
+  env: Environment,
+  type: string,
+  manualSharedBundle: ?string, // for naming purposes
+|};
 
 export type DependencyBundleGraph = ContentGraph<
-  | {
-      value: Bundle;
-      type: 'bundle';
-    }
-  | {
-      value: Dependency;
-      type: 'dependency';
-    },
-  number
+  | {|
+      value: Bundle,
+      type: 'bundle',
+    |}
+  | {|
+      value: Dependency,
+      type: 'dependency',
+    |},
+  number,
 >;
 
 const dependencyPriorityEdges = {
@@ -59,7 +62,7 @@ const dependencyPriorityEdges = {
   parallel: 2,
   lazy: 3,
   conditional: 4,
-} as const;
+};
 
 export const idealBundleGraphEdges = Object.freeze({
   default: 1,
@@ -68,20 +71,30 @@ export const idealBundleGraphEdges = Object.freeze({
 
 export type IdealBundleGraph = Graph<
   Bundle | 'root',
-  (typeof idealBundleGraphEdges)[keyof typeof idealBundleGraphEdges]
+  $Values<typeof idealBundleGraphEdges>,
 >;
 
 // IdealGraph is the structure we will pass to decorate,
 // which mutates the assetGraph into the bundleGraph we would
 // expect from default bundler
-export type IdealGraph = {
-  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>;
-  assets: Array<Asset>;
-  bundleGraph: IdealBundleGraph;
-  bundleGroupBundleIds: Set<NodeId>;
-  dependencyBundleGraph: DependencyBundleGraph;
-  manualAssetToBundle: Map<Asset, NodeId>;
-};
+export type IdealGraph = {|
+  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>,
+  assets: Array<Asset>,
+  bundleGraph: IdealBundleGraph,
+  bundleGroupBundleIds: Set<NodeId>,
+  dependencyBundleGraph: DependencyBundleGraph,
+  manualAssetToBundle: Map<Asset, NodeId>,
+|};
+
+function isNonRootBundle(
+  bundle?: Bundle | 'root' | null,
+  message?: string,
+): Bundle {
+  let existingBundle = nullthrows(bundle, message);
+  invariant(existingBundle !== 'root', "Bundle cannot be 'root'");
+
+  return existingBundle;
+}
 
 export function createIdealGraph(
   assetGraph: MutableBundleGraph,
@@ -95,7 +108,7 @@ export function createIdealGraph(
   let dependencyBundleGraph: DependencyBundleGraph = new ContentGraph();
   let assetReference: DefaultMap<
     Asset,
-    Array<[Dependency, Bundle]>
+    Array<[Dependency, Bundle]>,
   > = new DefaultMap(() => []);
 
   // A Graph of Bundles and a root node (dummy string), which models only Bundles, and connections to their
@@ -109,9 +122,8 @@ export function createIdealGraph(
   };
   // Graph that models bundleRoots, with parallel & async deps only to inform reachability
   let bundleRootGraph: Graph<
-    // asset index
-    number,
-    (typeof bundleRootEdgeTypes)[keyof typeof bundleRootEdgeTypes]
+    number, // asset index
+    $Values<typeof bundleRootEdgeTypes>,
   > = new Graph();
   let assetToBundleRootNodeId = new Map<BundleRoot, number>();
 
@@ -145,7 +157,7 @@ export function createIdealGraph(
     bundleGroupBundleIds.add(nodeId);
   }
 
-  let assets: Array<Asset> = [];
+  let assets = [];
   let assetToIndex = new Map<Asset, number>();
 
   function makeManualAssetToConfigLookup() {
@@ -160,7 +172,6 @@ export function createIdealGraph(
 
     for (let c of config.manualSharedBundles) {
       if (c.root != null) {
-        // @ts-expect-error TS2345
         parentsToConfig.get(path.join(config.projectRoot, c.root)).push(c);
       }
     }
@@ -208,7 +219,6 @@ export function createIdealGraph(
           // We track all matching MSB's for constant modules as they are never duplicated
           // and need to be assigned to all matching bundles
           if (node.value.meta.isConstantModule === true) {
-            // @ts-expect-error TS2345
             constantModuleToMSB.get(node.value).push(c);
           }
 
@@ -242,14 +252,14 @@ export function createIdealGraph(
     makeManualAssetToConfigLookup();
   let manualBundleToInternalizedAsset: DefaultMap<
     NodeId,
-    Array<Asset>
+    Array<Asset>,
   > = new DefaultMap(() => []);
 
   let mergeSourceBundleLookup = new Map<string, NodeId>();
   let mergeSourceBundleAssets = new Set(
     config.sharedBundleMerge?.flatMap(
       (c) =>
-        c.sourceBundles?.map((assetMatch: string) =>
+        c.sourceBundles?.map((assetMatch) =>
           path.join(config.projectRoot, assetMatch),
         ) ?? [],
     ),
@@ -262,27 +272,7 @@ export function createIdealGraph(
    */
   assetGraph.traverse(
     {
-      enter(
-        node: // @ts-expect-error TS2304
-        | BundleGraphTraversable
-          | {
-              readonly type: 'dependency';
-              value: Dependency;
-            },
-        context:
-          | {
-              readonly type: 'asset';
-              value: Asset;
-            }
-          | null
-          | undefined
-          | {
-              readonly type: 'dependency';
-              value: Dependency;
-            },
-        // @ts-expect-error TS2304
-        actions: TraversalActions,
-      ) {
+      enter(node, context, actions) {
         if (node.type === 'asset') {
           if (
             context?.type === 'dependency' &&
@@ -409,7 +399,6 @@ export function createIdealGraph(
                     type: 'bundle',
                   },
                 ),
-                // @ts-expect-error TS7053
                 dependencyPriorityEdges[dependency.priority],
               );
 
@@ -521,7 +510,6 @@ export function createIdealGraph(
 
               assetReference.get(childAsset).push([dependency, bundle]);
             } else {
-              // @ts-expect-error TS2322
               bundleId = null;
             }
             if (manualSharedObject && bundleId != null) {
@@ -529,7 +517,6 @@ export function createIdealGraph(
               // add the asset if it doesn't already have it and set key
 
               invariant(
-                // @ts-expect-error TS2367
                 bundle !== 'root' && bundle != null && bundleId != null,
               );
 
@@ -556,8 +543,7 @@ export function createIdealGraph(
         }
         return node;
       },
-      // @ts-expect-error TS2322
-      exit(node: BundleGraphTraversable) {
+      exit(node) {
         if (stack[stack.length - 1]?.[0] === node.value) {
           stack.pop();
         }
@@ -606,20 +592,20 @@ export function createIdealGraph(
 
   // reachableRoots is an array of bit sets for each asset. Each bit set
   // indicates which bundle roots are reachable from that asset synchronously.
-  let reachableRoots: Array<BitSet> = [];
+  let reachableRoots = [];
   for (let i = 0; i < assets.length; i++) {
     reachableRoots.push(new BitSet(bundleRootGraph.nodes.length));
   }
 
   // reachableAssets is the inverse mapping of reachableRoots. For each bundle root,
   // it contains a bit set that indicates which assets are reachable from it.
-  let reachableAssets: Array<BitSet> = [];
+  let reachableAssets = [];
 
   // ancestorAssets maps bundle roots to the set of all assets available to it at runtime,
   // including in earlier parallel bundles. These are intersected through all paths to
   // the bundle to ensure that the available assets are always present no matter in which
   // order the bundles are loaded.
-  let ancestorAssets: Array<null | BitSet> = [];
+  let ancestorAssets = [];
 
   let inlineConstantDeps = new DefaultMap(() => new Set());
 
@@ -848,11 +834,8 @@ export function createIdealGraph(
 
   function assignInlineConstants(parentAsset: Asset, bundle: Bundle) {
     for (let inlineConstant of inlineConstantDeps.get(parentAsset)) {
-      // @ts-expect-error TS2345
       if (!bundle.assets.has(inlineConstant)) {
-        // @ts-expect-error TS2345
         bundle.assets.add(inlineConstant);
-        // @ts-expect-error TS18046
         bundle.size += inlineConstant.stats.size;
       }
     }
@@ -912,7 +895,7 @@ export function createIdealGraph(
       let bundle;
       let bundleId;
       let manualSharedBundleKey = manualSharedObject.name + ',' + asset.type;
-      let sourceBundles: Array<NodeId> = [];
+      let sourceBundles = [];
       reachable.forEach((id) => {
         sourceBundles.push(nullthrows(bundleRoots.get(assets[id]))[0]);
       });
@@ -1027,7 +1010,7 @@ export function createIdealGraph(
       });
     }
 
-    let reachableArray: Array<Asset> = [];
+    let reachableArray = [];
     reachable.forEach((id) => {
       reachableArray.push(assets[id]);
     });
@@ -1102,6 +1085,8 @@ export function createIdealGraph(
   }
 
   let manualSharedBundleIds = new Set([...manualSharedMap.values()]);
+  let modifiedSourceBundles = new Set<Bundle>();
+
   // Step split manual shared bundles for those that have the "split" property set
   let remainderMap = new DefaultMap(() => []);
   for (let id of manualSharedMap.values()) {
@@ -1120,9 +1105,9 @@ export function createIdealGraph(
       if (modNum != null) {
         for (let a of [...manualBundle.assets]) {
           let numRep = getBigIntFromContentKey(a.id);
+          // $FlowFixMe Flow doesn't know about BigInt
           let r = Number(numRep % BigInt(modNum));
 
-          // @ts-expect-error TS2345
           remainderMap.get(r).push(a);
         }
 
@@ -1145,10 +1130,8 @@ export function createIdealGraph(
           }
           for (let sp of remainderMap.get(i)) {
             bundle.assets.add(sp);
-            // @ts-expect-error TS2339
             bundle.size += sp.stats.size;
             manualBundle.assets.delete(sp);
-            // @ts-expect-error TS2339
             manualBundle.size -= sp.stats.size;
           }
         }
@@ -1161,7 +1144,6 @@ export function createIdealGraph(
   // match multiple MSB's
   for (let [asset, msbs] of constantModuleToMSB.entries()) {
     for (let manualSharedObject of msbs) {
-      // @ts-expect-error TS2339
       let bundleId = manualSharedMap.get(manualSharedObject.name + ',js');
       if (bundleId == null) continue;
       let bundle = nullthrows(bundleGraph.getNode(bundleId));
@@ -1170,16 +1152,86 @@ export function createIdealGraph(
         'We tried to use the root incorrectly',
       );
 
-      // @ts-expect-error TS2345
       if (!bundle.assets.has(asset)) {
-        // @ts-expect-error TS2345
         bundle.assets.add(asset);
-        // @ts-expect-error TS18046
         bundle.size += asset.stats.size;
       }
     }
   }
 
+  if (getFeatureFlag('supportWebpackChunkName')) {
+    // Merge webpack chunk name bundles
+    let chunkNameBundles = new DefaultMap(() => new Set());
+    for (let [nodeId, node] of dependencyBundleGraph.nodes.entries()) {
+      // meta.chunkName is set by the Rust transformer, so we just need to find
+      // bundles that have a chunkName set.
+      if (
+        !node ||
+        node.type !== 'dependency' ||
+        node.value.meta.chunkName == null
+      ) {
+        continue;
+      }
+
+      let connectedBundles = dependencyBundleGraph.getNodeIdsConnectedFrom(
+        nodeId,
+        dependencyPriorityEdges[node.value.priority],
+      );
+
+      if (connectedBundles.length === 0) {
+        continue;
+      }
+
+      invariant(
+        connectedBundles.length === 1,
+        'Expected webpackChunkName dependency to be connected to no more than one bundle',
+      );
+
+      let bundleId = connectedBundles[0];
+      let bundleNode = dependencyBundleGraph.getNode(bundleId);
+      invariant(bundleNode != null && bundleNode.type === 'bundle');
+
+      // If a bundle does not have a main entry asset, it's somehow just a
+      // shared bundle, and will be merged/deleted by other means.
+      if (bundleNode.value.mainEntryAsset == null) {
+        continue;
+      }
+
+      let bundleNodeId = null;
+      let mainEntryAssetId = bundleNode.value.mainEntryAsset?.id;
+
+      if (mainEntryAssetId != null) {
+        bundleNodeId = bundles.get(mainEntryAssetId);
+      }
+
+      if (bundleNodeId == null) {
+        continue;
+      }
+
+      chunkNameBundles
+        .get(node.value.meta.chunkName)
+        // DependencyBundleGraph uses content keys as node ids, so we can use that
+        // to get the bundle id.
+        .add(bundleNodeId);
+    }
+
+    for (let [chunkName, bundleIds] of chunkNameBundles.entries()) {
+      // The `[request]` placeholder is not yet supported
+      if (
+        bundleIds.size <= 1 ||
+        (typeof chunkName === 'string' && chunkName.includes('[request]'))
+      ) {
+        continue; // Nothing to merge
+      }
+
+      // Merge all bundles with the same chunk name into the first one.
+      let [firstBundleId, ...rest] = Array.from(bundleIds);
+      for (let bundleId of rest) {
+        mergeBundles(firstBundleId, bundleId);
+      }
+    }
+  }
+
   // Step merge shared bundles that meet the overlap threshold
   // This step is skipped by default as the threshold defaults to 1
   if (config.sharedBundleMerge && config.sharedBundleMerge.length > 0) {
@@ -1202,7 +1254,6 @@ export function createIdealGraph(
   }
 
   // Step Remove Shared Bundles: Remove shared bundles from bundle groups that hit the parallel request limit.
-  let modifiedSourceBundles = new Set();
 
   if (config.disableSharedBundles === false) {
     for (let bundleGroupId of bundleGraph.getNodeIdsConnectedFrom(rootNodeId)) {
@@ -1216,7 +1267,6 @@ export function createIdealGraph(
       let numBundlesContributingToPRL = bundleIdsInGroup.reduce((count, b) => {
         let bundle = nullthrows(bundleGraph.getNode(b));
         invariant(bundle !== 'root');
-        // @ts-expect-error TS2365
         return count + (bundle.bundleBehavior !== 'inline');
       }, 0);
 
@@ -1252,9 +1302,7 @@ export function createIdealGraph(
           numBundlesContributingToPRL > config.maxParallelRequests
         ) {
           let bundleTuple = sharedBundlesInGroup.pop();
-          // @ts-expect-error TS18048
           let bundleToRemove = bundleTuple.bundle;
-          // @ts-expect-error TS18048
           let bundleIdToRemove = bundleTuple.id;
           //TODO add integration test where bundles in bunlde group > max parallel request limit & only remove a couple shared bundles
           // but total # bundles still exceeds limit due to non shared bundles
@@ -1310,36 +1358,49 @@ export function createIdealGraph(
     }
   }
 
-  function mergeBundles(
-    bundleGraph: IdealBundleGraph,
-    bundleToKeepId: NodeId,
-    bundleToRemoveId: NodeId,
-    assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>,
-  ) {
-    let bundleToKeep = nullthrows(bundleGraph.getNode(bundleToKeepId));
-    let bundleToRemove = nullthrows(bundleGraph.getNode(bundleToRemoveId));
-    invariant(bundleToKeep !== 'root' && bundleToRemove !== 'root');
+  function mergeBundles(bundleToKeepId: NodeId, bundleToRemoveId: NodeId) {
+    let bundleToKeep = isNonRootBundle(
+      bundleGraph.getNode(bundleToKeepId),
+      `Bundle ${bundleToKeepId} not found`,
+    );
+    let bundleToRemove = isNonRootBundle(
+      bundleGraph.getNode(bundleToRemoveId),
+      `Bundle ${bundleToRemoveId} not found`,
+    );
+    modifiedSourceBundles.add(bundleToKeep);
     for (let asset of bundleToRemove.assets) {
       bundleToKeep.assets.add(asset);
       bundleToKeep.size += asset.stats.size;
 
       let newAssetReference = assetReference
         .get(asset)
-        .map(([dep, bundle]: [any, any]) =>
+        .map(([dep, bundle]) =>
           bundle === bundleToRemove ? [dep, bundleToKeep] : [dep, bundle],
         );
 
-      // @ts-expect-error TS2345
       assetReference.set(asset, newAssetReference);
     }
 
     // Merge any internalized assets
-    invariant(
-      bundleToKeep.internalizedAssets && bundleToRemove.internalizedAssets,
-      'All shared bundles should have internalized assets',
-    );
-    bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      if (bundleToKeep.internalizedAssets != null) {
+        if (bundleToRemove.internalizedAssets != null) {
+          bundleToKeep.internalizedAssets.intersect(
+            bundleToRemove.internalizedAssets,
+          );
+        } else {
+          bundleToKeep.internalizedAssets.clear();
+        }
+      }
+    } else {
+      invariant(
+        bundleToKeep.internalizedAssets && bundleToRemove.internalizedAssets,
+        'All shared bundles should have internalized assets',
+      );
+      bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
+    }
 
+    // Merge and clean up source bundles
     for (let sourceBundleId of bundleToRemove.sourceBundles) {
       if (bundleToKeep.sourceBundles.has(sourceBundleId)) {
         continue;
@@ -1349,6 +1410,104 @@ export function createIdealGraph(
       bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
     }
 
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      bundleToKeep.sourceBundles.delete(bundleToRemoveId);
+
+      for (let bundle of bundleGraph.getNodeIdsConnectedFrom(
+        bundleToRemoveId,
+      )) {
+        let bundleNode = nullthrows(bundleGraph.getNode(bundle));
+        if (bundleNode === 'root') {
+          continue;
+        }
+
+        // If the bundle is a source bundle, add it to the bundle to keep
+        if (bundleNode.sourceBundles.has(bundleToRemoveId)) {
+          bundleNode.sourceBundles.add(bundleToKeepId);
+          bundleNode.sourceBundles.delete(bundleToRemoveId);
+          bundleGraph.addEdge(bundleToKeepId, bundle);
+        }
+      }
+
+      // Merge bundle roots
+      for (let bundleRoot of bundleToRemove.bundleRoots) {
+        bundleToKeep.bundleRoots.add(bundleRoot);
+      }
+
+      if (bundleToRemove.mainEntryAsset != null) {
+        invariant(bundleToKeep.mainEntryAsset != null);
+
+        // Merge the bundles in bundle group
+        let bundlesInRemoveBundleGroup =
+          getBundlesForBundleGroup(bundleToRemoveId);
+
+        for (let bundleIdInGroup of bundlesInRemoveBundleGroup) {
+          if (bundleIdInGroup === bundleToRemoveId) {
+            continue;
+          }
+          bundleGraph.addEdge(bundleToKeepId, bundleIdInGroup);
+        }
+
+        // Remove old bundle group
+        bundleGroupBundleIds.delete(bundleToRemoveId);
+
+        // Clean up bundle roots
+        let bundleRootToRemoveNodeId = nullthrows(
+          assetToBundleRootNodeId.get(
+            nullthrows(bundleToRemove.mainEntryAsset),
+          ),
+        );
+        let bundleRootToKeepNodeId = nullthrows(
+          assetToBundleRootNodeId.get(nullthrows(bundleToKeep.mainEntryAsset)),
+        );
+
+        for (let nodeId of bundleRootGraph.getNodeIdsConnectedTo(
+          bundleRootToRemoveNodeId,
+        )) {
+          bundleRootGraph.addEdge(nodeId, bundleRootToKeepNodeId);
+          bundleRootGraph.removeEdge(nodeId, bundleRootToRemoveNodeId);
+        }
+
+        for (let nodeId of bundleRootGraph.getNodeIdsConnectedFrom(
+          bundleRootToRemoveNodeId,
+        )) {
+          bundleRootGraph.addEdge(bundleRootToKeepNodeId, nodeId);
+          bundleRootGraph.removeEdge(bundleRootToRemoveNodeId, nodeId);
+        }
+
+        bundleRoots.set(nullthrows(bundleToRemove.mainEntryAsset), [
+          bundleToKeepId,
+          bundleToKeepId,
+        ]);
+
+        // Merge dependency bundle graph
+        for (let dependencyNodeId of dependencyBundleGraph.getNodeIdsConnectedTo(
+          dependencyBundleGraph.getNodeIdByContentKey(String(bundleToRemoveId)),
+          ALL_EDGE_TYPES,
+        )) {
+          let dependencyNode = nullthrows(
+            dependencyBundleGraph.getNode(dependencyNodeId),
+          );
+          invariant(dependencyNode.type === 'dependency');
+
+          // Add dependency to the bundle to keep
+          dependencyBundleGraph.addEdge(
+            dependencyNodeId,
+            dependencyBundleGraph.getNodeIdByContentKey(String(bundleToKeepId)),
+            dependencyPriorityEdges[dependencyNode.value.priority],
+          );
+          // Remove dependency from the bundle to remove
+          dependencyBundleGraph.removeEdge(
+            dependencyNodeId,
+            dependencyBundleGraph.getNodeIdByContentKey(
+              String(bundleToRemoveId),
+            ),
+            dependencyPriorityEdges[dependencyNode.value.priority],
+          );
+        }
+      }
+    }
+
     bundleGraph.removeNode(bundleToRemoveId);
   }
 
@@ -1382,36 +1541,43 @@ export function createIdealGraph(
     let clusters = findMergeCandidates(
       bundleGraph,
       Array.from(sharedBundles),
-      mergeConfig.map(
-        (config): MergeGroup => ({
-          ...config,
-          sourceBundles: config.sourceBundles?.map((assetMatch: string) => {
-            let sourceBundleNodeId = mergeSourceBundleLookup.get(assetMatch);
-
-            if (sourceBundleNodeId == null) {
-              throw new Error(
-                `Source bundle ${assetMatch} not found in merge source bundle lookup`,
-              );
-            }
+      mergeConfig.map((config): MergeGroup => ({
+        ...config,
+        sourceBundles: config.sourceBundles?.map((assetMatch) => {
+          let sourceBundleNodeId = mergeSourceBundleLookup.get(assetMatch);
+
+          if (sourceBundleNodeId == null) {
+            throw new Error(
+              `Source bundle ${assetMatch} not found in merge source bundle lookup`,
+            );
+          }
 
-            return sourceBundleNodeId;
-          }),
+          return sourceBundleNodeId;
         }),
-      ),
+      })),
     );
 
+    let mergedBundles = new Set();
+
     for (let cluster of clusters) {
       let [mergeTarget, ...rest] = cluster;
 
       for (let bundleIdToMerge of rest) {
-        mergeBundles(bundleGraph, mergeTarget, bundleIdToMerge, assetReference);
+        mergeBundles(mergeTarget, bundleIdToMerge);
       }
+
+      mergedBundles.add(mergeTarget);
+    }
+
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      return mergedBundles;
     }
   }
 
-  function getBigIntFromContentKey(contentKey: string) {
+  function getBigIntFromContentKey(contentKey) {
     let b = Buffer.alloc(64);
     b.write(contentKey);
+    // $FlowFixMe Flow doesn't have BigInt types in this version
     return b.readBigInt64BE();
   }
   // Fix asset order in source bundles as they are likely now incorrect after shared bundle deletion
@@ -1419,9 +1585,7 @@ export function createIdealGraph(
     let assetOrderMap = new Map(assets.map((a, index) => [a, index]));
 
     for (let bundle of modifiedSourceBundles) {
-      // @ts-expect-error TS18046
       bundle.assets = new Set(
-        // @ts-expect-error TS18046
         [...bundle.assets].sort((a, b) => {
           let aIndex = nullthrows(assetOrderMap.get(a));
           let bIndex = nullthrows(assetOrderMap.get(b));
@@ -1440,8 +1604,8 @@ export function createIdealGraph(
       bundleRootGraph.removeNode(bundleRootId);
     }
   }
-  function getBundlesForBundleGroup(bundleGroupId: NodeId) {
-    let bundlesInABundleGroup: Array<NodeId> = [];
+  function getBundlesForBundleGroup(bundleGroupId) {
+    let bundlesInABundleGroup = [];
     bundleGraph.traverse((nodeId) => {
       bundlesInABundleGroup.push(nodeId);
     }, bundleGroupId);
@@ -1522,23 +1686,24 @@ export function createIdealGraph(
   };
 }
 
-function createBundle(opts: {
-  asset?: Asset;
-  bundleBehavior?: BundleBehavior | null | undefined;
-  env?: Environment;
-  manualSharedBundle?: string | null | undefined;
-  needsStableName?: boolean;
-  sourceBundles?: Set<NodeId>;
-  target: Target;
-  type?: string;
-  uniqueKey?: string;
-}): Bundle {
+function createBundle(opts: {|
+  asset?: Asset,
+  bundleBehavior?: ?BundleBehavior,
+  env?: Environment,
+  manualSharedBundle?: ?string,
+  needsStableName?: boolean,
+  sourceBundles?: Set<NodeId>,
+  target: Target,
+  type?: string,
+  uniqueKey?: string,
+|}): Bundle {
   if (opts.asset == null) {
     return {
       assets: new Set(),
       bundleBehavior: opts.bundleBehavior,
       env: nullthrows(opts.env),
       mainEntryAsset: null,
+      bundleRoots: new Set(),
       manualSharedBundle: opts.manualSharedBundle,
       needsStableName: Boolean(opts.needsStableName),
       size: 0,
@@ -1555,6 +1720,7 @@ function createBundle(opts: {
     bundleBehavior: opts.bundleBehavior ?? asset.bundleBehavior,
     env: opts.env ?? asset.env,
     mainEntryAsset: asset,
+    bundleRoots: new Set([asset]),
     manualSharedBundle: opts.manualSharedBundle,
     needsStableName: Boolean(opts.needsStableName),
     size: asset.stats.size,