BREAKING CHANGE(smartwatch): Introduce Smartwatch: cross-runtime native file watching for Node.js, Deno and Bun; rename smartchok to smartwatch and bump major version to 2.0.0

ts/utils/write-stabilizer.ts

@@ -0,0 +1,97 @@
+import * as fs from 'fs';
+
+interface IPendingWrite {
+  lastSize: number;
+  lastChange: number;
+  timeoutId: ReturnType<typeof setTimeout>;
+  resolve: (stats: fs.Stats) => void;
+  reject: (error: Error) => void;
+}
+
+/**
+ * Implements awaitWriteFinish functionality by polling file size until stable.
+ * This replaces chokidar's built-in write stabilization.
+ */
+export class WriteStabilizer {
+  private pendingWrites = new Map<string, IPendingWrite>();
+
+  constructor(
+    private stabilityThreshold: number = 300,
+    private pollInterval: number = 100
+  ) {}
+
+  /**
+   * Wait for a file write to complete by polling until size is stable
+   */
+  async waitForWriteFinish(filePath: string): Promise<fs.Stats> {
+    // Cancel any existing pending check for this file
+    this.cancel(filePath);
+
+    return new Promise((resolve, reject) => {
+      const poll = async () => {
+        try {
+          const stats = await fs.promises.stat(filePath);
+          const pending = this.pendingWrites.get(filePath);
+
+          if (!pending) {
+            // Was cancelled
+            return;
+          }
+
+          const now = Date.now();
+
+          if (stats.size !== pending.lastSize) {
+            // Size changed - file is still being written, reset timer
+            pending.lastSize = stats.size;
+            pending.lastChange = now;
+            pending.timeoutId = setTimeout(poll, this.pollInterval);
+          } else if (now - pending.lastChange >= this.stabilityThreshold) {
+            // Size has been stable for the threshold duration
+            this.pendingWrites.delete(filePath);
+            resolve(stats);
+          } else {
+            // Size is the same but not yet past threshold
+            pending.timeoutId = setTimeout(poll, this.pollInterval);
+          }
+        } catch (error: any) {
+          this.pendingWrites.delete(filePath);
+          if (error.code === 'ENOENT') {
+            // File was deleted during polling
+            reject(new Error(`File was deleted: ${filePath}`));
+          } else {
+            reject(error);
+          }
+        }
+      };
+
+      this.pendingWrites.set(filePath, {
+        lastSize: -1,
+        lastChange: Date.now(),
+        timeoutId: setTimeout(poll, this.pollInterval),
+        resolve,
+        reject
+      });
+    });
+  }
+
+  /**
+   * Cancel any pending write stabilization for a file
+   */
+  cancel(filePath: string): void {
+    const pending = this.pendingWrites.get(filePath);
+    if (pending) {
+      clearTimeout(pending.timeoutId);
+      this.pendingWrites.delete(filePath);
+    }
+  }
+
+  /**
+   * Cancel all pending write stabilizations
+   */
+  cancelAll(): void {
+    for (const [filePath, pending] of this.pendingWrites) {
+      clearTimeout(pending.timeoutId);
+    }
+    this.pendingWrites.clear();
+  }
+}