Class VFSWatchAsyncIterable

lib/internal/vfs/watcher.js:579–683

const kMaxPendingEvents = 1024;

class VFSWatchAsyncIterable {
  #watcher;
  #closed = false;
  #pendingEvents = [];
  #pendingResolvers = [];

  /**
   * @param {VirtualProvider} provider The VFS provider
   * @param {string} path The path to watch (provider-relative)
   * @param {object} [options] Options
   */
  constructor(provider, path, options = kEmptyObject) {
    // Strip signal from options passed to VFSWatcher - we handle abort
    // at the iterable level to reject pending next() with AbortError
    // instead of resolving with done:true via the 'close' event.
    const signal = options.signal;
    const watcherOptions = ObjectAssign({ __proto__: null }, options);
    delete watcherOptions.signal;
    this.#watcher = new VFSWatcher(provider, path, watcherOptions);

    this.#watcher.on('change', (eventType, filename) => {
      const event = { eventType, filename };
      if (this.#pendingResolvers.length > 0) {
        const { resolve } = this.#pendingResolvers.shift();
        resolve({ done: false, value: event });
      } else if (this.#pendingEvents.length < kMaxPendingEvents) {
        ArrayPrototypePush(this.#pendingEvents, event);
      }
      // Drop events when queue is full to prevent unbounded memory growth
    });

    this.#watcher.on('close', () => {
      this.#closed = true;
      // Resolve any pending iterators
      while (this.#pendingResolvers.length > 0) {
        const { resolve } = this.#pendingResolvers.shift();
        resolve({ done: true, value: undefined });
      }
    });

    // Handle abort signal - reject pending next() with AbortError
    if (signal) {
      const onAbort = () => {
        this.#closed = true;
        const err = new AbortError(undefined, { cause: signal.reason });
        while (this.#pendingResolvers.length > 0) {
          const { reject } = this.#pendingResolvers.shift();
          reject(err);
        }
        this.#watcher.close();
      };
      if (signal.aborted) {
        onAbort();
      } else {
        signal.addEventListener('abort', onAbort, { once: true });
      }
    }
  }