@gjsify/fs 0.1.13 → 0.2.0

package/src/utimes.ts

@@ -0,0 +1,97 @@
+// 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

@@ -0,0 +1,171 @@
+// 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

@@ -0,0 +1,185 @@
+// 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 });
+    });
+  });
+};

package/src/write-stream.ts

@@ -4,8 +4,8 @@
 // Modifications: Rewritten to use Gio.File for GJS
 
 import { Writable } from "node:stream";
-import { fileURLToPath, URL } from "node:url";
 import { open, write, close } from "./callback.js";
+import { normalizePath } from "./utils.js";
 
 import type { OpenFlags } from './types/index.js';
 import type { PathLike, WriteStream as IWriteStream } from 'node:fs';
@@ -14,13 +14,10 @@ import type { CreateWriteStreamOptions } from 'node:fs/promises'; // Types from
 const kIsPerformingIO = Symbol("kIsPerformingIO");
 const kIoDone = Symbol("kIoDone");
 
-export function toPathIfFileURL(
-  fileURLOrPath: string | Buffer | URL,
-): string | Buffer {
-  if (!(fileURLOrPath instanceof URL)) {
-    return fileURLOrPath;
-  }
-  return fileURLToPath(fileURLOrPath);
+// Legacy alias — delegates to the fs-package-internal `normalizePath`.
+// Accepts Buffer for compatibility with older call-sites; always returns a string.
+export function toPathIfFileURL(fileURLOrPath: string | Buffer | URL): string {
+  return normalizePath(fileURLOrPath as any);
 }
 export class WriteStream extends Writable implements IWriteStream {