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

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @atlaspack/bundler-default
 
+## 3.2.0
+
+### Minor Changes
+
+- [#721](https://github.com/atlassian-labs/atlaspack/pull/721) [`069de47`](https://github.com/atlassian-labs/atlaspack/commit/069de478e64fb5889f6f2ce023eb510782767fbd) Thanks [@benjervis](https://github.com/benjervis)! - Add support for bundle merging based on `webpackChunkName` comments.
+
+  Adding a `webpackChunkName` comment to an import will allow the bundler to merge multiple imports into a single bundle.
+
+  e.g.:
+
+  ```ts
+  import(/* webpackChunkName: "my-chunk" */ './my-module');
+  import(/* webpackChunkName: "my-chunk" */ './another-module');
+  ```
+
+  This can be enabled with the feature flag `supportWebpackChunkName`.
+
+### Patch Changes
+
+- Updated dependencies [[`069de47`](https://github.com/atlassian-labs/atlaspack/commit/069de478e64fb5889f6f2ce023eb510782767fbd)]:
+  - @atlaspack/feature-flags@2.20.0
+  - @atlaspack/graph@3.5.10
+  - @atlaspack/utils@2.17.3
+  - @atlaspack/plugin@2.14.21
+
 ## 3.1.2
 
 ### Patch Changes

package/lib/DefaultBundler.js

@@ -59,7 +59,6 @@ var _default = exports.default = new (_plugin().Bundler)({
     logger
   }) {
     let targetMap = getEntryByTarget(bundleGraph); // Organize entries by target output folder/ distDir
-    // @ts-expect-error TS2304
     let graphs = [];
     for (let entries of targetMap.values()) {
       let singleFileEntries = new Map();
@@ -76,7 +75,9 @@ var _default = exports.default = new (_plugin().Bundler)({
       }
 
       // Create separate bundleGraphs per distDir
-      graphs.push((0, _idealGraph.createIdealGraph)(bundleGraph, config, idealGraphEntries, logger));
+      graphs.push(
+      // $FlowFixMe
+      (0, _idealGraph.createIdealGraph)(bundleGraph, config, idealGraphEntries, logger));
 
       // Do this after the ideal graph so that the mutation of the bundleGraph doesn't
       // interfere with the main bundling algorithm
@@ -95,11 +96,7 @@ function getEntryByTarget(bundleGraph) {
   // Find entries from assetGraph per target
   let targets = new (_utils().DefaultMap)(() => new Map());
   bundleGraph.traverse({
-    enter(
-    // @ts-expect-error TS2304
-    node, context,
-    // @ts-expect-error TS2304
-    actions) {
+    enter(node, context, actions) {
       if (node.type !== 'asset') {
         return node;
       }

package/lib/bundleMerge.js

@@ -38,7 +38,6 @@ function getBundlesForBundleGroup(bundleGraph, bundleGroupId) {
   let count = 0;
   bundleGraph.traverse(nodeId => {
     var _bundleGraph$getNode;
-    // @ts-expect-error TS2339
     if (((_bundleGraph$getNode = bundleGraph.getNode(nodeId)) === null || _bundleGraph$getNode === void 0 ? void 0 : _bundleGraph$getNode.bundleBehavior) !== 'inline') {
       count++;
     }
@@ -119,9 +118,9 @@ function getPossibleMergeCandidates(bundleGraph, bundles) {
     for (let j = i + 1; j < mergeCandidates.length; j++) {
       let a = mergeCandidates[i];
       let b = mergeCandidates[j];
-
-      // @ts-expect-error TS18048
-      if (a.bundle.internalizedAssets.equals(b.bundle.internalizedAssets)) {
+      if (
+      // $FlowFixMe both bundles will always have internalizedAssets
+      a.bundle.internalizedAssets.equals(b.bundle.internalizedAssets)) {
         uniquePairs.push([a, b]);
       }
     }

package/lib/bundlerConfig.js

@@ -39,13 +39,14 @@ function resolveModeConfig(config, mode) {
   for (const key of Object.keys(config)) {
     if (key === 'development' || key === 'production') {
       if (key === mode) {
-        // @ts-expect-error TS2322
         modeConfig = config[key];
       }
     } else {
       generalConfig[key] = config[key];
     }
   }
+
+  // $FlowFixMe Not sure how to convince flow here...
   return {
     ...generalConfig,
     ...modeConfig
@@ -171,7 +172,6 @@ async function loadBundlerConfig(config, options, logger) {
       ...HTTP_OPTIONS['2'],
       projectRoot: options.projectRoot
     };
-    // @ts-expect-error TS2322
     return modDefault;
   }
   (0, _assert().default)(((_conf = conf) === null || _conf === void 0 ? void 0 : _conf.contents) != null);
@@ -212,7 +212,6 @@ async function loadBundlerConfig(config, options, logger) {
     prependKey: `/${(0, _diagnostic().encodeJSONKeyComponent)('@atlaspack/bundler-default')}`
   }, '@atlaspack/bundler-default', 'Invalid config for @atlaspack/bundler-default');
   let http = modeConfig.http ?? 2;
-  // @ts-expect-error TS7053
   let defaults = HTTP_OPTIONS[http];
   return {
     minBundles: modeConfig.minBundles ?? defaults.minBundles,

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,8 +179,6 @@ function decorateLegacyGraph(idealGraph, bundleGraph) {
       bundleGraph.createAssetReference(dependency, asset, legacyBundle);
     }
   }
-
-  // @ts-expect-error TS2488
   for (let {
     type,
     from,
@@ -173,14 +188,12 @@ 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,7 +50,6 @@ 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,
@@ -66,6 +65,11 @@ 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
@@ -122,7 +126,6 @@ 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);
       }
     }
@@ -159,7 +162,6 @@ function createIdealGraph(assetGraph, config, entries, logger) {
           // 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);
           }
           if (assetRegexes.some(regex => regex.test(projectRelativePath))) {
@@ -200,9 +202,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
    * adding only that asset to each bundle, not its entire subgraph.
    */
   assetGraph.traverse({
-    enter(node, context,
-    // @ts-expect-error TS2304
-    actions) {
+    enter(node, context, 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
@@ -287,9 +287,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
             }), dependencyBundleGraph.addNodeByContentKeyIfNeeded(String(bundleId), {
               value: bundle,
               type: 'bundle'
-            }),
-            // @ts-expect-error TS7053
-            dependencyPriorityEdges[dependency.priority]);
+            }), 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];
@@ -349,16 +347,13 @@ 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)(
-            // @ts-expect-error TS2367
-            bundle !== 'root' && bundle != null && bundleId != null);
+            (0, _assert().default)(bundle !== 'root' && bundle != null && bundleId != null);
             manualAssetToBundle.set(childAsset, bundleId);
             if (!bundle.assets.has(childAsset)) {
               // Add asset to bundle
@@ -379,7 +374,6 @@ 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) {
@@ -608,11 +602,8 @@ 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;
       }
     }
@@ -810,6 +801,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()) {
@@ -826,9 +819,8 @@ 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++) {
@@ -850,10 +842,8 @@ 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;
           }
         }
@@ -866,21 +856,66 @@ 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) {
+        mergeBundles(firstBundleId, bundleId);
+      }
+    }
+  }
 
   // Step merge shared bundles that meet the overlap threshold
   // This step is skipped by default as the threshold defaults to 1
@@ -899,7 +934,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.
@@ -912,7 +947,6 @@ 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');
-        // @ts-expect-error TS2365
         return count + (bundle.bundleBehavior !== 'inline');
       }, 0);
       if (numBundlesContributingToPRL > config.maxParallelRequests) {
@@ -942,9 +976,7 @@ 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
@@ -987,22 +1019,32 @@ 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
-    (0, _assert().default)(bundleToKeep.internalizedAssets && bundleToRemove.internalizedAssets, 'All shared bundles should have internalized assets');
-    bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
+    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;
@@ -1010,6 +1052,66 @@ 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;
+        }
+
+        // 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(mergeConfig) {
@@ -1044,26 +1146,29 @@ function createIdealGraph(assetGraph, config, entries, logger) {
         })
       };
     }));
+    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
   if (modifiedSourceBundles.size > 0) {
     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) => {
+      bundle.assets = new Set([...bundle.assets].sort((a, b) => {
         let aIndex = (0, _nullthrows().default)(assetOrderMap.get(a));
         let bIndex = (0, _nullthrows().default)(assetOrderMap.get(b));
         return aIndex - bIndex;
@@ -1151,6 +1256,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,
@@ -1166,6 +1272,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

@@ -13,6 +13,7 @@ function _manyKeysMap() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe
 let caches = [];
 function clearCaches() {
   for (let cache of caches) {
@@ -31,8 +32,8 @@ function memoize(fn) {
     }
 
     // Calculate the result and cache it
-    // @ts-expect-error TS2683
     const result = fn.apply(this, args);
+    // $FlowFixMe
     cache.set(args, result);
     return result;
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-default",
-  "version": "3.1.3-typescript-bc4459c37.0",
+  "version": "3.2.0",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -10,24 +10,19 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "./lib/DefaultBundler.js",
-  "source": "./src/DefaultBundler.ts",
-  "types": "./lib/DefaultBundler.d.ts",
+  "main": "lib/DefaultBundler.js",
+  "source": "src/DefaultBundler.js",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.2-typescript-bc4459c37.0",
-    "@atlaspack/feature-flags": "2.19.3-typescript-bc4459c37.0",
-    "@atlaspack/graph": "3.5.10-typescript-bc4459c37.0",
-    "@atlaspack/plugin": "2.14.21-typescript-bc4459c37.0",
-    "@atlaspack/rust": "3.4.2-typescript-bc4459c37.0",
-    "@atlaspack/utils": "2.17.3-typescript-bc4459c37.0",
-    "many-keys-map": "^1.0.3",
-    "nullthrows": "^1.1.1"
-  },
-  "scripts": {
-    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
-  },
-  "gitHead": "bc4459c37a38ef1f74772126637e1d8841d1fcb0"
-}
+    "@atlaspack/diagnostic": "2.14.1",
+    "@atlaspack/feature-flags": "2.20.0",
+    "@atlaspack/graph": "3.5.10",
+    "@atlaspack/plugin": "2.14.21",
+    "@atlaspack/rust": "3.4.1",
+    "@atlaspack/utils": "2.17.3",
+    "nullthrows": "^1.1.1",
+    "many-keys-map": "^1.0.3"
+  }
+}