@atlaspack/bundler-default 2.14.5-canary.35 → 2.14.5-canary.351

package/dist/memoize.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCaches = clearCaches;
+exports.memoize = memoize;
+const many_keys_map_1 = __importDefault(require("many-keys-map"));
+let caches = [];
+function clearCaches() {
+    for (let cache of caches) {
+        cache.clear();
+    }
+}
+function memoize(fn) {
+    let cache = new many_keys_map_1.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;
+    };
+}

package/dist/stats.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stats = void 0;
+const path_1 = require("path");
+const utils_1 = require("@atlaspack/utils");
+class Stats {
+    constructor(projectRoot) {
+        this.merges = new utils_1.DefaultMap(() => []);
+        this.projectRoot = projectRoot;
+    }
+    trackMerge(bundleToKeep, bundleToRemove, reason) {
+        if (!utils_1.debugTools['bundle-stats']) {
+            return;
+        }
+        this.merges
+            .get(bundleToKeep)
+            .push(...this.merges.get(bundleToRemove), { id: bundleToRemove, reason });
+        this.merges.delete(bundleToRemove);
+    }
+    getBundleLabel(bundle) {
+        if (bundle.manualSharedBundle) {
+            return bundle.manualSharedBundle;
+        }
+        if (bundle.mainEntryAsset) {
+            let relativePath = (0, path_1.relative)(this.projectRoot, bundle.mainEntryAsset.filePath);
+            if (relativePath.length > 100) {
+                relativePath =
+                    relativePath.slice(0, 50) + '...' + relativePath.slice(-50);
+            }
+            return relativePath;
+        }
+        return `shared`;
+    }
+    report(getBundle) {
+        if (!utils_1.debugTools['bundle-stats']) {
+            return;
+        }
+        let mergeResults = [];
+        let totals = {
+            label: 'Totals',
+            merges: 0,
+        };
+        for (let [bundleId, mergedBundles] of this.merges) {
+            let bundle = getBundle(bundleId);
+            if (!bundle) {
+                continue;
+            }
+            let result = {
+                label: this.getBundleLabel(bundle),
+                size: bundle.size,
+                merges: mergedBundles.length,
+            };
+            for (let merged of mergedBundles) {
+                result[merged.reason] = (result[merged.reason] || 0) + 1;
+                totals[merged.reason] = (totals[merged.reason] || 0) + 1;
+            }
+            totals.merges += mergedBundles.length;
+            mergeResults.push(result);
+        }
+        mergeResults.sort((a, b) => {
+            // Sort by bundle size descending
+            return b.size - a.size;
+        });
+        mergeResults.push(totals);
+        // eslint-disable-next-line no-console
+        console.table(mergeResults);
+    }
+}
+exports.Stats = Stats;

package/lib/DefaultBundler.js

@@ -59,6 +59,7 @@ 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();
@@ -94,7 +95,11 @@ function getEntryByTarget(bundleGraph) {
   // Find entries from assetGraph per target
   let targets = new (_utils().DefaultMap)(() => new Map());
   bundleGraph.traverse({
-    enter(node, context, actions) {
+    enter(
+    // @ts-expect-error TS2304
+    node, context,
+    // @ts-expect-error TS2304
+    actions) {
       if (node.type !== 'asset') {
         return node;
       }

package/lib/MonolithicBundler.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addJSMonolithBundle = addJSMonolithBundle;
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -18,7 +25,8 @@ function addJSMonolithBundle(bundleGraph, entryAsset, entryDep) {
   // Create a single bundle to hold all JS assets
   let bundle = bundleGraph.createBundle({
     entryAsset,
-    target
+    target,
+    needsStableName: (0, _featureFlags().getFeatureFlag)('singleFileOutputStableName')
   });
   bundleGraph.traverse((node, _, actions) => {
     // JS assets can be added to the bundle, but the rest are ignored
@@ -38,8 +46,8 @@ function addJSMonolithBundle(bundleGraph, entryAsset, entryDep) {
     }
     let assets = bundleGraph.getDependencyAssets(dependency);
     for (const asset of assets) {
-      if (asset.bundleBehavior === 'isolated') {
-        throw new Error('Isolated assets are not supported for single file output builds');
+      if (asset.bundleBehavior === 'isolated' || asset.bundleBehavior === 'inlineIsolated') {
+        throw new Error(`${asset.bundleBehavior === 'isolated' ? 'Isolated' : 'Inline isolated'} assets are not supported for single file output builds`);
       }
 
       // For assets marked as inline, we create new bundles and let other

package/lib/bundleMerge.js

@@ -25,67 +25,136 @@ function _graph() {
   };
   return data;
 }
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _memoize = require("./memoize");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getBundlesForBundleGroup(bundleGraph, bundleGroupId) {
+  let count = 0;
+  bundleGraph.traverse(nodeId => {
+    const node = bundleGraph.getNode(nodeId);
+    if (node && (node === 'root' || node.bundleBehavior !== 'inline' && node.bundleBehavior !== 'inlineIsolated')) {
+      count++;
+    }
+  }, bundleGroupId);
+  return count;
+}
+let getBundleOverlap = (sourceBundlesA, sourceBundlesB) => {
+  let allSourceBundles = (0, _utils().setUnion)(sourceBundlesA, sourceBundlesB);
+  let sharedSourceBundles = (0, _utils().setIntersectStatic)(sourceBundlesA, sourceBundlesB);
+  return sharedSourceBundles.size / allSourceBundles.size;
+};
+
 // Returns a decimal showing the proportion source bundles are common to
 // both bundles versus the total number of source bundles.
-function scoreBundleMerge(bundleA, bundleB) {
-  let sharedSourceBundles = 0;
-  let allSourceBundles = new Set([...bundleA.sourceBundles, ...bundleB.sourceBundles]);
-  for (let bundle of bundleB.sourceBundles) {
-    if (bundleA.sourceBundles.has(bundle)) {
-      sharedSourceBundles++;
+function checkBundleThreshold(bundleA, bundleB, threshold) {
+  return getBundleOverlap(bundleA.bundle.sourceBundles, bundleB.bundle.sourceBundles) >= threshold;
+}
+let checkSharedSourceBundles = (0, _memoize.memoize)((bundle, importantAncestorBundles) => {
+  return importantAncestorBundles.every(ancestorId => bundle.sourceBundles.has(ancestorId));
+});
+let hasSuitableBundleGroup = (0, _memoize.memoize)((bundleGraph, bundle, minBundlesInGroup) => {
+  for (let sourceBundle of bundle.sourceBundles) {
+    let bundlesInGroup = getBundlesForBundleGroup(bundleGraph, sourceBundle);
+    if (bundlesInGroup >= minBundlesInGroup) {
+      return true;
+    }
+  }
+  return false;
+});
+function validMerge(bundleGraph, config, bundleA, bundleB) {
+  if (config.maxBundleSize != null) {
+    if (bundleA.bundle.size > config.maxBundleSize || bundleB.bundle.size > config.maxBundleSize) {
+      return false;
+    }
+  }
+  if (config.overlapThreshold != null) {
+    if (!checkBundleThreshold(bundleA, bundleB, config.overlapThreshold)) {
+      return false;
+    }
+  }
+  if (config.sourceBundles != null) {
+    if (!checkSharedSourceBundles(bundleA.bundle, config.sourceBundles) || !checkSharedSourceBundles(bundleB.bundle, config.sourceBundles)) {
+      return false;
+    }
+  }
+  if (config.minBundlesInGroup != null) {
+    if (!hasSuitableBundleGroup(bundleGraph, bundleA.bundle, config.minBundlesInGroup) || !hasSuitableBundleGroup(bundleGraph, bundleB.bundle, config.minBundlesInGroup)) {
+      return false;
     }
   }
-  return sharedSourceBundles / allSourceBundles.size;
+  return true;
 }
 function getMergeClusters(graph, candidates) {
   let clusters = [];
-  for (let candidate of candidates) {
+  for (let [candidate, edgeType] of candidates.entries()) {
     let cluster = [];
     graph.traverse(nodeId => {
       cluster.push((0, _nullthrows().default)(graph.getNode(nodeId)));
       // Remove node from candidates as it has already been processed
       candidates.delete(nodeId);
-    }, candidate);
+    }, candidate, edgeType);
     clusters.push(cluster);
   }
   return clusters;
 }
-function findMergeCandidates(bundleGraph, bundles, threshold) {
+function getPossibleMergeCandidates(bundleGraph, bundles) {
+  let mergeCandidates = bundles.map(bundleId => {
+    let bundle = bundleGraph.getNode(bundleId);
+    (0, _assert().default)(bundle && bundle !== 'root', 'Bundle should exist');
+    return {
+      id: bundleId,
+      bundle,
+      contentKey: bundleId.toString()
+    };
+  });
+  const uniquePairs = [];
+  for (let i = 0; i < mergeCandidates.length; i++) {
+    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)) {
+        uniquePairs.push([a, b]);
+      }
+    }
+  }
+  return uniquePairs;
+}
+function findMergeCandidates(bundleGraph, bundles, config) {
   let graph = new (_graph().ContentGraph)();
-  let seen = new Set();
-  let candidates = new Set();
+  let candidates = new Map();
+  let allPossibleMergeCandidates = getPossibleMergeCandidates(bundleGraph, bundles);
 
   // Build graph of clustered merge candidates
-  for (let bundleId of bundles) {
-    let bundle = bundleGraph.getNode(bundleId);
-    (0, _assert().default)(bundle && bundle !== 'root');
-    if (bundle.type !== 'js') {
-      continue;
-    }
-    for (let otherBundleId of bundles) {
-      if (bundleId === otherBundleId) {
+  for (let i = 0; i < config.length; i++) {
+    // Ensure edge type coresponds to config index
+    let edgeType = i + 1;
+    for (let group of allPossibleMergeCandidates) {
+      let candidateA = group[0];
+      let candidateB = group[1];
+      if (!validMerge(bundleGraph, config[i], candidateA, candidateB)) {
         continue;
       }
-      let key = [bundleId, otherBundleId].sort().join(':');
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-      let otherBundle = bundleGraph.getNode(otherBundleId);
-      (0, _assert().default)(otherBundle && otherBundle !== 'root');
-      let score = scoreBundleMerge(bundle, otherBundle);
-      if (score >= threshold) {
-        let bundleNode = graph.addNodeByContentKeyIfNeeded(bundleId.toString(), bundleId);
-        let otherBundleNode = graph.addNodeByContentKeyIfNeeded(otherBundleId.toString(), otherBundleId);
+      let bundleNode = graph.addNodeByContentKeyIfNeeded(candidateA.contentKey, candidateA.id);
+      let otherBundleNode = graph.addNodeByContentKeyIfNeeded(candidateB.contentKey, candidateB.id);
 
-        // Add edge in both directions
-        graph.addEdge(bundleNode, otherBundleNode);
-        graph.addEdge(otherBundleNode, bundleNode);
-        candidates.add(bundleNode);
-        candidates.add(otherBundleNode);
-      }
+      // Add edge in both directions
+      graph.addEdge(bundleNode, otherBundleNode, edgeType);
+      graph.addEdge(otherBundleNode, bundleNode, edgeType);
+      candidates.set(bundleNode, edgeType);
+      candidates.set(otherBundleNode, edgeType);
     }
+
+    // Remove bundles that have been allocated to a higher priority merge
+    allPossibleMergeCandidates = allPossibleMergeCandidates.filter(group => !graph.hasContentKey(group[0].contentKey) && !graph.hasContentKey(group[1].contentKey));
   }
+  (0, _memoize.clearCaches)();
   return getMergeClusters(graph, candidates);
 }

package/lib/bundlerConfig.js

@@ -39,14 +39,13 @@ 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
@@ -61,7 +60,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 30000,
     maxParallelRequests: 6,
     disableSharedBundles: false,
-    sharedBundleMergeThreshold: 1
+    sharedBundleMerge: []
   },
   '2': {
     minBundles: 1,
@@ -69,7 +68,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 20000,
     maxParallelRequests: 25,
     disableSharedBundles: false,
-    sharedBundleMergeThreshold: 1
+    sharedBundleMerge: []
   }
 };
 const CONFIG_SCHEMA = {
@@ -110,6 +109,50 @@ const CONFIG_SCHEMA = {
         additionalProperties: false
       }
     },
+    sharedBundleMerge: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          overlapThreshold: {
+            type: 'number'
+          },
+          maxBundleSize: {
+            type: 'number'
+          },
+          sourceBundles: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          minBundlesInGroup: {
+            type: 'number'
+          }
+        },
+        additionalProperties: false
+      }
+    },
+    asyncBundleMerge: {
+      type: 'object',
+      properties: {
+        bundleSize: {
+          type: 'number',
+          required: true
+        },
+        maxOverfetchSize: {
+          type: 'number',
+          required: true
+        },
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    },
     minBundles: {
       type: 'number'
     },
@@ -148,6 +191,7 @@ 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);
@@ -183,16 +227,18 @@ async function loadBundlerConfig(config, options, logger) {
   }
   _utils().validateSchema.diagnostic(CONFIG_SCHEMA, {
     data: modeConfig,
-    source: await options.inputFS.readFile(conf.filePath, 'utf8'),
+    source: () => options.inputFS.readFileSync(conf.filePath, 'utf8'),
     filePath: conf.filePath,
     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,
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
-    sharedBundleMergeThreshold: modeConfig.sharedBundleMergeThreshold ?? defaults.sharedBundleMergeThreshold,
+    sharedBundleMerge: modeConfig.sharedBundleMerge ?? defaults.sharedBundleMerge,
+    asyncBundleMerge: modeConfig.asyncBundleMerge,
     maxParallelRequests: modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,
     disableSharedBundles: modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,

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) {