fixup! fix(@angular/build): improve library bundler resolution and watch shared chunk consistency

Author: alan-agius4

packages/angular/build/src/builders/library/pipeline/bundler.ts

@@ -82,30 +82,181 @@ interface MultiBundleOutput {
 }
 
 /**
- * Checks whether an entry point's previous output files included shared (non-entry) chunks.
+ * Checks whether two sets share at least one common element.
  */
-function hasSharedChunks(
-  outputFiles: ReadonlySet<string> | undefined,
-  dir: string,
-  bundleName: string,
-  extension: 'mjs' | 'd.ts',
-): boolean {
-  if (!outputFiles || outputFiles.size === 0) {
-    return false;
+function hasSetIntersection(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {
+  if (a.size > b.size) {
+    return hasSetIntersection(b, a);
+  }
+
+  for (const item of a) {
+    if (b.has(item)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Expands the selected entry points to include any available entry points whose module IDs
+ * transitively overlap with the selected set.
+ */
+function expandOverlappingEntryPoints(
+  selectedEntryPoints: readonly NormalizedEntryPoint[],
+  allEntryPoints: readonly NormalizedEntryPoint[],
+  isAvailable: (ep: NormalizedEntryPoint) => boolean,
+  getModuleIds: (ep: NormalizedEntryPoint) => ReadonlySet<string> | undefined,
+): readonly NormalizedEntryPoint[] {
+  if (selectedEntryPoints.length >= allEntryPoints.length) {
+    return selectedEntryPoints;
+  }
+
+  let trackedModuleIds: ReadonlySet<string> | undefined;
+  let mutableTrackedIds: Set<string> | undefined;
+
+  if (selectedEntryPoints.length === 1) {
+    trackedModuleIds = getModuleIds(selectedEntryPoints[0]);
+  } else {
+    mutableTrackedIds = new Set<string>();
+    for (const ep of selectedEntryPoints) {
+      const ids = getModuleIds(ep);
+      if (ids) {
+        for (const id of ids) {
+          mutableTrackedIds.add(id);
+        }
+      }
+    }
+    trackedModuleIds = mutableTrackedIds;
+  }
+
+  if (!trackedModuleIds || trackedModuleIds.size === 0) {
+    return selectedEntryPoints;
   }
 
-  const entryFile = `${dir}/${bundleName}.${extension}`;
-  const entryMapFile = `${entryFile}.map`;
+  let selectedNames: Set<string> | undefined;
+  const singleSelectedName =
+    selectedEntryPoints.length === 1 ? selectedEntryPoints[0].name : undefined;
+
+  let added = true;
+  while (added) {
+    added = false;
+    for (const ep of allEntryPoints) {
+      if (singleSelectedName !== undefined && !selectedNames) {
+        if (ep.name === singleSelectedName) {
+          continue;
+        }
+      } else {
+        selectedNames ??= new Set(selectedEntryPoints.map((item) => item.name));
+        if (selectedNames.has(ep.name)) {
+          continue;
+        }
+      }
 
-  for (const file of outputFiles) {
-    if (file !== entryFile && file !== entryMapFile) {
+      const ids = getModuleIds(ep);
+      if (ids && hasSetIntersection(ids, trackedModuleIds) && isAvailable(ep)) {
+        selectedNames ??= new Set(selectedEntryPoints.map((item) => item.name));
+        selectedNames.add(ep.name);
+        mutableTrackedIds ??= new Set(trackedModuleIds);
+        trackedModuleIds = mutableTrackedIds;
+        for (const id of ids) {
+          mutableTrackedIds.add(id);
+        }
+        added = true;
+      }
+    }
+  }
+
+  return selectedNames && selectedNames.size > selectedEntryPoints.length
+    ? allEntryPoints.filter((ep) => selectedNames.has(ep.name))
+    : selectedEntryPoints;
+}
+
+/**
+ * Checks whether any bundled entry point acquired a module ID that was not present in its
+ * previous bundle result.
+ */
+function hasNewlyAddedModules(
+  bundledEntryPoints: readonly NormalizedEntryPoint[],
+  output: MultiBundleOutput,
+  getPreviousModuleIds: (ep: NormalizedEntryPoint) => ReadonlySet<string> | undefined,
+): boolean {
+  for (const ep of bundledEntryPoints) {
+    const newIds = output.bundles.get(ep.bundleName)?.moduleIds;
+    if (!newIds || newIds.size === 0) {
+      continue;
+    }
+
+    const prevIds = getPreviousModuleIds(ep);
+    if (!prevIds) {
       return true;
     }
+
+    for (const id of newIds) {
+      if (!prevIds.has(id)) {
+        return true;
+      }
+    }
   }
 
   return false;
 }
 
+/**
+ * Bundles dirty entry points for a single mode (ESM or DTS), automatically expanding the entry
+ * point set before or after bundling when module IDs overlap across entry points.
+ */
+async function bundleModeWithSharedModules(
+  dirtyEntryPoints: readonly NormalizedEntryPoint[],
+  allEntryPoints: readonly NormalizedEntryPoint[],
+  files: ReadonlyMap<string, string>,
+  dtsMode: boolean,
+  getPreviousModuleIds: (ep: NormalizedEntryPoint) => ReadonlySet<string> | undefined,
+  bundleFn: (
+    entryPoints: readonly NormalizedEntryPoint[],
+    files: ReadonlyMap<string, string>,
+    options: NormalizedLibraryOptions,
+  ) => Promise<MultiBundleOutput>,
+  options: NormalizedLibraryOptions,
+): Promise<MultiBundleOutput> {
+  if (dirtyEntryPoints.length === 0) {
+    return { filesToEmit: [], bundles: new Map(), warnings: [] };
+  }
+
+  if (dirtyEntryPoints.length >= allEntryPoints.length) {
+    return bundleFn(dirtyEntryPoints, files, options);
+  }
+
+  const isAvailable = (ep: NormalizedEntryPoint): boolean =>
+    files.has(resolveEntryInputPath(ep.entryFilePath, dtsMode));
+
+  const initialEntryPoints = expandOverlappingEntryPoints(
+    dirtyEntryPoints,
+    allEntryPoints,
+    isAvailable,
+    getPreviousModuleIds,
+  );
+  const output = await bundleFn(initialEntryPoints, files, options);
+
+  if (
+    initialEntryPoints.length < allEntryPoints.length &&
+    hasNewlyAddedModules(initialEntryPoints, output, getPreviousModuleIds)
+  ) {
+    const expandedEntryPoints = expandOverlappingEntryPoints(
+      initialEntryPoints,
+      allEntryPoints,
+      isAvailable,
+      (ep) => output.bundles.get(ep.bundleName)?.moduleIds ?? getPreviousModuleIds(ep),
+    );
+
+    if (expandedEntryPoints.length > initialEntryPoints.length) {
+      return bundleFn(expandedEntryPoints, files, options);
+    }
+  }
+
+  return output;
+}
+
 /**
  * Collects all normalized entry points from options and bundle input items.
  */
@@ -128,7 +279,7 @@ function getAllEntryPoints(
 
 /**
  * Bundles the compiled in-memory JavaScript and declaration files for all dirty entry points
- * using at most 2 Rolldown instances total (1 for all .mjs bundles, 1 for all .d.ts bundles).
+ * using at most 2 Rolldown instances per pass (1 for all .mjs bundles, 1 for all .d.ts bundles).
  *
  * @param items The collection of entry point inputs with change statuses.
  * @param esmFiles Map of virtual POSIX ESM output file paths to their content.
@@ -151,16 +302,15 @@ export async function bundleEntryPoints(
 
   const allEntryPoints = getAllEntryPoints(items, options);
   const itemsByName = new Map(items.map((item) => [item.entryPoint.name, item]));
+  const getPreviousResult = (name: string): BundleResult | undefined =>
+    itemsByName.get(name)?.previousBundleResult ?? previousBundleResults?.get(name);
 
-  let esmEntryPoints: NormalizedEntryPoint[] = [];
-  let dtsEntryPoints: NormalizedEntryPoint[] = [];
-  let hasSharedEsmChunks = false;
-  let hasSharedDtsChunks = false;
+  const esmEntryPoints: NormalizedEntryPoint[] = [];
+  const dtsEntryPoints: NormalizedEntryPoint[] = [];
 
   for (const item of items) {
     const { entryPoint } = item;
-    const previousBundleResult =
-      item.previousBundleResult ?? previousBundleResults?.get(entryPoint.name);
+    const previousBundleResult = getPreviousResult(entryPoint.name);
     if (item.hasEsmChanges || !previousBundleResult) {
       esmEntryPoints.push(entryPoint);
     }
@@ -169,50 +319,25 @@ export async function bundleEntryPoints(
     }
   }
 
-  for (const entryPoint of allEntryPoints) {
-    const previousBundleResult =
-      itemsByName.get(entryPoint.name)?.previousBundleResult ??
-      previousBundleResults?.get(entryPoint.name);
-    if (!previousBundleResult) {
-      continue;
-    }
-
-    hasSharedEsmChunks ||= hasSharedChunks(
-      previousBundleResult.esmOutputFiles,
-      FESM_OUTPUT_DIR,
-      entryPoint.bundleName,
-      'mjs',
-    );
-    hasSharedDtsChunks ||= hasSharedChunks(
-      previousBundleResult.dtsOutputFiles,
-      TYPES_OUTPUT_DIR,
-      entryPoint.bundleName,
-      'd.ts',
-    );
-  }
-
-  if (
-    esmEntryPoints.length > 0 &&
-    hasSharedEsmChunks &&
-    esmEntryPoints.length < allEntryPoints.length
-  ) {
-    esmEntryPoints = allEntryPoints.filter((ep) =>
-      esmFiles.has(ep.entryFilePath.replace(/\.(m?)ts$/, '.$1js')),
-    );
-  }
-  if (
-    dtsEntryPoints.length > 0 &&
-    hasSharedDtsChunks &&
-    dtsEntryPoints.length < allEntryPoints.length
-  ) {
-    dtsEntryPoints = allEntryPoints.filter((ep) =>
-      dtsFiles.has(ep.entryFilePath.replace(/\.(m?ts)$/, '.d.$1')),
-    );
-  }
-
   const [esmOutput, dtsOutput] = await Promise.all([
-    bundleAllEsm(esmEntryPoints, esmFiles, options),
-    bundleAllDts(dtsEntryPoints, dtsFiles, options),
+    bundleModeWithSharedModules(
+      esmEntryPoints,
+      allEntryPoints,
+      esmFiles,
+      false,
+      (ep) => getPreviousResult(ep.name)?.esmModuleIds,
+      bundleAllEsm,
+      options,
+    ),
+    bundleModeWithSharedModules(
+      dtsEntryPoints,
+      allEntryPoints,
+      dtsFiles,
+      true,
+      (ep) => getPreviousResult(ep.name)?.dtsModuleIds,
+      bundleAllDts,
+      options,
+    ),
   ]);
 
   for (const entryPoint of allEntryPoints) {
@@ -223,8 +348,7 @@ export async function bundleEntryPoints(
       continue;
     }
 
-    const previousBundleResult =
-      item?.previousBundleResult ?? previousBundleResults?.get(entryPoint.name);
+    const previousBundleResult = getPreviousResult(entryPoint.name);
     bundleResults.set(entryPoint.name, {
       esmModuleIds: esmBundle?.moduleIds ?? previousBundleResult?.esmModuleIds ?? new Set(),
       dtsModuleIds: dtsBundle?.moduleIds ?? previousBundleResult?.dtsModuleIds ?? new Set(),
@@ -241,6 +365,15 @@ export async function bundleEntryPoints(
   };
 }
 
+/**
+ * Resolves the compiled in-memory entry file path for a TypeScript entry point.
+ */
+function resolveEntryInputPath(entryFilePath: string, dtsMode: boolean): string {
+  return dtsMode
+    ? entryFilePath.replace(/\.(m?ts)$/, '.d.$1')
+    : entryFilePath.replace(/\.(m?)ts$/, '.$1js');
+}
+
 /**
  * Generates the Rolldown input mapping object from the specified entry points.
  *
@@ -254,9 +387,7 @@ function resolveEntryInputMap(
 ): Record<string, string> {
   const input: Record<string, string> = {};
   for (const { bundleName, entryFilePath } of entryPoints) {
-    input[bundleName] = dtsMode
-      ? entryFilePath.replace(/\.(m?ts)$/, '.d.$1')
-      : entryFilePath.replace(/\.(m?)ts$/, '.$1js');
+    input[bundleName] = resolveEntryInputPath(entryFilePath, dtsMode);
   }
 
   return input;