@gjsify/fs 0.4.0 → 0.4.4

package/src/fs-watcher.ts

@@ -1,198 +0,0 @@
-// Reference: Node.js lib/internal/fs/watchers.js
-// Reimplemented for GJS using Gio.FileMonitor
-
-import GLib from '@girs/glib-2.0';
-import Gio from '@girs/gio-2.0';
-import { EventEmitter } from 'node:events';
-import { normalizePath } from './utils.js';
-const privates = new WeakMap;
-
-import type { FSWatcher as IFSWatcher, PathLike, WatchOptions } from 'node:fs';
-
-export class FSWatcher extends EventEmitter implements IFSWatcher {
-
-  constructor(filename: PathLike, options, listener) {
-    super();
-    if (!options || typeof options !== 'object')
-      options = {persistent: true};
-
-    const persistent = options.persistent !== false;
-    const cancellable = Gio.Cancellable.new();
-    const pathStr = normalizePath(filename);
-    const file = Gio.File.new_for_path(pathStr);
-    const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
-    watcher.connect('changed', changed.bind(this));
-
-    // When persistent is true, acquire a reference on the default GLib main context
-    // so the main loop stays alive while this watcher is active.
-    // This mirrors Node.js behavior where persistent watchers keep the event loop alive.
-    let sourceId: number | null = null;
-    if (persistent) {
-      // Add a never-firing timeout source to keep the mainloop alive.
-      // This is a lightweight way to hold a ref on the main context.
-      sourceId = (GLib.timeout_add as unknown as (priority: number, interval: number, fn: () => boolean) => number)(
-        GLib.PRIORITY_LOW,
-        2147483647,
-        () => GLib.SOURCE_CONTINUE,
-      );
-    }
-
-    privates.set(this, {
-      persistent,
-      cancellable,
-      sourceId,
-      // even if never used later on, the monitor needs to be
-      // attached to this instance or GJS reference counter
-      // will ignore it and no watch will ever happen
-      watcher
-    });
-    if (listener) this.on('change', listener);
-  }
-
-  close() {
-    const priv = privates.get(this);
-    if (!priv.cancellable.is_cancelled()) {
-      priv.cancellable.cancel();
-      if (priv.sourceId !== null) {
-        GLib.source_remove(priv.sourceId);
-        priv.sourceId = null;
-      }
-    }
-  }
-
-  /**
-   * When called, requests that the Node.js event loop not exit so long as the
-   * FSWatcher is active. Calling ref() multiple times has no effect.
-   */
-  ref(): this {
-    const priv = privates.get(this);
-    if (!priv.persistent && !priv.cancellable.is_cancelled()) {
-      priv.persistent = true;
-      priv.sourceId = (GLib.timeout_add as unknown as (priority: number, interval: number, fn: () => boolean) => number)(
-        GLib.PRIORITY_LOW,
-        2147483647,
-        () => GLib.SOURCE_CONTINUE,
-      );
-    }
-    return this;
-  }
-
-  /**
-   * When called, the active FSWatcher will not require the Node.js event loop
-   * to remain active. Calling unref() multiple times has no effect.
-   */
-  unref(): this {
-    const priv = privates.get(this);
-    if (priv.persistent) {
-      priv.persistent = false;
-      if (priv.sourceId !== null) {
-        GLib.source_remove(priv.sourceId);
-        priv.sourceId = null;
-      }
-    }
-    return this;
-  }
-
-};
-
-function changed(watcher, file, otherFile, eventType) {
-  switch (eventType) {
-    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
-      this.emit('change', 'change', file.get_basename());
-      break;
-    case Gio.FileMonitorEvent.DELETED:
-    case Gio.FileMonitorEvent.CREATED:
-    case Gio.FileMonitorEvent.RENAMED:
-    case Gio.FileMonitorEvent.MOVED_IN:
-    case Gio.FileMonitorEvent.MOVED_OUT:
-      this.emit('rename', 'rename', file.get_basename());
-      break;
-  }
-}
-
-export default FSWatcher;
-
-// ─── fs.promises.watch ────────────────────────────────────────────────────────
-
-type WatchEvent = { eventType: string; filename: string | null };
-
-function gioEventToNodeType(eventType: Gio.FileMonitorEvent): string | null {
-  switch (eventType) {
-    case Gio.FileMonitorEvent.CHANGES_DONE_HINT: return 'change';
-    case Gio.FileMonitorEvent.DELETED:
-    case Gio.FileMonitorEvent.CREATED:
-    case Gio.FileMonitorEvent.RENAMED:
-    case Gio.FileMonitorEvent.MOVED_IN:
-    case Gio.FileMonitorEvent.MOVED_OUT: return 'rename';
-    default: return null;
-  }
-}
-
-export async function* watchAsync(
-  filename: PathLike,
-  options?: WatchOptions & { signal?: AbortSignal },
-): AsyncIterableIterator<WatchEvent> {
-  const signal = (options as any)?.signal as AbortSignal | undefined;
-
-  if (signal?.aborted) return;
-
-  const pathStr = normalizePath(filename);
-  const file = Gio.File.new_for_path(pathStr);
-  const cancellable = Gio.Cancellable.new();
-
-  let watcher: Gio.FileMonitor;
-  try {
-    watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
-  } catch {
-    return;
-  }
-
-  const eventQueue: WatchEvent[] = [];
-  const waiterQueue: Array<{ resolve: (r: IteratorResult<WatchEvent>) => void }> = [];
-  let finished = false;
-
-  function enqueue(event: WatchEvent): void {
-    if (finished) return;
-    if (waiterQueue.length > 0) {
-      waiterQueue.shift()!.resolve({ value: event, done: false });
-    } else {
-      eventQueue.push(event);
-    }
-  }
-
-  function terminate(): void {
-    if (finished) return;
-    finished = true;
-    if (!cancellable.is_cancelled()) cancellable.cancel();
-    while (waiterQueue.length > 0) {
-      waiterQueue.shift()!.resolve({ value: undefined as any, done: true });
-    }
-  }
-
-  const signalId = watcher.connect('changed', (_mon: Gio.FileMonitor, changedFile: Gio.File, _otherFile: Gio.File | null, eventType: Gio.FileMonitorEvent) => {
-    const type = gioEventToNodeType(eventType);
-    if (type === null) return;
-    enqueue({ eventType: type, filename: changedFile?.get_basename() ?? null });
-  });
-
-  const abortHandler = () => terminate();
-  signal?.addEventListener('abort', abortHandler);
-
-  try {
-    while (!finished) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift()!;
-        continue;
-      }
-      const result = await new Promise<IteratorResult<WatchEvent>>(resolve => {
-        waiterQueue.push({ resolve });
-      });
-      if (result.done) break;
-      yield result.value;
-    }
-  } finally {
-    signal?.removeEventListener('abort', abortHandler);
-    try { watcher.disconnect(signalId); } catch {}
-    if (!cancellable.is_cancelled()) cancellable.cancel();
-  }
-}

package/src/glob.spec.ts

@@ -1,201 +0,0 @@
-// Ported from refs/bun/test/js/node/fs/glob.test.ts
-// Original: MIT, Oven & contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  globSync,
-  glob,
-  promises,
-  mkdirSync,
-  writeFileSync,
-  mkdtempSync,
-  rmSync,
-} from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-function makeTmp(): string {
-  return mkdtempSync(join(tmpdir(), 'gjsify-glob-'));
-}
-
-export default async () => {
-  await describe('fs.globSync', async () => {
-    await it('matches *.ts files in flat directory', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.ts'), '');
-      writeFileSync(join(tmp, 'b.ts'), '');
-      writeFileSync(join(tmp, 'c.txt'), '');
-
-      const results = globSync('*.ts', { cwd: tmp });
-      expect(results.sort()).toStrictEqual(['a.ts', 'b.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('matches **/*.ts recursively', async () => {
-      const tmp = makeTmp();
-      mkdirSync(join(tmp, 'sub'));
-      writeFileSync(join(tmp, 'root.ts'), '');
-      writeFileSync(join(tmp, 'sub', 'nested.ts'), '');
-      writeFileSync(join(tmp, 'sub', 'other.txt'), '');
-
-      const results = globSync('**/*.ts', { cwd: tmp });
-      expect(results.sort()).toStrictEqual(['root.ts', 'sub/nested.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('matches files in a subdirectory pattern', async () => {
-      const tmp = makeTmp();
-      mkdirSync(join(tmp, 'src'));
-      writeFileSync(join(tmp, 'src', 'index.ts'), '');
-      writeFileSync(join(tmp, 'src', 'util.ts'), '');
-      writeFileSync(join(tmp, 'index.ts'), '');
-
-      const results = globSync('src/*.ts', { cwd: tmp });
-      expect(results.sort()).toStrictEqual(['src/index.ts', 'src/util.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('supports {a,b} alternation', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.ts'), '');
-      writeFileSync(join(tmp, 'b.ts'), '');
-      writeFileSync(join(tmp, 'c.ts'), '');
-
-      const results = globSync('*.{ts,js}', { cwd: tmp });
-      expect(results.sort()).toStrictEqual(['a.ts', 'b.ts', 'c.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('** matches all files and directories', async () => {
-      const tmp = makeTmp();
-      mkdirSync(join(tmp, 'sub'));
-      writeFileSync(join(tmp, 'a.ts'), '');
-      writeFileSync(join(tmp, 'sub', 'b.ts'), '');
-
-      const results = globSync('**', { cwd: tmp });
-      // Should include '.', 'a.ts', 'sub', 'sub/b.ts'
-      expect(results.includes('a.ts')).toBe(true);
-      expect(results.includes('sub/b.ts')).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('a/** matches the directory itself and its contents', async () => {
-      const tmp = makeTmp();
-      mkdirSync(join(tmp, 'sub'));
-      writeFileSync(join(tmp, 'sub', 'x.ts'), '');
-      writeFileSync(join(tmp, 'root.ts'), '');
-
-      const results = globSync('sub/**', { cwd: tmp });
-      expect(results.includes('sub')).toBe(true);
-      expect(results.includes('sub/x.ts')).toBe(true);
-      expect(results.includes('root.ts')).toBe(false);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('accepts array of patterns', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.ts'), '');
-      writeFileSync(join(tmp, 'b.js'), '');
-      writeFileSync(join(tmp, 'c.txt'), '');
-
-      const results = globSync(['*.ts', '*.js'], { cwd: tmp });
-      expect(results.sort()).toStrictEqual(['a.ts', 'b.js']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('exclude function filters out matching paths', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.ts'), '');
-      writeFileSync(join(tmp, 'b.ts'), '');
-
-      // Use **/*.ts so Node.js native also invokes the exclude function
-      // (flat patterns like *.ts skip directory traversal and exclude is not called)
-      const results = globSync('**/*.ts', {
-        cwd: tmp,
-        exclude: (p) => p === 'a.ts',
-      });
-      expect(results).toStrictEqual(['b.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('returns empty array when no files match', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.txt'), '');
-
-      const results = globSync('*.ts', { cwd: tmp });
-      expect(results).toStrictEqual([]);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('returns empty array for non-existent cwd', async () => {
-      const results = globSync('*.ts', { cwd: '/nonexistent-dir-gjsify-test' });
-      expect(results).toStrictEqual([]);
-    });
-  });
-
-  await describe('fs.glob (callback)', async () => {
-    await it('calls back with matched files', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'hello.ts'), '');
-      writeFileSync(join(tmp, 'world.ts'), '');
-
-      const results = await new Promise<string[]>((resolve, reject) => {
-        glob('*.ts', { cwd: tmp }, (err, matches) => {
-          if (err) return reject(err);
-          resolve(matches);
-        });
-      });
-
-      expect(results.sort()).toStrictEqual(['hello.ts', 'world.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('accepts callback as second argument (no options)', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'file.ts'), '');
-
-      const results = await new Promise<string[]>((resolve, reject) => {
-        (glob as any)('*.ts', (err: any, matches: string[]) => {
-          if (err) return reject(err);
-          resolve(matches);
-        });
-      });
-
-      // No cwd given — just verify it completes without error
-      expect(Array.isArray(results)).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-
-  await describe('fs.promises.glob', async () => {
-    await it('async iterates matched files', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'alpha.ts'), '');
-      writeFileSync(join(tmp, 'beta.ts'), '');
-
-      const results: string[] = [];
-      for await (const match of promises.glob('*.ts', { cwd: tmp })) {
-        results.push(match);
-      }
-
-      expect(results.sort()).toStrictEqual(['alpha.ts', 'beta.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('async iterates recursively with **/*.ts', async () => {
-      const tmp = makeTmp();
-      mkdirSync(join(tmp, 'lib'));
-      writeFileSync(join(tmp, 'index.ts'), '');
-      writeFileSync(join(tmp, 'lib', 'helper.ts'), '');
-
-      const results: string[] = [];
-      for await (const match of promises.glob('**/*.ts', { cwd: tmp })) {
-        results.push(match);
-      }
-
-      expect(results.sort()).toStrictEqual(['index.ts', 'lib/helper.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-};

package/src/glob.ts

@@ -1,205 +0,0 @@
-// Reference: Node.js lib/internal/fs/glob.js
-// Reimplemented for GJS using readdirSync (recursive) + pattern matching
-
-import { readdirSync } from './sync.js';
-import { normalizePath } from './utils.js';
-import type { PathLike } from 'node:fs';
-
-export interface GlobOptions {
-  cwd?: string | URL;
-  exclude?: string | string[] | ((path: string) => boolean);
-  withFileTypes?: boolean;
-}
-
-// ─── Pattern → RegExp conversion ─────────────────────────────────────────────
-
-/** Convert a single glob segment (no `/`) to a regex source string */
-function segmentToRegexSrc(seg: string): string {
-  // Handle extglob: !(pattern), *(pattern), +(pattern), ?(pattern), @(pattern)
-  const extglob = /^([!*+?@])\((.+)\)$/.exec(seg);
-  if (extglob) {
-    const [, type, inner] = extglob;
-    const parts = inner.split('|').map(p => segmentToRegexSrc(p));
-    const group = '(?:' + parts.join('|') + ')';
-    switch (type) {
-      case '!': return '(?!(?:' + parts.join('|') + '))[^/]*';
-      case '*': return group + '*';
-      case '+': return group + '+';
-      case '?': return group + '?';
-      case '@': return group;
-    }
-  }
-
-  let result = '';
-  let i = 0;
-  while (i < seg.length) {
-    const c = seg[i];
-    if (c === '*') { result += '[^/]*'; i++; continue; }
-    if (c === '?') { result += '[^/]'; i++; continue; }
-    if (c === '[') {
-      // Character class — pass through to regex
-      const end = seg.indexOf(']', i + 1);
-      if (end === -1) { result += '\\['; i++; continue; }
-      result += seg.slice(i, end + 1);
-      i = end + 1;
-      continue;
-    }
-    if (c === '{') {
-      // Alternation
-      const end = seg.indexOf('}', i + 1);
-      if (end === -1) { result += '\\{'; i++; continue; }
-      const alts = seg.slice(i + 1, end).split(',').map(a => segmentToRegexSrc(a.trim()));
-      result += '(?:' + alts.join('|') + ')';
-      i = end + 1;
-      continue;
-    }
-    // Escape regex special chars
-    if ('.+^$|()[]{}'.includes(c)) {
-      result += '\\' + c;
-    } else {
-      result += c;
-    }
-    i++;
-  }
-  return result;
-}
-
-/**
- * Convert a glob pattern to a RegExp that matches relative POSIX paths.
- */
-function globToRegex(pattern: string): RegExp {
-  // Normalize: collapse multiple slashes, remove leading './'
-  pattern = pattern.replace(/\/+/g, '/').replace(/^\.\//, '');
-
-  const segments = pattern.split('/');
-  const parts: string[] = [];
-
-  for (let si = 0; si < segments.length; si++) {
-    const seg = segments[si];
-    const isLast = si === segments.length - 1;
-
-    if (seg === '**') {
-      if (isLast) {
-        if (parts.length > 0 && parts[parts.length - 1] === '/') {
-          // Remove the trailing '/' so "a/" becomes optional: "a(?:/.*)?
-          parts.pop();
-          parts.push('(?:/.+)?');
-        } else {
-          // '**' at root level: match '.' or anything
-          parts.push('(?:.+)?');
-        }
-      } else {
-        // Not last: match zero or more path segments with trailing slash
-        parts.push('(?:[^/]+/)*');
-      }
-    } else {
-      parts.push(segmentToRegexSrc(seg));
-      if (!isLast) parts.push('/');
-    }
-  }
-
-  return new RegExp('^(?:' + parts.join('') + ')$');
-}
-
-// ─── Exclude logic ────────────────────────────────────────────────────────────
-
-function buildExcludePredicate(exclude: GlobOptions['exclude']): ((path: string) => boolean) | null {
-  if (!exclude) return null;
-  if (typeof exclude === 'function') return exclude;
-  const patterns = Array.isArray(exclude) ? exclude : [exclude];
-  const regexes = patterns.map(p => globToRegex(p));
-  return (path: string) => regexes.some(rx => rx.test(path));
-}
-
-// ─── Walk + match ─────────────────────────────────────────────────────────────
-
-function matchAll(pattern: string, cwd: string, exclude: GlobOptions['exclude']): string[] {
-  const regex = globToRegex(pattern);
-  const isExcluded = buildExcludePredicate(exclude);
-
-  // Get all entries recursively (files + directories)
-  let allEntries: string[];
-  try {
-    allEntries = readdirSync(cwd, { recursive: true }) as string[];
-  } catch {
-    return [];
-  }
-
-  // Include '.' itself for patterns like '**' that match the root
-  const candidates = ['.', ...allEntries];
-
-  const results: string[] = [];
-  for (const entry of candidates) {
-    // Normalize separators for matching
-    const normalized = entry.replace(/\\/g, '/');
-    if (!regex.test(normalized)) continue;
-    if (isExcluded && isExcluded(normalized)) continue;
-    results.push(entry);
-  }
-
-  return results;
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export function globSync(
-  pattern: string | string[],
-  options?: GlobOptions,
-): string[] {
-  const patterns = Array.isArray(pattern) ? pattern : [pattern];
-  const cwd = options?.cwd
-    ? normalizePath(options.cwd as PathLike)
-    : (globalThis as any).process?.cwd?.() ?? '/';
-  const exclude = options?.exclude;
-
-  const seen = new Set<string>();
-  const results: string[] = [];
-
-  for (const p of patterns) {
-    for (const match of matchAll(p, cwd, exclude)) {
-      if (!seen.has(match)) {
-        seen.add(match);
-        results.push(match);
-      }
-    }
-  }
-
-  return results;
-}
-
-export function glob(
-  pattern: string | string[],
-  options: GlobOptions | ((err: NodeJS.ErrnoException | null, matches: string[]) => void),
-  callback?: (err: NodeJS.ErrnoException | null, matches: string[]) => void,
-): void {
-  let opts: GlobOptions;
-  let cb: (err: NodeJS.ErrnoException | null, matches: string[]) => void;
-
-  if (typeof options === 'function') {
-    cb = options;
-    opts = {};
-  } else {
-    cb = callback!;
-    opts = options || {};
-  }
-
-  Promise.resolve().then(() => {
-    try {
-      const matches = globSync(pattern, opts);
-      cb(null, matches);
-    } catch (err: unknown) {
-      cb(err as NodeJS.ErrnoException, []);
-    }
-  });
-}
-
-// promises.glob returns an async iterator
-export async function* globAsync(
-  pattern: string | string[],
-  options?: GlobOptions,
-): AsyncIterableIterator<string> {
-  const matches = globSync(pattern, options);
-  for (const m of matches) {
-    yield m;
-  }
-}