@gjsify/fs 0.4.0 → 0.4.3

package/src/utimes.spec.ts

@@ -1,113 +0,0 @@
-// Ported from refs/node-test/parallel/test-fs-utimes.js (behavior)
-// Original: MIT, Node.js contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import { utimesSync, utimes, lutimesSync, lchownSync, promises } from 'node:fs';
-import { statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const TMP = tmpdir();
-
-function tmpFile(name: string): string {
-  const p = join(TMP, `gjsify-utimes-${name}-${process.pid}`);
-  writeFileSync(p, 'test');
-  return p;
-}
-
-export default async () => {
-  await describe('fs.utimes / fs.lutimes / fs.lchown / fs.lchmod', async () => {
-    await it('utimesSync sets mtime', async () => {
-      const f = tmpFile('mtime');
-      const mtime = new Date('2020-01-01T00:00:00Z');
-      utimesSync(f, mtime, mtime);
-      const stat = statSync(f);
-      expect(stat.mtime.getFullYear()).toBe(2020);
-      unlinkSync(f);
-    });
-
-    await it('utimesSync sets atime', async () => {
-      const f = tmpFile('atime');
-      const atime = new Date('2021-06-15T12:00:00Z');
-      const mtime = new Date('2020-01-01T00:00:00Z');
-      utimesSync(f, atime, mtime);
-      const stat = statSync(f);
-      expect(stat.mtime.getFullYear()).toBe(2020);
-      unlinkSync(f);
-    });
-
-    await it('utimes callback sets timestamps', async () => {
-      const f = tmpFile('cb');
-      const mtime = new Date('2019-03-10T00:00:00Z');
-      await new Promise<void>((resolve, reject) => {
-        utimes(f, mtime, mtime, (err) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-      const stat = statSync(f);
-      expect(stat.mtime.getFullYear()).toBe(2019);
-      unlinkSync(f);
-    });
-
-    await it('promises.utimes sets timestamps', async () => {
-      const f = tmpFile('promise');
-      const mtime = new Date('2018-08-01T00:00:00Z');
-      await promises.utimes(f, mtime, mtime);
-      const stat = statSync(f);
-      expect(stat.mtime.getFullYear()).toBe(2018);
-      unlinkSync(f);
-    });
-
-    await it('lutimesSync does not throw on a symlink', async () => {
-      const target = tmpFile('lutime-target');
-      const link = join(TMP, `gjsify-lutime-link-${process.pid}`);
-      try { unlinkSync(link); } catch {}
-      symlinkSync(target, link);
-      const mtime = new Date('2017-05-20T00:00:00Z');
-      // Just verify the call completes without throwing
-      expect(() => lutimesSync(link, mtime, mtime)).not.toThrow();
-      unlinkSync(link);
-      unlinkSync(target);
-    });
-
-    await it('lutimes callback completes without error', async () => {
-      const f = tmpFile('lutimes-cb');
-      const mtime = new Date('2016-01-01T00:00:00Z');
-      const { lutimes } = await import('node:fs') as any;
-      await new Promise<void>((resolve, reject) => {
-        lutimes(f, mtime, mtime, (err: any) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-      unlinkSync(f);
-    });
-
-    await it('lchownSync does not throw (may need root to actually change)', async () => {
-      const f = tmpFile('lchown');
-      const link = join(TMP, `gjsify-lchown-link-${process.pid}`);
-      try { unlinkSync(link); } catch {}
-      symlinkSync(f, link);
-      // This will only actually change owner if running as root; just verify no throw
-      try {
-        lchownSync(link, process.getuid ? process.getuid() : 0, process.getgid ? process.getgid() : 0);
-      } catch {
-        // acceptable if kernel denies (EPERM) — just must not crash the process
-      }
-      unlinkSync(link);
-      unlinkSync(f);
-    });
-
-    await it('lchmod is a no-op (does not throw)', async () => {
-      const f = tmpFile('lchmod');
-      // Node.js removed lchmod on Linux; on GJS we export it as a no-op
-      const fsModule = await import('node:fs') as any;
-      if (typeof fsModule.lchmod === 'function') {
-        expect(() => fsModule.lchmod(f, 0o644, () => {})).not.toThrow();
-      }
-      unlinkSync(f);
-    });
-  });
-};

package/src/utimes.ts

@@ -1,97 +0,0 @@
-// Reference: Node.js lib/fs.js (utimes/lutimes/lchown/lchmod)
-// Reimplemented for GJS using Gio.FileInfo timestamp attributes
-
-import GLib from '@girs/glib-2.0';
-import Gio from '@girs/gio-2.0';
-import { normalizePath } from './utils.js';
-
-import type { PathLike, TimeLike } from 'node:fs';
-
-function toGLibDateTime(t: TimeLike): GLib.DateTime {
-  const ms = t instanceof Date ? t.getTime()
-    : typeof t === 'bigint' ? Number(t)
-    : typeof t === 'string' ? Date.parse(t)
-    : t * 1000; // Node accepts float seconds
-  return GLib.DateTime.new_from_unix_utc(Math.floor(ms / 1000));
-}
-
-function setTimestamps(path: string, atime: TimeLike, mtime: TimeLike, flags: Gio.FileQueryInfoFlags): void {
-  const file = Gio.File.new_for_path(path);
-  const info = new Gio.FileInfo();
-  info.set_modification_date_time(toGLibDateTime(mtime));
-  info.set_access_date_time(toGLibDateTime(atime));
-  file.set_attributes_from_info(info, flags, null);
-}
-
-// ─── utimes ───────────────────────────────────────────────────────────────────
-
-export function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void {
-  setTimestamps(normalizePath(path), atime, mtime, Gio.FileQueryInfoFlags.NONE);
-}
-
-export function utimes(
-  path: PathLike,
-  atime: TimeLike,
-  mtime: TimeLike,
-  callback: (err: NodeJS.ErrnoException | null) => void,
-): void {
-  Promise.resolve().then(() => utimesSync(path, atime, mtime)).then(() => callback(null), callback);
-}
-
-export async function utimesAsync(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void> {
-  utimesSync(path, atime, mtime);
-}
-
-// ─── lutimes ──────────────────────────────────────────────────────────────────
-
-export function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void {
-  setTimestamps(normalizePath(path), atime, mtime, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS);
-}
-
-export function lutimes(
-  path: PathLike,
-  atime: TimeLike,
-  mtime: TimeLike,
-  callback: (err: NodeJS.ErrnoException | null) => void,
-): void {
-  Promise.resolve().then(() => lutimesSync(path, atime, mtime)).then(() => callback(null), callback);
-}
-
-export async function lutimesAsync(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void> {
-  lutimesSync(path, atime, mtime);
-}
-
-// ─── lchown ───────────────────────────────────────────────────────────────────
-// chown -h changes the ownership of the symlink itself, not its target.
-
-export function lchownSync(path: PathLike, uid: number, gid: number): void {
-  GLib.spawn_command_line_sync(`chown -h ${uid}:${gid} ${normalizePath(path)}`);
-}
-
-export function lchown(
-  path: PathLike,
-  uid: number,
-  gid: number,
-  callback: (err: NodeJS.ErrnoException | null) => void,
-): void {
-  Promise.resolve().then(() => lchownSync(path, uid, gid)).then(() => callback(null), callback);
-}
-
-export async function lchownAsync(path: PathLike, uid: number, gid: number): Promise<void> {
-  lchownSync(path, uid, gid);
-}
-
-// ─── lchmod ───────────────────────────────────────────────────────────────────
-// Not supported on Linux — no-op, no throw (mirrors Node.js behavior on Linux).
-
-export function lchmodSync(_path: PathLike, _mode: number): void {}
-
-export function lchmod(
-  _path: PathLike,
-  _mode: number,
-  callback: (err: NodeJS.ErrnoException | null) => void,
-): void {
-  callback(null);
-}
-
-export async function lchmodAsync(_path: PathLike, _mode: number): Promise<void> {}

package/src/watch.spec.ts

@@ -1,171 +0,0 @@
-// Ported from refs/bun/test/js/node/watch/fs.watch.test.ts
-// Original: MIT, Oven & contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  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-watch-'));
-}
-
-export default async () => {
-  await describe('fs.promises.watch', async () => {
-    await it('yields rename event when a file is created in a directory', async () => {
-      const tmp = makeTmp();
-      const ac = new AbortController();
-      let received = false;
-
-      // Write the file shortly after the iterator starts waiting
-      setTimeout(() => {
-        writeFileSync(join(tmp, 'new-file.txt'), 'hello');
-      }, 30);
-
-      try {
-        for await (const event of promises.watch(tmp, { signal: ac.signal })) {
-          expect(typeof event.eventType).toBe('string');
-          expect(['rename', 'change']).toContain(event.eventType);
-          received = true;
-          ac.abort();
-        }
-      } catch (e: any) {
-        // AbortError from native Node.js is expected — our impl ends cleanly
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      }
-
-      expect(received).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('yields change event when a watched file is modified', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'watch-me.txt');
-      writeFileSync(file, 'initial');
-
-      const ac = new AbortController();
-      let received = false;
-
-      setTimeout(() => {
-        writeFileSync(file, 'modified');
-      }, 30);
-
-      try {
-        for await (const event of promises.watch(file, { signal: ac.signal })) {
-          expect(typeof event.eventType).toBe('string');
-          expect(['rename', 'change']).toContain(event.eventType);
-          received = true;
-          ac.abort();
-        }
-      } catch (e: any) {
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      }
-
-      expect(received).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('filename in event is a string or null', async () => {
-      const tmp = makeTmp();
-      const ac = new AbortController();
-      let filename: string | null | undefined = undefined;
-
-      setTimeout(() => {
-        writeFileSync(join(tmp, 'tracked.txt'), 'x');
-      }, 30);
-
-      try {
-        for await (const event of promises.watch(tmp, { signal: ac.signal })) {
-          filename = event.filename;
-          ac.abort();
-        }
-      } catch (e: any) {
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      }
-
-      // filename is a string basename or null (GJS writeFileSync uses atomic writes
-      // via GLib.file_set_contents which may report a temp filename — any string is valid)
-      expect(typeof filename === 'string' || filename === null).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('stops iterating immediately when signal is pre-aborted', async () => {
-      const tmp = makeTmp();
-      const ac = new AbortController();
-      ac.abort(); // aborted BEFORE the watch starts
-
-      let count = 0;
-      try {
-        for await (const _ of promises.watch(tmp, { signal: ac.signal })) {
-          count++;
-        }
-      } catch (e: any) {
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      }
-
-      expect(count).toBe(0);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('stops cleanly when AbortController is aborted during iteration', async () => {
-      const tmp = makeTmp();
-      const ac = new AbortController();
-      let eventCount = 0;
-
-      // Write repeatedly so events keep coming
-      const interval = setInterval(() => {
-        writeFileSync(join(tmp, 'file.txt'), String(Date.now()));
-      }, 20);
-
-      try {
-        for await (const event of promises.watch(tmp, { signal: ac.signal })) {
-          expect(['rename', 'change']).toContain(event.eventType);
-          eventCount++;
-          if (eventCount >= 2) {
-            clearInterval(interval);
-            ac.abort();
-          }
-        }
-      } catch (e: any) {
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      } finally {
-        clearInterval(interval);
-      }
-
-      expect(eventCount).toBeGreaterThan(0);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('multiple events can be collected before abort', async () => {
-      const tmp = makeTmp();
-      const ac = new AbortController();
-      const events: string[] = [];
-
-      setTimeout(() => {
-        writeFileSync(join(tmp, 'a.txt'), '1');
-        writeFileSync(join(tmp, 'b.txt'), '2');
-      }, 30);
-
-      try {
-        for await (const event of promises.watch(tmp, { signal: ac.signal })) {
-          events.push(event.eventType);
-          if (events.length >= 2) {
-            ac.abort();
-          }
-        }
-      } catch (e: any) {
-        if (e?.name !== 'AbortError' && e?.code !== 'ABORT_ERR') throw e;
-      }
-
-      expect(events.length).toBeGreaterThan(0);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-};

package/src/watchfile.spec.ts

@@ -1,185 +0,0 @@
-// Ported from refs/bun/test/js/node/watch/fs.watchFile.test.ts (behavior)
-// Original: MIT, Oven & contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  watchFile,
-  unwatchFile,
-  writeFileSync,
-  mkdtempSync,
-  rmSync,
-} from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-const INTERVAL = 50;
-
-function makeTmp(): string {
-  return mkdtempSync(join(tmpdir(), 'gjsify-watchfile-'));
-}
-
-function wait(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export default async () => {
-  await describe('fs.watchFile / fs.unwatchFile', async () => {
-    await it('calls listener when file is modified', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'watch.txt');
-      writeFileSync(file, 'initial');
-
-      let called = false;
-      const listener = () => { called = true; };
-
-      watchFile(file, { interval: INTERVAL }, listener);
-
-      await wait(20);
-      writeFileSync(file, 'modified');
-      await wait(INTERVAL * 3);
-
-      unwatchFile(file, listener);
-      expect(called).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('calls listener with curr and prev Stats', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'stats.txt');
-      writeFileSync(file, 'v1');
-
-      let curr: any = null;
-      let prev: any = null;
-      const listener = (c: any, p: any) => { curr = c; prev = p; };
-
-      watchFile(file, { interval: INTERVAL }, listener);
-
-      await wait(20);
-      writeFileSync(file, 'v2-longer');
-      await wait(INTERVAL * 3);
-
-      unwatchFile(file, listener);
-      expect(curr).not.toBeNull();
-      expect(prev).not.toBeNull();
-      expect(typeof curr.mtimeMs).toBe('number');
-      expect(typeof prev.mtimeMs).toBe('number');
-      expect(curr.size).toBeGreaterThan(prev.size);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('stops calling listener after unwatchFile', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'stop.txt');
-      writeFileSync(file, 'start');
-
-      let count = 0;
-      const listener = () => { count++; };
-
-      watchFile(file, { interval: INTERVAL }, listener);
-
-      await wait(20);
-      writeFileSync(file, 'change1');
-      await wait(INTERVAL * 3);
-      unwatchFile(file, listener);
-
-      const countAfterUnwatch = count;
-      writeFileSync(file, 'change2');
-      await wait(INTERVAL * 3);
-
-      expect(count).toBe(countAfterUnwatch);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('unwatchFile with no listener removes all listeners', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'all.txt');
-      writeFileSync(file, 'x');
-
-      let a = 0;
-      let b = 0;
-      const la = () => { a++; };
-      const lb = () => { b++; };
-
-      watchFile(file, { interval: INTERVAL }, la);
-      watchFile(file, { interval: INTERVAL }, lb);
-
-      await wait(20);
-      writeFileSync(file, 'y');
-      await wait(INTERVAL * 3);
-
-      unwatchFile(file); // remove all
-
-      const snapA = a;
-      const snapB = b;
-      writeFileSync(file, 'z');
-      await wait(INTERVAL * 3);
-
-      expect(a).toBe(snapA);
-      expect(b).toBe(snapB);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('returns StatWatcher with changeListenerCount', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'watcher.txt');
-      writeFileSync(file, '0');
-
-      const listener = () => {};
-      const watcher = watchFile(file, { interval: INTERVAL }, listener);
-
-      expect(typeof watcher.on).toBe('function');
-      expect(watcher.listenerCount('change')).toBe(1);
-
-      unwatchFile(file, listener);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('multiple listeners on same file share one watcher', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'shared.txt');
-      writeFileSync(file, '0');
-
-      let a = 0;
-      let b = 0;
-      const la = () => { a++; };
-      const lb = () => { b++; };
-
-      const w1 = watchFile(file, { interval: INTERVAL }, la);
-      const w2 = watchFile(file, { interval: INTERVAL }, lb);
-
-      expect(w1).toBe(w2); // same watcher instance
-
-      await wait(20);
-      writeFileSync(file, '1');
-      await wait(INTERVAL * 3);
-
-      unwatchFile(file, la);
-      unwatchFile(file, lb);
-      expect(a).toBeGreaterThan(0);
-      expect(b).toBeGreaterThan(0);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('listener called when file is created (was non-existent)', async () => {
-      const tmp = makeTmp();
-      const file = join(tmp, 'new.txt');
-      // file does NOT exist yet
-
-      let called = false;
-      const listener = (curr: any) => {
-        if (curr.size > 0) called = true;
-      };
-
-      watchFile(file, { interval: INTERVAL }, listener);
-
-      await wait(20);
-      writeFileSync(file, 'created');
-      await wait(INTERVAL * 3);
-
-      unwatchFile(file, listener);
-      expect(called).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-};