@atlaspack/bundler-default 2.14.5-canary.16 → 2.14.5-canary.161

package/lib/decorateLegacyGraph.js

@@ -42,11 +42,13 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
     bundleGroupBundleIds,
     manualAssetToBundle
   } = idealGraph;
+  // This line can be deleted once supportWebpackChunkName feature flag is removed.
   let entryBundleToBundleGroup = new Map();
   // Step Create Bundles: Create bundle groups, bundles, and shared bundles and add assets to them
   for (let [bundleNodeId, idealBundle] of idealBundleGraph.nodes.entries()) {
     if (!idealBundle || idealBundle === 'root') continue;
     let entryAsset = idealBundle.mainEntryAsset;
+    // This line can be deleted once supportWebpackChunkName feature flag is removed.
     let bundleGroup;
     let bundle;
     if (bundleGroupBundleIds.has(bundleNodeId)) {
@@ -57,19 +59,33 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
         return dependency.value;
       });
       (0, _assert().default)(entryAsset != null, 'Processing a bundleGroup with no entry asset');
+      let bundleGroups = new Map();
       for (let dependency of dependencies) {
         bundleGroup = bundleGraph.createBundleGroup(dependency, idealBundle.target);
+        bundleGroups.set(bundleGroup.entryAssetId, bundleGroup);
+      }
+      if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+        (0, _assert().default)(bundleGroups.size > 0, 'No bundle groups created');
+      } else {
+        (0, _assert().default)(bundleGroup);
+        entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
       }
-      (0, _assert().default)(bundleGroup);
-      entryBundleToBundleGroup.set(bundleNodeId, bundleGroup);
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
         entryAsset: (0, _nullthrows().default)(entryAsset),
+        bundleRoots: Array.from(idealBundle.bundleRoots),
         needsStableName: idealBundle.needsStableName,
         bundleBehavior: idealBundle.bundleBehavior,
         target: idealBundle.target,
         manualSharedBundle: idealBundle.manualSharedBundle
       }));
-      bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+        for (let bundleGroup of bundleGroups.values()) {
+          bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+        }
+      } else {
+        (0, _assert().default)(bundleGroup);
+        bundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+      }
     } else if (idealBundle.sourceBundles.size > 0 && !idealBundle.mainEntryAsset) {
       let uniqueKey = idealBundle.uniqueKey != null ? idealBundle.uniqueKey : [...idealBundle.assets].map(asset => asset.id).join(',');
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
@@ -95,6 +111,7 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
       (0, _assert().default)(entryAsset != null);
       bundle = (0, _nullthrows().default)(bundleGraph.createBundle({
         entryAsset,
+        bundleRoots: Array.from(idealBundle.bundleRoots),
         needsStableName: idealBundle.needsStableName,
         bundleBehavior: idealBundle.bundleBehavior,
         target: idealBundle.target,
@@ -162,6 +179,8 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
       bundleGraph.createAssetReference(dependency, asset, legacyBundle);
     }
   }
+
+  // @ts-expect-error TS2488
   for (let {
     type,
     from,
@@ -171,12 +190,14 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
     if (sourceBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     (0, _assert().default)(sourceBundle !== 'root');
     let legacySourceBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(sourceBundle));
     let targetBundle = (0, _nullthrows().default)(idealBundleGraph.getNode(to));
     if (targetBundle === 'root') {
       continue;
     }
+    // @ts-expect-error TS2367
     (0, _assert().default)(targetBundle !== 'root');
     let legacyTargetBundle = (0, _nullthrows().default)(idealBundleToLegacyBundle.get(targetBundle));
     if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && type === _idealGraph.idealBundleGraphEdges.conditional) {

package/lib/idealGraph.js

@@ -50,6 +50,7 @@ function _nullthrows() {
 var _bundleMerge = require("./bundleMerge");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /* BundleRoot - An asset that is the main entry of a Bundle. */
+
 const dependencyPriorityEdges = {
   sync: 1,
   parallel: 2,
@@ -65,7 +66,13 @@ const idealBundleGraphEdges = exports.idealBundleGraphEdges = Object.freeze({
 // which mutates the assetGraph into the bundleGraph we would
 // expect from default bundler
 
+function isNonRootBundle(bundle, message) {
+  let existingBundle = (0, _nullthrows().default)(bundle, message);
+  (0, _assert().default)(existingBundle !== 'root', "Bundle cannot be 'root'");
+  return existingBundle;
+}
 function createIdealGraph(assetGraph, config, entries, logger) {
+  var _config$sharedBundleM;
   // Asset to the bundle and group it's an entry of
   let bundleRoots = new Map();
   let bundles = new Map();
@@ -108,15 +115,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   }
   let assets = [];
   let assetToIndex = new Map();
-  //Manual is a map of the user-given name to the bundle node Id that corresponds to ALL the assets that match any glob in that user-specified array
-  let manualSharedMap = new Map();
-  // May need a map to be able to look up NON- bundle root assets which need special case instructions
-  // Use this when placing assets into bundles, to avoid duplication
-  let manualAssetToBundle = new Map();
-  let {
-    manualAssetToConfig,
-    constantModuleToMSB
-  } = function makeManualAssetToConfigLookup() {
+  function makeManualAssetToConfigLookup() {
     let manualAssetToConfig = new Map();
     let constantModuleToMSB = new (_utils().DefaultMap)(() => []);
     if (config.manualSharedBundles.length === 0) {
@@ -128,6 +127,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     let parentsToConfig = new (_utils().DefaultMap)(() => []);
     for (let c of config.manualSharedBundles) {
       if (c.root != null) {
+        // @ts-expect-error TS2345
         parentsToConfig.get(_path().default.join(config.projectRoot, c.root)).push(c);
       }
     }
@@ -160,17 +160,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       assetGraph.traverse((node, _, actions) => {
         if (node.type === 'asset' && (!Array.isArray(c.types) || c.types.includes(node.value.type))) {
           let projectRelativePath = _path().default.relative(config.projectRoot, node.value.filePath);
-          if (!assetRegexes.some(regex => regex.test(projectRelativePath))) {
-            return;
-          }
 
           // 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);
           }
-          manualAssetToConfig.set(node.value, c);
-          return;
+          if (assetRegexes.some(regex => regex.test(projectRelativePath))) {
+            manualAssetToConfig.set(node.value, c);
+          }
         }
         if (node.type === 'dependency' && (node.value.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional') && parentAsset) {
           // Don't walk past the bundle group assets
@@ -182,8 +181,23 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       manualAssetToConfig,
       constantModuleToMSB
     };
-  }();
+  }
+
+  //Manual is a map of the user-given name to the bundle node Id that corresponds to ALL the assets that match any glob in that user-specified array
+  let manualSharedMap = new Map();
+  // May need a map to be able to look up NON- bundle root assets which need special case instructions
+  // Use this when placing assets into bundles, to avoid duplication
+  let manualAssetToBundle = new Map();
+  let {
+    manualAssetToConfig,
+    constantModuleToMSB
+  } = makeManualAssetToConfigLookup();
   let manualBundleToInternalizedAsset = new (_utils().DefaultMap)(() => []);
+  let mergeSourceBundleLookup = new Map();
+  let mergeSourceBundleAssets = new Set((_config$sharedBundleM = config.sharedBundleMerge) === null || _config$sharedBundleM === void 0 ? void 0 : _config$sharedBundleM.flatMap(c => {
+    var _c$sourceBundles;
+    return ((_c$sourceBundles = c.sourceBundles) === null || _c$sourceBundles === void 0 ? void 0 : _c$sourceBundles.map(assetMatch => _path().default.join(config.projectRoot, assetMatch))) ?? [];
+  }));
 
   /**
    * Step Create Bundles: Traverse the assetGraph (aka MutableBundleGraph) and create bundles
@@ -191,7 +205,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
    * adding only that asset to each bundle, not its entire subgraph.
    */
   assetGraph.traverse({
-    enter(node, context, actions) {
+    enter(node, context,
+    // @ts-expect-error TS2304
+    actions) {
       if (node.type === 'asset') {
         if ((context === null || context === void 0 ? void 0 : context.type) === 'dependency' && context !== null && context !== void 0 && context.value.isEntry && !entries.has(node.value)) {
           // Skip whole subtrees of other targets by skipping those entries
@@ -234,15 +250,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
           manualSharedBundleKey != null && manualSharedMap.has(manualSharedBundleKey)) {
             bundleId = (0, _nullthrows().default)(manualSharedMap.get(manualSharedBundleKey));
           }
-          if (dependency.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional' || childAsset.bundleBehavior === 'isolated' // An isolated Dependency, or Bundle must contain all assets it needs to load.
-          ) {
+          if (dependency.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional' || childAsset.bundleBehavior === 'isolated' ||
+          // An isolated Dependency, or Bundle must contain all assets it needs to load.
+          childAsset.bundleBehavior === 'inlineIsolated') {
             if (bundleId == null) {
               let firstBundleGroup = (0, _nullthrows().default)(bundleGraph.getNode(stack[0][1]));
               (0, _assert().default)(firstBundleGroup !== 'root');
               bundle = createBundle({
                 asset: childAsset,
                 bundleBehavior: dependency.bundleBehavior ?? childAsset.bundleBehavior,
-                needsStableName: dependency.bundleBehavior === 'inline' || childAsset.bundleBehavior === 'inline' ? false : dependency.isEntry || dependency.needsStableName,
+                needsStableName: dependency.bundleBehavior === 'inline' || childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inlineIsolated' || childAsset.bundleBehavior === 'inlineIsolated' ? false : dependency.isEntry || dependency.needsStableName,
                 target: firstBundleGroup.target
               });
               bundleId = bundleGraph.addNode(bundle);
@@ -250,6 +267,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               bundleRoots.set(childAsset, [bundleId, bundleId]);
               bundleGroupBundleIds.add(bundleId);
               bundleGraph.addEdge(bundleGraphRootNodeId, bundleId);
+              // If this asset is relevant for merging then track it's source
+              // bundle id for later
+              if (mergeSourceBundleAssets.has(childAsset.filePath)) {
+                mergeSourceBundleLookup.set(_path().default.relative(config.projectRoot, childAsset.filePath), bundleId);
+              }
               if (manualSharedObject) {
                 // MSB Step 4: If this was the first instance of a match, mark mainAsset for internalization
                 // since MSBs should not have main entry assets
@@ -261,7 +283,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               if (
               // If this dependency requests isolated, but the bundle is not,
               // make the bundle isolated for all uses.
-              dependency.bundleBehavior === 'isolated' && bundle.bundleBehavior == null) {
+              (dependency.bundleBehavior === 'isolated' || dependency.bundleBehavior === 'inlineIsolated') && bundle.bundleBehavior == null) {
                 bundle.bundleBehavior = dependency.bundleBehavior;
               }
             }
@@ -271,7 +293,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
             }), dependencyBundleGraph.addNodeByContentKeyIfNeeded(String(bundleId), {
               value: bundle,
               type: 'bundle'
-            }), dependencyPriorityEdges[dependency.priority]);
+            }),
+            // @ts-expect-error TS7053
+            dependencyPriorityEdges[dependency.priority]);
             if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && dependency.priority === 'conditional') {
               let [referencingBundleRoot, bundleGroupNodeId] = (0, _nullthrows().default)(stack[stack.length - 1]);
               let referencingBundleId = (0, _nullthrows().default)(bundleRoots.get(referencingBundleRoot))[0];
@@ -300,7 +324,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
                 env: childAsset.env,
                 bundleBehavior: dependency.bundleBehavior ?? childAsset.bundleBehavior,
                 target: referencingBundle.target,
-                needsStableName: childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inline' || dependency.priority === 'parallel' && !dependency.needsStableName ? false : referencingBundle.needsStableName
+                needsStableName: childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inlineIsolated' || dependency.priority === 'parallel' && !dependency.needsStableName ? false : referencingBundle.needsStableName
               });
               bundleId = bundleGraph.addNode(bundle);
             } else {
@@ -309,7 +333,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               if (
               // If this dependency requests isolated, but the bundle is not,
               // make the bundle isolated for all uses.
-              dependency.bundleBehavior === 'isolated' && bundle.bundleBehavior == null) {
+              (dependency.bundleBehavior === 'isolated' || dependency.bundleBehavior === 'inlineIsolated') && bundle.bundleBehavior == null) {
                 bundle.bundleBehavior = dependency.bundleBehavior;
               }
             }
@@ -331,13 +355,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
             }
             assetReference.get(childAsset).push([dependency, bundle]);
           } else {
+            // @ts-expect-error TS2322
             bundleId = null;
           }
           if (manualSharedObject && bundleId != null) {
             // MSB Step 5:  At this point we've either created or found an existing MSB bundle
             // add the asset if it doesn't already have it and set key
 
-            (0, _assert().default)(bundle !== 'root' && bundle != null && bundleId != null);
+            (0, _assert().default)(
+            // @ts-expect-error TS2367
+            bundle !== 'root' && bundle != null && bundleId != null);
             manualAssetToBundle.set(childAsset, bundleId);
             if (!bundle.assets.has(childAsset)) {
               // Add asset to bundle
@@ -358,6 +385,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
       return node;
     },
+    // @ts-expect-error TS2322
     exit(node) {
       var _stack;
       if (((_stack = stack[stack.length - 1]) === null || _stack === void 0 ? void 0 : _stack[0]) === node.value) {
@@ -495,7 +523,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     // not true that a bundle's available assets = all assets of all the bundleGroups
     // it belongs to. It's the intersection of those sets.
     let available;
-    if (bundleRoot.bundleBehavior === 'isolated') {
+    if (bundleRoot.bundleBehavior === 'isolated' || bundleRoot.bundleBehavior === 'inlineIsolated') {
       available = new (_graph().BitSet)(assets.length);
     } else {
       available = (0, _nullthrows().default)(ancestorAssets[nodeId]).clone();
@@ -558,7 +586,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       continue;
     }
     let parentRoots = bundleRootGraph.getNodeIdsConnectedTo(id, _graph().ALL_EDGE_TYPES);
-    let canDelete = getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'isolated';
+    let canDelete = getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'isolated' && getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'inlineIsolated';
     if (parentRoots.length === 0) continue;
     for (let parentId of parentRoots) {
       var _ancestorAssets$paren;
@@ -586,8 +614,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   }
   function assignInlineConstants(parentAsset, 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;
       }
     }
@@ -623,7 +654,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       let assetId = bundleRootGraph.getNode(nodeId);
       if (assetId == null) return; // deleted
       let a = assets[assetId];
-      if (entries.has(a) || !a.isBundleSplittable || bundleRoots.get(a) && (getBundleFromBundleRoot(a).needsStableName || getBundleFromBundleRoot(a).bundleBehavior === 'isolated')) {
+      if (entries.has(a) || !a.isBundleSplittable || bundleRoots.get(a) && (getBundleFromBundleRoot(a).needsStableName || getBundleFromBundleRoot(a).bundleBehavior === 'isolated' || getBundleFromBundleRoot(a).bundleBehavior === 'inlineIsolated')) {
         // Add asset to non-splittable bundles.
         addAssetToBundleRoot(asset, a);
       } else if (!((_ancestorAssets$nodeI = ancestorAssets[nodeId]) !== null && _ancestorAssets$nodeI !== void 0 && _ancestorAssets$nodeI.has(i))) {
@@ -785,6 +816,8 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }
   }
   let manualSharedBundleIds = new Set([...manualSharedMap.values()]);
+  let modifiedSourceBundles = new Set();
+
   // Step split manual shared bundles for those that have the "split" property set
   let remainderMap = new (_utils().DefaultMap)(() => []);
   for (let id of manualSharedMap.values()) {
@@ -801,8 +834,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       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);
         }
         for (let i = 1; i < [...remainderMap.keys()].length; i++) {
@@ -824,8 +858,10 @@ function createIdealGraph(assetGraph, config, entries, logger) {
           }
           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;
           }
         }
@@ -838,21 +874,77 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   // 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 = (0, _nullthrows().default)(bundleGraph.getNode(bundleId));
       (0, _assert().default)(bundle != null && bundle !== 'root', '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 ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+    // Merge webpack chunk name bundles
+    let chunkNameBundles = new (_utils().DefaultMap)(() => new Set());
+    for (let [nodeId, node] of dependencyBundleGraph.nodes.entries()) {
+      var _bundleNode$value$mai;
+      // 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;
+      }
+      (0, _assert().default)(connectedBundles.length === 1, 'Expected webpackChunkName dependency to be connected to no more than one bundle');
+      let bundleId = connectedBundles[0];
+      let bundleNode = dependencyBundleGraph.getNode(bundleId);
+      (0, _assert().default)(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$mai = bundleNode.value.mainEntryAsset) === null || _bundleNode$value$mai === void 0 ? void 0 : _bundleNode$value$mai.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) {
+        // @ts-expect-error TS2345
+        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.sharedBundleMergeThreshold < 1) {
-    mergeOverlapBundles();
+  if (config.sharedBundleMerge && config.sharedBundleMerge.length > 0) {
+    mergeOverlapBundles(config.sharedBundleMerge);
   }
 
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
@@ -866,7 +958,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   }
 
   // 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)) {
       // Find shared bundles in this bundle group.
@@ -879,7 +971,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       let numBundlesContributingToPRL = bundleIdsInGroup.reduce((count, b) => {
         let bundle = (0, _nullthrows().default)(bundleGraph.getNode(b));
         (0, _assert().default)(bundle !== 'root');
-        return count + (bundle.bundleBehavior !== 'inline');
+        return count + Number(bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inlineIsolated');
       }, 0);
       if (numBundlesContributingToPRL > config.maxParallelRequests) {
         let sharedBundleIdsInBundleGroup = bundleIdsInGroup.filter(b => {
@@ -908,7 +1000,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
         // Remove bundles until the bundle group is within the parallel request limit.
         while (sharedBundlesInGroup.length > 0 && 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
@@ -951,16 +1045,34 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
     }
   }
-  function mergeBundles(bundleGraph, bundleToKeepId, bundleToRemoveId, assetReference) {
-    let bundleToKeep = (0, _nullthrows().default)(bundleGraph.getNode(bundleToKeepId));
-    let bundleToRemove = (0, _nullthrows().default)(bundleGraph.getNode(bundleToRemoveId));
-    (0, _assert().default)(bundleToKeep !== 'root' && bundleToRemove !== 'root');
+  function mergeBundles(bundleToKeepId, bundleToRemoveId) {
+    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]) => bundle === bundleToRemove ? [dep, bundleToKeep] : [dep, bundle]);
+
+      // @ts-expect-error TS2345
       assetReference.set(asset, newAssetReference);
     }
+
+    // Merge any internalized assets
+    if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      if (bundleToKeep.internalizedAssets != null) {
+        if (bundleToRemove.internalizedAssets != null) {
+          bundleToKeep.internalizedAssets.intersect(bundleToRemove.internalizedAssets);
+        } else {
+          bundleToKeep.internalizedAssets.clear();
+        }
+      }
+    } else {
+      (0, _assert().default)(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;
@@ -968,18 +1080,69 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       bundleToKeep.sourceBundles.add(sourceBundleId);
       bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
     }
+    if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      bundleToKeep.sourceBundles.delete(bundleToRemoveId);
+      for (let bundle of bundleGraph.getNodeIdsConnectedFrom(bundleToRemoveId)) {
+        let bundleNode = (0, _nullthrows().default)(bundleGraph.getNode(bundle));
+        if (bundleNode === 'root') {
+          continue;
+        }
 
-    // Merge any internalized assets
-    if (bundleToRemove.internalizedAssets) {
-      if (bundleToKeep.internalizedAssets) {
-        bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
-      } else {
-        bundleToKeep.internalizedAssets = bundleToRemove.internalizedAssets;
+        // 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) {
+        (0, _assert().default)(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 = (0, _nullthrows().default)(assetToBundleRootNodeId.get((0, _nullthrows().default)(bundleToRemove.mainEntryAsset)));
+        let bundleRootToKeepNodeId = (0, _nullthrows().default)(assetToBundleRootNodeId.get((0, _nullthrows().default)(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((0, _nullthrows().default)(bundleToRemove.mainEntryAsset), [bundleToKeepId, bundleToKeepId]);
+
+        // Merge dependency bundle graph
+        for (let dependencyNodeId of dependencyBundleGraph.getNodeIdsConnectedTo(dependencyBundleGraph.getNodeIdByContentKey(String(bundleToRemoveId)), _graph().ALL_EDGE_TYPES)) {
+          let dependencyNode = (0, _nullthrows().default)(dependencyBundleGraph.getNode(dependencyNodeId));
+          (0, _assert().default)(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);
   }
-  function mergeOverlapBundles() {
+  function mergeOverlapBundles(mergeConfig) {
     // Find all shared bundles
     let sharedBundles = new Set();
     bundleGraph.traverse(nodeId => {
@@ -998,18 +1161,34 @@ function createIdealGraph(assetGraph, config, entries, logger) {
         sharedBundles.add(nodeId);
       }
     });
-    let clusters = (0, _bundleMerge.findMergeCandidates)(bundleGraph, Array.from(sharedBundles), config.sharedBundleMergeThreshold);
+    let clusters = (0, _bundleMerge.findMergeCandidates)(bundleGraph, Array.from(sharedBundles), mergeConfig.map(config => {
+      var _config$sourceBundles;
+      return {
+        ...config,
+        sourceBundles: (_config$sourceBundles = config.sourceBundles) === null || _config$sourceBundles === void 0 ? void 0 : _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;
+        })
+      };
+    }));
+    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 ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      return mergedBundles;
     }
   }
   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
@@ -1104,6 +1283,7 @@ function createBundle(opts) {
       bundleBehavior: opts.bundleBehavior,
       env: (0, _nullthrows().default)(opts.env),
       mainEntryAsset: null,
+      bundleRoots: new Set(),
       manualSharedBundle: opts.manualSharedBundle,
       needsStableName: Boolean(opts.needsStableName),
       size: 0,
@@ -1119,6 +1299,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,

package/lib/memoize.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearCaches = clearCaches;
+exports.memoize = memoize;
+function _manyKeysMap() {
+  const data = _interopRequireDefault(require("many-keys-map"));
+  _manyKeysMap = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let caches = [];
+function clearCaches() {
+  for (let cache of caches) {
+    cache.clear();
+  }
+}
+function memoize(fn) {
+  let cache = new (_manyKeysMap().default)();
+  caches.push(cache);
+  return function (...args) {
+    // Navigate through the cache hierarchy
+    let cached = cache.get(args);
+    if (cached !== undefined) {
+      // If the result is cached, return it
+      return cached;
+    }
+
+    // Calculate the result and cache it
+    // @ts-expect-error TS2683
+    const result = fn.apply(this, args);
+    cache.set(args, result);
+    return result;
+  };
+}