@atlaspack/bundler-default 2.14.5-canary.20 → 2.14.5-canary.200

package/src/memoize.ts

@@ -0,0 +1,32 @@
+import ManyKeysMap from 'many-keys-map';
+
+let caches: Array<any> = [];
+
+export function clearCaches() {
+  for (let cache of caches) {
+    cache.clear();
+  }
+}
+
+export function memoize<Args extends Array<unknown>, Return>(
+  fn: (...args: Args) => Return,
+): (...args: Args) => Return {
+  let cache = new ManyKeysMap();
+  caches.push(cache);
+
+  return function (...args: Args): Return {
+    // 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/src/stats.ts

@@ -0,0 +1,97 @@
+import {relative} from 'path';
+import {NodeId} from '@atlaspack/graph';
+import {DefaultMap, debugTools} from '@atlaspack/utils';
+
+import {Bundle} from './idealGraph';
+
+interface MergedBundle {
+  id: NodeId;
+  reason: string;
+}
+
+export class Stats {
+  projectRoot: string;
+  merges: DefaultMap<NodeId, MergedBundle[]> = new DefaultMap(() => []);
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+  }
+
+  trackMerge(bundleToKeep: NodeId, bundleToRemove: NodeId, reason: string) {
+    if (!debugTools['bundle-stats']) {
+      return;
+    }
+
+    this.merges
+      .get(bundleToKeep)
+      .push(...this.merges.get(bundleToRemove), {id: bundleToRemove, reason});
+    this.merges.delete(bundleToRemove);
+  }
+
+  getBundleLabel(bundle: Bundle): string {
+    if (bundle.manualSharedBundle) {
+      return bundle.manualSharedBundle;
+    }
+
+    if (bundle.mainEntryAsset) {
+      let relativePath = relative(
+        this.projectRoot,
+        bundle.mainEntryAsset.filePath,
+      );
+
+      if (relativePath.length > 100) {
+        relativePath =
+          relativePath.slice(0, 50) + '...' + relativePath.slice(-50);
+      }
+
+      return relativePath;
+    }
+
+    return `shared`;
+  }
+
+  report(getBundle: (bundleId: NodeId) => Bundle | null | undefined): void {
+    if (!debugTools['bundle-stats']) {
+      return;
+    }
+
+    type MergeResult = Record<string, string | number>;
+    let mergeResults: Array<MergeResult> = [];
+
+    let totals: Record<string, string | number> = {
+      label: 'Totals',
+      merges: 0,
+    };
+
+    for (let [bundleId, mergedBundles] of this.merges) {
+      let bundle = getBundle(bundleId);
+      if (!bundle) {
+        continue;
+      }
+
+      let result: MergeResult = {
+        label: this.getBundleLabel(bundle),
+        size: bundle.size,
+        merges: mergedBundles.length,
+      };
+
+      for (let merged of mergedBundles) {
+        result[merged.reason] = ((result[merged.reason] as number) || 0) + 1;
+        totals[merged.reason] = ((totals[merged.reason] as number) || 0) + 1;
+      }
+
+      (totals.merges as number) += mergedBundles.length;
+      mergeResults.push(result);
+    }
+
+    mergeResults.sort((a, b) => {
+      // Sort by bundle size descending
+      return (b.size as number) - (a.size as number);
+    });
+
+    mergeResults.push(totals);
+
+    // eslint-disable-next-line no-console
+    console.table(mergeResults);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}

package/src/bundleMerge.js

@@ -1,103 +0,0 @@
-// @flow strict-local
-
-import invariant from 'assert';
-import nullthrows from 'nullthrows';
-import type {NodeId} from '@atlaspack/graph';
-import type {Bundle, IdealBundleGraph} from './idealGraph';
-import {ContentGraph} from '@atlaspack/graph';
-
-// Returns a decimal showing the proportion source bundles are common to
-// both bundles versus the total number of source bundles.
-function scoreBundleMerge(bundleA: Bundle, bundleB: Bundle): number {
-  let sharedSourceBundles = 0;
-  let allSourceBundles = new Set([
-    ...bundleA.sourceBundles,
-    ...bundleB.sourceBundles,
-  ]);
-
-  for (let bundle of bundleB.sourceBundles) {
-    if (bundleA.sourceBundles.has(bundle)) {
-      sharedSourceBundles++;
-    }
-  }
-
-  return sharedSourceBundles / allSourceBundles.size;
-}
-
-function getMergeClusters(
-  graph: ContentGraph<NodeId>,
-  candidates: Set<NodeId>,
-): Array<Array<NodeId>> {
-  let clusters = [];
-
-  for (let candidate of candidates) {
-    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);
-
-    clusters.push(cluster);
-  }
-
-  return clusters;
-}
-
-export function findMergeCandidates(
-  bundleGraph: IdealBundleGraph,
-  bundles: Array<NodeId>,
-  threshold: number,
-): Array<Array<NodeId>> {
-  let graph = new ContentGraph<NodeId>();
-  let seen = new Set<string>();
-  let candidates = new Set<NodeId>();
-
-  // Build graph of clustered merge candidates
-  for (let bundleId of bundles) {
-    let bundle = bundleGraph.getNode(bundleId);
-    invariant(bundle && bundle !== 'root');
-    if (bundle.type !== 'js') {
-      continue;
-    }
-
-    for (let otherBundleId of bundles) {
-      if (bundleId === otherBundleId) {
-        continue;
-      }
-
-      let key = [bundleId, otherBundleId].sort().join(':');
-
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-
-      let otherBundle = bundleGraph.getNode(otherBundleId);
-      invariant(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,
-        );
-
-        // Add edge in both directions
-        graph.addEdge(bundleNode, otherBundleNode);
-        graph.addEdge(otherBundleNode, bundleNode);
-
-        candidates.add(bundleNode);
-        candidates.add(otherBundleNode);
-      }
-    }
-  }
-
-  return getMergeClusters(graph, candidates);
-}