Remove watchFile from promises API as requested

Copilot · streamich · Copilot · commit 26820ce6661a · 2025-07-27T19:16:46.000Z
Co-authored-by: streamich &lt;9773803+streamich@users.noreply.github.com&gt;
diff --git a/src/__tests__/promises.test.ts b/src/__tests__/promises.test.ts
@@ -771,13 +771,13 @@ describe('Promises API', () => {
       vol.fromJSON({
         '/foo': 'bar',
       });
-      
+
       const watcher = promises.watch('/foo');
       expect(typeof watcher[Symbol.asyncIterator]).toBe('function');
       expect(typeof watcher.next).toBe('function');
       expect(typeof watcher.return).toBe('function');
       expect(typeof watcher.throw).toBe('function');
-      
+
       // Clean up
       if (watcher.return) {
         await watcher.return();
@@ -790,10 +790,10 @@ describe('Promises API', () => {
       vol.fromJSON({
         '/foo': 'bar',
       });
-      
+
       const watcher = promises.watch('/foo');
       const events: Array<{ eventType: string; filename: string | Buffer }> = [];
-      
+
       // Start watching
       const watchPromise = (async () => {
         const iterator = watcher[Symbol.asyncIterator]();
@@ -805,15 +805,15 @@ describe('Promises API', () => {
           await iterator.return();
         }
       })();
-      
+
       // Give watcher time to start
       await new Promise(resolve => setTimeout(resolve, 10));
-      
+
       // Modify the file
       vol.writeFileSync('/foo', 'baz');
-      
+
       await watchPromise;
-      
+
       expect(events).toHaveLength(1);
       expect(events[0].eventType).toBe('change');
       expect(events[0].filename).toBe('foo');
@@ -825,13 +825,13 @@ describe('Promises API', () => {
       vol.fromJSON({
         '/foo': 'bar',
       });
-      
+
       const abortController = new AbortController();
       const watcher = promises.watch('/foo', { signal: abortController.signal });
-      
+
       // Abort immediately
       abortController.abort();
-      
+
       const iterator = watcher[Symbol.asyncIterator]();
       const result = await iterator.next();
       expect(result.done).toBe(true);
@@ -843,18 +843,18 @@ describe('Promises API', () => {
       vol.fromJSON({
         '/foo': 'bar',
       });
-      
+
       const watcher = promises.watch('/foo', { maxQueue: 1, overflow: 'ignore' });
-      
+
       // Generate multiple events quickly
       vol.writeFileSync('/foo', 'change1');
       vol.writeFileSync('/foo', 'change2');
       vol.writeFileSync('/foo', 'change3');
-      
+
       const iterator = watcher[Symbol.asyncIterator]();
       const result1 = await iterator.next();
       expect(result1.done).toBe(false);
-      
+
       if (iterator.return) {
         await iterator.return();
       }
@@ -866,103 +866,14 @@ describe('Promises API', () => {
       vol.fromJSON({
         '/foo': 'bar',
       });
-      
+
       const watcher = promises.watch('/foo', { maxQueue: 1, overflow: 'throw' });
-      
+
       // This test is tricky because we need to ensure the overflow happens
       // We can't easily test this synchronously, so we'll skip for now
       if (watcher.return) {
         await watcher.return();
       }
     });
   });
-
-  describe('watchFile(filename[, options])', () => {
-    it('Returns an AsyncIterableIterator', async () => {
-      const vol = new Volume();
-      const { promises } = vol;
-      vol.fromJSON({
-        '/foo': 'bar',
-      });
-      
-      const watcher = promises.watchFile('/foo');
-      expect(typeof watcher[Symbol.asyncIterator]).toBe('function');
-      expect(typeof watcher.next).toBe('function');
-      expect(typeof watcher.return).toBe('function');
-      expect(typeof watcher.throw).toBe('function');
-      
-      // Clean up
-      if (watcher.return) {
-        await watcher.return();
-      }
-    });
-
-    it('Emits stat change events when file is modified', async () => {
-      const vol = new Volume();
-      const { promises } = vol;
-      vol.fromJSON({
-        '/foo': 'bar',
-      });
-      
-      const watcher = promises.watchFile('/foo', { interval: 1 });
-      const events: Array<{ curr: any; prev: any }> = [];
-      
-      // Start watching
-      const watchPromise = (async () => {
-        const iterator = watcher[Symbol.asyncIterator]();
-        const result = await iterator.next();
-        if (!result.done) {
-          events.push(result.value);
-        }
-        if (iterator.return) {
-          await iterator.return();
-        }
-      })();
-      
-      // Give watcher time to start
-      await new Promise(resolve => setTimeout(resolve, 10));
-      
-      // Modify the file
-      vol.writeFileSync('/foo', 'modified content');
-      
-      await watchPromise;
-      
-      expect(events).toHaveLength(1);
-      expect(events[0].curr).toBeDefined();
-      expect(events[0].prev).toBeDefined();
-      expect(events[0].curr.isFile()).toBe(true);
-      expect(events[0].prev.isFile()).toBe(true);
-    });
-
-    it('Works with for-await loops', async () => {
-      const vol = new Volume();
-      const { promises } = vol;
-      vol.fromJSON({
-        '/test.txt': 'initial',
-      });
-      
-      const watcher = promises.watch('/test.txt');
-      const events: Array<{ eventType: string; filename: string | Buffer }> = [];
-      
-      // Start the for-await loop
-      const watchPromise = (async () => {
-        for await (const event of watcher) {
-          events.push(event);
-          if (events.length >= 2) {
-            break;
-          }
-        }
-      })();
-      
-      // Generate events
-      setTimeout(() => vol.writeFileSync('/test.txt', 'change1'), 10);
-      setTimeout(() => vol.writeFileSync('/test.txt', 'change2'), 15);
-      
-      await watchPromise;
-      
-      expect(events).toHaveLength(2);
-      expect(events[0].eventType).toBe('change');
-      expect(events[1].eventType).toBe('change');
-    });
-  });
 });
diff --git a/src/node/FsPromises.ts b/src/node/FsPromises.ts
@@ -17,7 +17,7 @@ class FSWatchAsyncIterator implements AsyncIterableIterator<{ eventType: string;
   constructor(
     private fs: any,
     private path: misc.PathLike,
-    private options: opts.IWatchOptions = {}
+    private options: opts.IWatchOptions = {},
   ) {
     this.maxQueue = options.maxQueue || 2048;
     this.overflow = options.overflow || 'ignore';
@@ -64,7 +64,7 @@ class FSWatchAsyncIterator implements AsyncIterableIterator<{ eventType: string;
     }
 
     this.eventQueue.push(event);
-    
+
     // If there's a waiting promise, resolve it
     if (this.resolveQueue.length > 0) {
       const { resolve } = this.resolveQueue.shift()!;
@@ -125,97 +125,6 @@ class FSWatchAsyncIterator implements AsyncIterableIterator<{ eventType: string;
   }
 }
 
-// AsyncIterator implementation for promises.watchFile
-class StatWatchAsyncIterator implements AsyncIterableIterator<{ curr: misc.IStats; prev: misc.IStats }> {
-  private watcher: any;
-  private eventQueue: Array<{ curr: misc.IStats; prev: misc.IStats }> = [];
-  private resolveQueue: Array<{ resolve: Function; reject: Function }> = [];
-  private finished = false;
-
-  constructor(
-    private fs: any,
-    private path: misc.PathLike,
-    private options: opts.IWatchFileOptions = {}
-  ) {
-    this.startWatching();
-  }
-
-  private startWatching() {
-    try {
-      this.watcher = this.fs.watchFile(this.path, this.options, (curr: misc.IStats, prev: misc.IStats) => {
-        this.enqueueEvent({ curr, prev });
-      });
-    } catch (error) {
-      this.finish();
-      throw error;
-    }
-  }
-
-  private enqueueEvent(event: { curr: misc.IStats; prev: misc.IStats }) {
-    if (this.finished) return;
-
-    this.eventQueue.push(event);
-    
-    // If there's a waiting promise, resolve it
-    if (this.resolveQueue.length > 0) {
-      const { resolve } = this.resolveQueue.shift()!;
-      const nextEvent = this.eventQueue.shift()!;
-      resolve({ value: nextEvent, done: false });
-    }
-  }
-
-  private finish(error?: Error) {
-    if (this.finished) return;
-    this.finished = true;
-
-    if (this.watcher) {
-      this.fs.unwatchFile(this.path);
-      this.watcher = null;
-    }
-
-    // Resolve or reject all pending promises
-    while (this.resolveQueue.length > 0) {
-      const { resolve, reject } = this.resolveQueue.shift()!;
-      if (error) {
-        reject(error);
-      } else {
-        resolve({ value: undefined, done: true });
-      }
-    }
-  }
-
-  async next(): Promise<IteratorResult<{ curr: misc.IStats; prev: misc.IStats }>> {
-    if (this.finished) {
-      return { value: undefined, done: true };
-    }
-
-    // If we have queued events, return one
-    if (this.eventQueue.length > 0) {
-      const event = this.eventQueue.shift()!;
-      return { value: event, done: false };
-    }
-
-    // Otherwise, wait for the next event
-    return new Promise((resolve, reject) => {
-      this.resolveQueue.push({ resolve, reject });
-    });
-  }
-
-  async return(): Promise<IteratorResult<{ curr: misc.IStats; prev: misc.IStats }>> {
-    this.finish();
-    return { value: undefined, done: true };
-  }
-
-  async throw(error: any): Promise<IteratorResult<{ curr: misc.IStats; prev: misc.IStats }>> {
-    this.finish(error);
-    throw error;
-  }
-
-  [Symbol.asyncIterator](): AsyncIterableIterator<{ curr: misc.IStats; prev: misc.IStats }> {
-    return this;
-  }
-}
-
 export class FsPromises implements FsPromisesApi {
   public readonly constants = constants;
 
@@ -288,16 +197,7 @@ export class FsPromises implements FsPromisesApi {
     filename: misc.PathLike,
     options?: opts.IWatchOptions | string,
   ): AsyncIterableIterator<{ eventType: string; filename: string | Buffer }> => {
-    const watchOptions: opts.IWatchOptions = typeof options === 'string' 
-      ? { encoding: options as any } 
-      : (options || {});
+    const watchOptions: opts.IWatchOptions = typeof options === 'string' ? { encoding: options as any } : options || {};
     return new FSWatchAsyncIterator(this.fs, filename, watchOptions);
   };
-
-  public readonly watchFile = (
-    filename: misc.PathLike,
-    options?: opts.IWatchFileOptions,
-  ): AsyncIterableIterator<{ curr: misc.IStats; prev: misc.IStats }> => {
-    return new StatWatchAsyncIterator(this.fs, filename, options || {});
-  };
 }
diff --git a/src/node/types/FsPromisesApi.ts b/src/node/types/FsPromisesApi.ts
@@ -37,9 +37,5 @@ export interface FsPromisesApi {
     filename: misc.PathLike,
     options?: opts.IWatchOptions,
   ): AsyncIterableIterator<{ eventType: string; filename: string | Buffer }>;
-  watchFile(
-    filename: misc.PathLike,
-    options?: opts.IWatchFileOptions,
-  ): AsyncIterableIterator<{ curr: misc.IStats; prev: misc.IStats }>;
   writeFile(id: misc.TFileHandle, data: misc.TPromisesData, options?: opts.IWriteFileOptions): Promise<void>;
 }
diff --git a/yarn.lock b/yarn.lock
