fix(@angular/build): deduplicate spurious chokidar polling change events (#34188)

When using Chokidar in polling mode, non-atomic file writes (such as open with O_TRUNC followed by write) can span across poll intervals and cause Chokidar to emit two 'change' events for a single file modification. If the initial rebuild completes quickly (e.g. in JIT mode), the trailing poll event can flush a second rebuild batch with the same file state.

Track the last known mtimeMs and size of watched files in createChokidarWatcher and ignore 'modified' events when the file's mtimeMs and size have not changed since the previous queued or flushed event.

PR Close #34188

Author: alan-agius4

packages/angular/build/src/utils/watcher.ts

@@ -754,6 +754,7 @@ async function createChokidarWatcher(
 ): Promise<BuildWatcher> {
   const chokidar = chokidarModule ?? (await import('chokidar'));
   const watchedFiles = new Set<string>();
+  const fileStats = new Map<string, { mtimeMs: number; size: number }>();
 
   let queue: WatcherQueue;
   if (options?.polling) {
@@ -813,16 +814,36 @@ async function createChokidarWatcher(
       return;
     }
 
-    if (type !== 'removed') {
-      const stat = fs.statSync(rawPath, { throwIfNoEntry: false });
-      // Ignore historical events from before watcher initialization, but allow a 1000 ms window
-      // to account for coarse filesystem timestamp resolution (e.g., ext4/overlayfs integer second
-      // mtime truncation on Linux) where files modified during startup may have truncated .000 ms mtimes.
-      if (stat && stat.mtimeMs < initTime - 1000) {
-        return;
-      }
+    if (type === 'removed') {
+      fileStats.delete(lookupKey);
+      queue.addChange(type, rawPath);
+
+      return;
+    }
+
+    const stat = fs.statSync(rawPath, { throwIfNoEntry: false });
+    if (!stat) {
+      return;
     }
 
+    // Ignore historical events from before watcher initialization, but allow a 1000 ms window
+    // to account for coarse filesystem timestamp resolution (e.g., ext4/overlayfs integer second
+    // mtime truncation on Linux) where files modified during startup may have truncated .000 ms mtimes.
+    if (stat.mtimeMs < initTime - 1000) {
+      return;
+    }
+
+    const previousStat = fileStats.get(lookupKey);
+    if (
+      type === 'modified' &&
+      previousStat &&
+      previousStat.mtimeMs === stat.mtimeMs &&
+      previousStat.size === stat.size
+    ) {
+      return;
+    }
+
+    fileStats.set(lookupKey, { mtimeMs: stat.mtimeMs, size: stat.size });
     queue.addChange(type, rawPath);
   };
 
@@ -835,8 +856,23 @@ async function createChokidarWatcher(
       return this;
     },
 
-    next() {
-      return queue.next();
+    async next() {
+      const result = await queue.next();
+      if (result.value) {
+        const files = [...result.value.added, ...result.value.modified];
+        await Promise.all(
+          files.map(async (file) => {
+            const stat = await fs.promises.stat(file).catch(() => undefined);
+            if (stat?.isFile()) {
+              const posixPath = toPosixPathNormalized(file);
+              const lookupKey = toLookupKey(posixPath, isCaseSensitive);
+              fileStats.set(lookupKey, { mtimeMs: stat.mtimeMs, size: stat.size });
+            }
+          }),
+        );
+      }
+
+      return result;
     },
 
     add(paths) {
@@ -875,6 +911,7 @@ async function createChokidarWatcher(
         const lookupKey = toLookupKey(posixPath, isCaseSensitive);
         if (watchedFiles.has(lookupKey)) {
           watchedFiles.delete(lookupKey);
+          fileStats.delete(lookupKey);
 
           // When the last watched file in a package is removed, unwatch the package directory.
           const { isPackage, unwatchPkgDir } = nodeModulesManager.removePackageFile(