@atlaspack/bundler-default 2.14.5-canary.36 → 2.14.5-canary.360

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;
+  };
+}

package/lib/stats.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Stats = void 0;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+class Stats {
+  merges = new (_utils().DefaultMap)(() => []);
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  trackMerge(bundleToKeep, bundleToRemove, reason) {
+    if (!_utils().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().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().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/types/DefaultBundler.d.ts

@@ -0,0 +1,18 @@
+import { Bundler } from '@atlaspack/plugin';
+/**
+ *
+ * The Bundler works by creating an IdealGraph, which contains a BundleGraph that models bundles
+ * connected to other bundles by what references them, and thus models BundleGroups.
+ *
+ * First, we enter `bundle({bundleGraph, config})`. Here, "bundleGraph" is actually just the
+ * assetGraph turned into a type `MutableBundleGraph`, which will then be mutated in decorate,
+ * and turned into what we expect the bundleGraph to be as per the old (default) bundler structure
+ *  & what the rest of Atlaspack expects a BundleGraph to be.
+ *
+ * `bundle({bundleGraph, config})` First gets a Mapping of target to entries, In most cases there is
+ *  only one target, and one or more entries. (Targets are pertinent in monorepos or projects where you
+ *  will have two or more distDirs, or output folders.) Then calls create IdealGraph and Decorate per target.
+ *
+ */
+declare const _default: Bundler<unknown>;
+export default _default;

package/lib/types/MonolithicBundler.d.ts

@@ -0,0 +1,2 @@
+import type { Asset, Dependency, MutableBundleGraph } from '@atlaspack/types-internal';
+export declare function addJSMonolithBundle(bundleGraph: MutableBundleGraph, entryAsset: Asset, entryDep: Dependency): void;

package/lib/types/bundleMerge.d.ts

@@ -0,0 +1,9 @@
+import type { NodeId } from '@atlaspack/graph';
+import type { IdealBundleGraph } from './idealGraph';
+export type MergeGroup = {
+    overlapThreshold?: number;
+    maxBundleSize?: number;
+    sourceBundles?: Array<NodeId>;
+    minBundlesInGroup?: number;
+};
+export declare function findMergeCandidates(bundleGraph: IdealBundleGraph, bundles: Array<NodeId>, config: Array<MergeGroup>): Array<Array<NodeId>>;

package/lib/types/bundlerConfig.d.ts

@@ -0,0 +1,36 @@
+import type { Config, PluginOptions, PluginLogger } from '@atlaspack/types-internal';
+type Glob = string;
+type ManualSharedBundles = Array<{
+    name: string;
+    assets: Array<Glob>;
+    types?: Array<string>;
+    root?: string;
+    split?: number;
+}>;
+export type SharedBundleMergeCandidates = Array<{
+    overlapThreshold?: number;
+    maxBundleSize?: number;
+    sourceBundles?: Array<string>;
+    minBundlesInGroup?: number;
+}>;
+export interface AsyncBundleMerge {
+    /** Consider all async bundles smaller than this for merging */
+    bundleSize: number;
+    /** The max bytes allowed to be potentially overfetched due to a merge  */
+    maxOverfetchSize: number;
+    /** Bundles to ignore from merging */
+    ignore?: Array<Glob>;
+}
+export type ResolvedBundlerConfig = {
+    minBundles: number;
+    minBundleSize: number;
+    maxParallelRequests: number;
+    projectRoot: string;
+    disableSharedBundles: boolean;
+    manualSharedBundles: ManualSharedBundles;
+    loadConditionalBundlesInParallel?: boolean;
+    sharedBundleMerge?: SharedBundleMergeCandidates;
+    asyncBundleMerge?: AsyncBundleMerge;
+};
+export declare function loadBundlerConfig(config: Config, options: PluginOptions, logger: PluginLogger): Promise<ResolvedBundlerConfig>;
+export {};

package/lib/types/decorateLegacyGraph.d.ts

@@ -0,0 +1,3 @@
+import type { MutableBundleGraph } from '@atlaspack/types-internal';
+import type { IdealGraph } from './idealGraph';
+export declare function decorateLegacyGraph(idealGraph: IdealGraph, bundleGraph: MutableBundleGraph): void;

package/lib/types/idealGraph.d.ts

@@ -0,0 +1,40 @@
+import { BitSet, ContentGraph, Graph, NodeId } from '@atlaspack/graph';
+import type { Asset, BundleBehavior, Dependency, Environment, MutableBundleGraph, Target, PluginLogger } from '@atlaspack/types';
+import { DefaultMap } from '@atlaspack/utils';
+import type { ResolvedBundlerConfig } from './bundlerConfig';
+export type Bundle = {
+    uniqueKey: string | null | undefined;
+    assets: Set<Asset>;
+    internalizedAssets?: BitSet;
+    bundleBehavior?: BundleBehavior | null | undefined;
+    needsStableName: boolean;
+    mainEntryAsset: Asset | null | undefined;
+    bundleRoots: Set<Asset>;
+    size: number;
+    sourceBundles: Set<NodeId>;
+    target: Target;
+    env: Environment;
+    type: string;
+    manualSharedBundle: string | null | undefined;
+};
+export type DependencyBundleGraph = ContentGraph<{
+    value: Bundle;
+    type: 'bundle';
+} | {
+    value: Dependency;
+    type: 'dependency';
+}, number>;
+export declare const idealBundleGraphEdges: Readonly<{
+    default: 1;
+    conditional: 2;
+}>;
+export type IdealBundleGraph = Graph<Bundle | 'root', (typeof idealBundleGraphEdges)[keyof typeof idealBundleGraphEdges]>;
+export type IdealGraph = {
+    assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>;
+    assets: Array<Asset>;
+    bundleGraph: IdealBundleGraph;
+    bundleGroupBundleIds: Set<NodeId>;
+    dependencyBundleGraph: DependencyBundleGraph;
+    manualAssetToBundle: Map<Asset, NodeId>;
+};
+export declare function createIdealGraph(assetGraph: MutableBundleGraph, config: ResolvedBundlerConfig, entries: Map<Asset, Dependency>, logger: PluginLogger): IdealGraph;

package/lib/types/memoize.d.ts

@@ -0,0 +1,2 @@
+export declare function clearCaches(): void;
+export declare function memoize<Args extends Array<unknown>, Return>(fn: (...args: Args) => Return): (...args: Args) => Return;

package/lib/types/stats.d.ts

@@ -0,0 +1,16 @@
+import { NodeId } from '@atlaspack/graph';
+import { DefaultMap } from '@atlaspack/utils';
+import { Bundle } from './idealGraph';
+interface MergedBundle {
+    id: NodeId;
+    reason: string;
+}
+export declare class Stats {
+    projectRoot: string;
+    merges: DefaultMap<NodeId, MergedBundle[]>;
+    constructor(projectRoot: string);
+    trackMerge(bundleToKeep: NodeId, bundleToRemove: NodeId, reason: string): void;
+    getBundleLabel(bundle: Bundle): string;
+    report(getBundle: (bundleId: NodeId) => Bundle | null | undefined): void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-default",
-  "version": "2.14.5-canary.36+2d10c6656",
+  "version": "2.14.5-canary.360+fc3adc098",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -10,19 +10,27 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/DefaultBundler.js",
-  "source": "src/DefaultBundler.js",
+  "main": "./lib/DefaultBundler.js",
+  "source": "./src/DefaultBundler.ts",
+  "types": "./lib/types/DefaultBundler.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.104+2d10c6656",
-    "@atlaspack/feature-flags": "2.14.1-canary.104+2d10c6656",
-    "@atlaspack/graph": "3.4.1-canary.104+2d10c6656",
-    "@atlaspack/plugin": "2.14.5-canary.36+2d10c6656",
-    "@atlaspack/rust": "3.2.1-canary.36+2d10c6656",
-    "@atlaspack/utils": "2.14.5-canary.36+2d10c6656",
-    "nullthrows": "^1.1.1"
+    "@atlaspack/diagnostic": "2.14.1-canary.428+fc3adc098",
+    "@atlaspack/feature-flags": "2.14.1-canary.428+fc3adc098",
+    "@atlaspack/graph": "3.4.1-canary.428+fc3adc098",
+    "@atlaspack/plugin": "2.14.5-canary.360+fc3adc098",
+    "@atlaspack/rust": "3.2.1-canary.360+fc3adc098",
+    "@atlaspack/types-internal": "2.14.1-canary.428+fc3adc098",
+    "@atlaspack/utils": "2.14.5-canary.360+fc3adc098",
+    "@types/sorted-array-functions": "^1.0.0",
+    "many-keys-map": "^1.0.3",
+    "nullthrows": "^1.1.1",
+    "sorted-array-functions": "^1.0.0"
   },
-  "gitHead": "2d10c6656fc58743c5dbed1d2b6c5666887f9fe4"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "fc3adc098f583e40d6d7687412cac6dde7cbb3f3"
+}

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {Bundler} from '@atlaspack/plugin';
 import type {Asset, Dependency, MutableBundleGraph} from '@atlaspack/types';
 import {DefaultMap} from '@atlaspack/utils';
@@ -25,14 +23,15 @@ import {addJSMonolithBundle} from './MonolithicBundler';
  *  will have two or more distDirs, or output folders.) Then calls create IdealGraph and Decorate per target.
  *
  */
-export default (new Bundler({
+export default new Bundler({
   loadConfig({config, options, logger}) {
     return loadBundlerConfig(config, options, logger);
   },
 
   bundle({bundleGraph, config, logger}) {
     let targetMap = getEntryByTarget(bundleGraph); // Organize entries by target output folder/ distDir
-    let graphs = [];
+    // @ts-expect-error TS2304
+    let graphs: Array<IdealGraph> = [];
 
     for (let entries of targetMap.values()) {
       let singleFileEntries = new Map();
@@ -64,7 +63,7 @@ export default (new Bundler({
     }
   },
   optimize() {},
-}): Bundler);
+}) as Bundler<unknown>;
 
 function getEntryByTarget(
   bundleGraph: MutableBundleGraph,
@@ -74,7 +73,23 @@ function getEntryByTarget(
     () => new Map(),
   );
   bundleGraph.traverse({
-    enter(node, context, actions) {
+    enter(
+      // @ts-expect-error TS2304
+      node: BundleGraphTraversable,
+      context:
+        | {
+            readonly type: 'asset';
+            value: Asset;
+          }
+        | null
+        | undefined
+        | {
+            readonly type: 'dependency';
+            value: Dependency;
+          },
+      // @ts-expect-error TS2304
+      actions: TraversalActions,
+    ) {
       if (node.type !== 'asset') {
         return node;
       }

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

@@ -1,5 +1,10 @@
-// @flow strict-local
-import type {Asset, Dependency, MutableBundleGraph} from '@atlaspack/types';
+import type {
+  Asset,
+  Dependency,
+  MutableBundleGraph,
+} from '@atlaspack/types-internal';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
 import nullthrows from 'nullthrows';
 
 export function addJSMonolithBundle(
@@ -13,7 +18,11 @@ export function addJSMonolithBundle(
   );
 
   // Create a single bundle to hold all JS assets
-  let bundle = bundleGraph.createBundle({entryAsset, target});
+  let bundle = bundleGraph.createBundle({
+    entryAsset,
+    target,
+    needsStableName: getFeatureFlag('singleFileOutputStableName'),
+  });
 
   bundleGraph.traverse(
     (node, _, actions) => {
@@ -39,9 +48,12 @@ export function addJSMonolithBundle(
       let assets = bundleGraph.getDependencyAssets(dependency);
 
       for (const asset of assets) {
-        if (asset.bundleBehavior === 'isolated') {
+        if (
+          asset.bundleBehavior === 'isolated' ||
+          asset.bundleBehavior === 'inlineIsolated'
+        ) {
           throw new Error(
-            'Isolated assets are not supported for single file output builds',
+            `${asset.bundleBehavior === 'isolated' ? 'Isolated' : 'Inline isolated'} assets are not supported for single file output builds`,
           );
         }
 

package/src/bundleMerge.ts

@@ -0,0 +1,250 @@
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+import {ContentGraph} from '@atlaspack/graph';
+import type {NodeId} from '@atlaspack/graph';
+import {setUnion, setIntersectStatic} from '@atlaspack/utils';
+import type {Bundle, IdealBundleGraph} from './idealGraph';
+import {memoize, clearCaches} from './memoize';
+
+function getBundlesForBundleGroup(
+  bundleGraph: IdealBundleGraph,
+  bundleGroupId: NodeId,
+): number {
+  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: Set<NodeId>,
+  sourceBundlesB: Set<NodeId>,
+): number => {
+  let allSourceBundles = setUnion(sourceBundlesA, sourceBundlesB);
+  let sharedSourceBundles = 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 checkBundleThreshold(
+  bundleA: MergeCandidate,
+  bundleB: MergeCandidate,
+  threshold: number,
+): boolean {
+  return (
+    getBundleOverlap(
+      bundleA.bundle.sourceBundles,
+      bundleB.bundle.sourceBundles,
+    ) >= threshold
+  );
+}
+
+let checkSharedSourceBundles = memoize(
+  (bundle: Bundle, importantAncestorBundles: Array<NodeId>): boolean => {
+    return importantAncestorBundles.every((ancestorId) =>
+      bundle.sourceBundles.has(ancestorId),
+    );
+  },
+);
+
+let hasSuitableBundleGroup = memoize(
+  (
+    bundleGraph: IdealBundleGraph,
+    bundle: Bundle,
+    minBundlesInGroup: number,
+  ): boolean => {
+    for (let sourceBundle of bundle.sourceBundles) {
+      let bundlesInGroup = getBundlesForBundleGroup(bundleGraph, sourceBundle);
+
+      if (bundlesInGroup >= minBundlesInGroup) {
+        return true;
+      }
+    }
+    return false;
+  },
+);
+
+function validMerge(
+  bundleGraph: IdealBundleGraph,
+  config: MergeGroup,
+  bundleA: MergeCandidate,
+  bundleB: MergeCandidate,
+): boolean {
+  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 true;
+}
+
+function getMergeClusters(
+  graph: ContentGraph<NodeId, EdgeType>,
+  candidates: Map<NodeId, EdgeType>,
+): Array<Array<NodeId>> {
+  let clusters: Array<Array<NodeId>> = [];
+
+  for (let [candidate, edgeType] of candidates.entries()) {
+    let cluster: Array<NodeId> = [];
+
+    graph.traverse(
+      (nodeId) => {
+        cluster.push(nullthrows(graph.getNode(nodeId)));
+        // Remove node from candidates as it has already been processed
+        candidates.delete(nodeId);
+      },
+      candidate,
+      edgeType,
+    );
+    clusters.push(cluster);
+  }
+
+  return clusters;
+}
+
+type MergeCandidate = {
+  bundle: Bundle;
+  id: NodeId;
+  contentKey: string;
+};
+function getPossibleMergeCandidates(
+  bundleGraph: IdealBundleGraph,
+  bundles: Array<NodeId>,
+): Array<[MergeCandidate, MergeCandidate]> {
+  let mergeCandidates = bundles.map((bundleId) => {
+    let bundle = bundleGraph.getNode(bundleId);
+    invariant(bundle && bundle !== 'root', 'Bundle should exist');
+
+    return {
+      id: bundleId,
+      bundle,
+      contentKey: bundleId.toString(),
+    };
+  });
+
+  const uniquePairs: Array<[MergeCandidate, MergeCandidate]> = [];
+
+  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;
+}
+
+export type MergeGroup = {
+  overlapThreshold?: number;
+  maxBundleSize?: number;
+  sourceBundles?: Array<NodeId>;
+  minBundlesInGroup?: number;
+};
+type EdgeType = number;
+
+export function findMergeCandidates(
+  bundleGraph: IdealBundleGraph,
+  bundles: Array<NodeId>,
+  config: Array<MergeGroup>,
+): Array<Array<NodeId>> {
+  let graph = new ContentGraph<NodeId, EdgeType>();
+  let candidates = new Map<NodeId, EdgeType>();
+
+  let allPossibleMergeCandidates = getPossibleMergeCandidates(
+    bundleGraph,
+    bundles,
+  );
+
+  // Build graph of clustered merge candidates
+  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 bundleNode = graph.addNodeByContentKeyIfNeeded(
+        candidateA.contentKey,
+        candidateA.id,
+      );
+      let otherBundleNode = graph.addNodeByContentKeyIfNeeded(
+        candidateB.contentKey,
+        candidateB.id,
+      );
+
+      // 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),
+    );
+  }
+
+  clearCaches();
+
+  return getMergeClusters(graph, candidates);
+}