fix(@angular/build): preserve asset precedence and expand glob-prefixed ignores in watch mode

Previously in library watch mode, ignore patterns containing glob characters that did not
end with `*` (such as `**/<dir>` or `{a,b}`) were not expanded with `/**` because
`normalizeGlobPattern` checked `picomatch.scan(result).isGlob`. Update
`normalizeGlobPattern` to append `/**` whenever the stripped pattern does not end with
`*`, matching `tinyglobby` directory expansion semantics.

In `collectAssetsToEmit`, incremental watch builds previously only deduplicated colliding
output paths among files present in the current `modifiedFiles` set. Modifying a
lower-priority asset could therefore overwrite an existing higher-priority asset on disk,
and deleting a higher-priority asset did not restore an existing lower-priority fallback
asset. Resolve candidate sources across all asset matchers, evict overridden asset
sources in `BuilderState.recordEmittedOutputs`, and re-emit lower-priority fallback
assets when an overriding asset is deleted. Also preserve cached `statSync` results
during deleted-directory checks so a newly created file replacing a directory at the same
path is still matched and emitted.

Author: clydin

packages/angular/build/src/builders/library/builder-state.ts

@@ -416,6 +416,16 @@ export class BuilderState {
     const { filesToDelete: toDelete, filesToEmit: toEmit } = collectedAssets;
 
     for (const emittedAsset of toEmit) {
+      for (const [source, outputs] of this.#emittedAssets) {
+        if (
+          source !== emittedAsset.source &&
+          outputs.delete(emittedAsset.path) &&
+          outputs.size === 0
+        ) {
+          this.#emittedAssets.delete(source);
+        }
+      }
+
       let outputs = this.#emittedAssets.get(emittedAsset.source);
       if (!outputs) {
         outputs = new Set();
@@ -424,26 +434,13 @@ export class BuilderState {
       outputs.add(emittedAsset.path);
     }
 
-    if (toDelete.length) {
-      const candidateDeletes = new Set<string>();
-      for (const source of toDelete) {
-        const outputs = this.#emittedAssets.get(source);
-        if (outputs) {
-          for (const output of outputs) {
-            candidateDeletes.add(output);
-          }
-          this.#emittedAssets.delete(source);
-        }
-      }
-
-      for (const outputs of this.#emittedAssets.values()) {
+    for (const source of toDelete) {
+      const outputs = this.#emittedAssets.get(source);
+      if (outputs) {
         for (const output of outputs) {
-          candidateDeletes.delete(output);
+          filesToDelete.add(output);
         }
-      }
-
-      for (const output of candidateDeletes) {
-        filesToDelete.add(output);
+        this.#emittedAssets.delete(source);
       }
     }
 

packages/angular/build/src/builders/library/builder-state_spec.ts

@@ -261,24 +261,43 @@ describe('BuilderState', () => {
       );
     });
 
-    it('should not delete an asset output path when another source still emits to it', () => {
+    it('should evict overridden asset sources and not delete an output path when a fallback source is re-emitted', async () => {
       const state = new BuilderState();
 
       const sourceA = '/workspace/projects/my-lib/README.md';
       const sourceB = '/workspace/docs/README.md';
 
+      // Initial build emits sourceA
       state.recordEmittedOutputs({
-        filesToEmit: [
-          createDiskOutputFile(sourceA, 'README.md'),
-          createDiskOutputFile(sourceB, 'README.md'),
-        ],
+        filesToEmit: [createDiskOutputFile(sourceA, 'README.md')],
+        filesToDelete: [],
+      });
+
+      // Subsequent watch iteration overrides 'README.md' with sourceB, evicting sourceA
+      state.resetExecutionResult();
+      state.recordEmittedOutputs({
+        filesToEmit: [createDiskOutputFile(sourceB, 'README.md')],
         filesToDelete: [],
       });
 
-      // Delete sourceB while sourceA remains active
+      // Deleting the now-shadowed sourceA is a no-op
+      const shadowedCollected = await state.collectAssets(
+        {
+          workspaceRoot: '/workspace',
+          assets: [
+            { glob: 'README.md', input: '/workspace/projects/my-lib', output: '.' },
+            { glob: 'README.md', input: '/workspace/docs', output: '.' },
+          ],
+        },
+        new Set([sourceA]),
+      );
+      expect(shadowedCollected.filesToEmit).toEqual([]);
+      expect(shadowedCollected.filesToDelete).toEqual([]);
+
+      // Delete sourceB while fallback sourceA is re-emitted
       state.resetExecutionResult();
       const firstDeletes = state.recordEmittedOutputs({
-        filesToEmit: [],
+        filesToEmit: [createDiskOutputFile(sourceA, 'README.md')],
         filesToDelete: [sourceB],
       });
       expect(firstDeletes.has('README.md')).toBeFalse();

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

@@ -47,13 +47,38 @@ export interface AssetMatcher {
  */
 function normalizeGlobPattern(pattern: string): string {
   let result = pattern.endsWith('/') ? pattern.slice(0, -1) : pattern;
-  if (pattern.endsWith('/') || !picomatch.scan(result).isGlob) {
+  if (pattern.endsWith('/') || !result.endsWith('*')) {
     result += '/**';
   }
 
   return path.posix.normalize(result);
 }
 
+/**
+ * Resolves the candidate POSIX source file path within `matcher` that would map to `outputPath`,
+ * or `undefined` if `outputPath` is outside `matcher.asset.output` or does not match `matcher`.
+ */
+function getCandidateSourceForOutput(
+  matcher: AssetMatcher,
+  outputPath: string,
+): string | undefined {
+  const relative = path.posix.relative(matcher.asset.output, outputPath);
+  if (!relative || relative.startsWith('..') || path.posix.isAbsolute(relative)) {
+    return undefined;
+  }
+
+  return matcher.isMatch(relative) ? `${matcher.prefix}${relative}` : undefined;
+}
+
+/**
+ * Checks whether a POSIX path exists on disk as a file, respecting `followSymlinks`.
+ */
+function isMatchingAssetFile(file: string, followSymlinks: boolean | undefined): boolean {
+  return followSymlinks
+    ? (statSync(file, { throwIfNoEntry: false })?.isFile() ?? false)
+    : (lstatSync(file, { throwIfNoEntry: false })?.isFile() ?? false);
+}
+
 /**
  * Compiles picomatch matchers and POSIX input prefixes for each asset configuration.
  *
@@ -62,15 +87,16 @@ function normalizeGlobPattern(pattern: string): string {
  */
 export function createAssetMatchers(assets: NormalizedAssetsPattern[]): readonly AssetMatcher[] {
   return assets.map((asset) => {
-    const ignore = [...DEFAULT_ASSET_IGNORE, ...(asset.ignore ?? [])]
+    const { glob: rawGlob, ignore: rawIgnore, input } = asset;
+    const ignore = [...DEFAULT_ASSET_IGNORE, ...(rawIgnore ?? [])]
       .filter((pattern) => pattern.length > 0)
       .map(normalizeGlobPattern);
-    const isMatch = picomatch(asset.glob ? path.posix.normalize(asset.glob) : [], {
+    const isMatch = picomatch(rawGlob ? path.posix.normalize(rawGlob) : [], {
       dot: true,
       windows: false,
       ignore,
     });
-    const prefix = asset.input.endsWith('/') ? asset.input : `${asset.input}/`;
+    const prefix = input.endsWith('/') ? input : `${input}/`;
 
     return { asset, prefix, isMatch };
   });
@@ -89,7 +115,7 @@ export function createAssetMatchers(assets: NormalizedAssetsPattern[]): readonly
 export async function collectAssetsToEmit(
   assets: NormalizedAssetsPattern[],
   workspaceRoot: string,
-  emittedAssets: ReadonlyMap<string, unknown>,
+  emittedAssets: ReadonlyMap<string, ReadonlySet<string>>,
   modifiedFiles?: ReadonlySet<string>,
   assetMatchers?: readonly AssetMatcher[],
 ): Promise<CollectedAssets> {
@@ -108,16 +134,21 @@ export async function collectAssetsToEmit(
 
       if (!emittedAssets.has(file) && emittedAssets.size > 0) {
         const dirPrefix = file.endsWith('/') ? file : `${file}/`;
-        let isDeletedDir: boolean | undefined;
+        let isDirectory: boolean | undefined;
         for (const emittedFile of emittedAssets.keys()) {
           if (emittedFile.startsWith(dirPrefix)) {
-            if (!(isDeletedDir ??= !statSync(file, { throwIfNoEntry: false })?.isDirectory())) {
-              break;
+            if (isDirectory === undefined) {
+              const stats = statSync(file, { throwIfNoEntry: false });
+              isDirectory = stats?.isDirectory() ?? false;
+              isFileStat = stats?.isFile() ?? false;
+              if (isDirectory) {
+                break;
+              }
             }
             filesToDelete.add(emittedFile);
           }
         }
-        if (isDeletedDir !== undefined) {
+        if (isDirectory !== undefined && !isFileStat) {
           continue;
         }
       }
@@ -154,6 +185,84 @@ export async function collectAssetsToEmit(
       }
     }
 
+    if (matchers.length > 1) {
+      // Ensure lower-priority modified assets do not overwrite existing higher-priority assets on disk.
+      for (const [outputPath, { file, matcherIndex }] of filesToEmit) {
+        for (let laterIndex = matchers.length - 1; laterIndex > matcherIndex; laterIndex--) {
+          const laterMatcher = matchers[laterIndex];
+          const candidateFile = getCandidateSourceForOutput(laterMatcher, outputPath);
+          if (!candidateFile || candidateFile === file.source) {
+            continue;
+          }
+
+          if (isMatchingAssetFile(candidateFile, laterMatcher.asset.followSymlinks)) {
+            if (emittedAssets.get(candidateFile)?.has(outputPath)) {
+              filesToEmit.delete(outputPath);
+            } else {
+              filesToEmit.set(outputPath, {
+                file: createDiskOutputFile(candidateFile, outputPath),
+                matcherIndex: laterIndex,
+              });
+            }
+            break;
+          } else if (emittedAssets.get(candidateFile)?.has(outputPath)) {
+            filesToDelete.add(candidateFile);
+          }
+        }
+      }
+
+      // Restore lower-priority fallback assets when a higher-priority overriding asset is deleted.
+      for (const deletedFile of filesToDelete) {
+        for (
+          let deletedMatcherIndex = 0;
+          deletedMatcherIndex < matchers.length;
+          deletedMatcherIndex++
+        ) {
+          const { asset, prefix, isMatch } = matchers[deletedMatcherIndex];
+          if (!deletedFile.startsWith(prefix)) {
+            continue;
+          }
+
+          const relative = deletedFile.slice(prefix.length);
+          if (!isMatch(relative)) {
+            continue;
+          }
+
+          const outputPath = path.posix.join(asset.output, relative);
+          if (filesToEmit.has(outputPath)) {
+            continue;
+          }
+
+          for (let candidateIndex = matchers.length - 1; candidateIndex >= 0; candidateIndex--) {
+            if (candidateIndex === deletedMatcherIndex) {
+              continue;
+            }
+
+            const candidateMatcher = matchers[candidateIndex];
+            const candidateFile = getCandidateSourceForOutput(candidateMatcher, outputPath);
+            if (!candidateFile || filesToDelete.has(candidateFile)) {
+              continue;
+            }
+
+            if (isMatchingAssetFile(candidateFile, candidateMatcher.asset.followSymlinks)) {
+              if (
+                candidateIndex < deletedMatcherIndex ||
+                !emittedAssets.get(candidateFile)?.has(outputPath)
+              ) {
+                filesToEmit.set(outputPath, {
+                  file: createDiskOutputFile(candidateFile, outputPath),
+                  matcherIndex: candidateIndex,
+                });
+              }
+              break;
+            } else if (emittedAssets.get(candidateFile)?.has(outputPath)) {
+              filesToDelete.add(candidateFile);
+            }
+          }
+        }
+      }
+    }
+
     return {
       filesToEmit: Array.from(filesToEmit.values(), ({ file }) => file),
       filesToDelete: Array.from(filesToDelete),