@gjsify/fs 0.1.15 → 0.2.0

package/src/promises.ts

@@ -6,8 +6,26 @@ import GLib from '@girs/glib-2.0';
 import { join, dirname } from 'node:path';
 import { getEncodingFromOptions, encodeUint8Array, decode } from './encoding.js';
 import { realpathSync, readdirSync as readdirSyncFn, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, linkSync } from './sync.js';
+import { cpAsync } from './cp.js';
+import { opendirAsync, Dir } from './dir.js';
+import { globAsync } from './glob.js';
+import { watchAsync } from './fs-watcher.js';
+import { statfsAsync } from './statfs.js';
+import { utimesAsync, lutimesAsync, lchownAsync, lchmodAsync } from './utimes.js';
+import {
+  fstatAsync,
+  ftruncateAsync,
+  fdatasyncAsync,
+  fsyncAsync,
+  fchmodAsync,
+  fchownAsync,
+  futimesAsync,
+  readvAsync,
+  writevAsync,
+  openAsBlob,
+} from './fd-ops.js';
 import { FileHandle } from './file-handle.js';
-import { tempDirPath } from './utils.js';
+import { tempDirPath, normalizePath } from './utils.js';
 import { Dirent } from './dirent.js';
 import { Stats, BigIntStats, STAT_ATTRIBUTES } from './stats.js';
 import { createNodeError } from './errors.js';
@@ -77,7 +95,7 @@ async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | nul
     _mode = options;
   }
 
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
 
   if (recursive) {
     return mkdirRecursiveAsync(pathStr);
@@ -90,7 +108,7 @@ async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | nul
         file.make_directory_finish(res);
         resolve(undefined);
       } catch (err: unknown) {
-        reject(createNodeError(err, 'mkdir', path));
+        reject(createNodeError(err, 'mkdir', pathStr));
       }
     });
   });
@@ -152,7 +170,8 @@ async function mkdirRecursiveAsync(pathStr: string): Promise<string | undefined>
 }
 
 async function readFile(path: PathLike | FileHandle, options: ReadOptions = { encoding: null, flag: 'r' }) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path as PathLike);
+  const file = Gio.File.new_for_path(pathStr);
 
   let ok: boolean;
   let data: Uint8Array;
@@ -167,11 +186,11 @@ async function readFile(path: PathLike | FileHandle, options: ReadOptions = { en
       });
     });
   } catch (error) {
-    throw createNodeError(error, 'open', path.toString() as PathLike);
+    throw createNodeError(error, 'open', pathStr);
   }
 
   if (!ok) {
-    throw createNodeError(new Error('failed to read file'), 'open', path.toString() as PathLike);
+    throw createNodeError(new Error('failed to read file'), 'open', pathStr);
   }
 
   return encodeUint8Array(getEncodingFromOptions(options, 'buffer'), data);
@@ -230,8 +249,9 @@ async function mkdtemp(prefix: string, options?: BufferEncodingOption | ObjectEn
   return decode(path, encoding);
 }
 
-async function writeFile(path: string, data: string | Uint8Array | unknown) {
-  const file = Gio.File.new_for_path(path);
+async function writeFile(path: PathLike, data: string | Uint8Array | unknown) {
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
 
   // Convert data to Uint8Array if it's a string
   let bytes: Uint8Array;
@@ -250,7 +270,7 @@ async function writeFile(path: string, data: string | Uint8Array | unknown) {
       try {
         resolve(file.replace_finish(res));
       } catch (err: unknown) {
-        reject(createNodeError(err, 'open', path));
+        reject(createNodeError(err, 'open', pathStr));
       }
     });
   });
@@ -264,7 +284,7 @@ async function writeFile(path: string, data: string | Uint8Array | unknown) {
           outputStream.write_bytes_finish(res);
           resolve();
         } catch (err: unknown) {
-          reject(createNodeError(err, 'write', path));
+          reject(createNodeError(err, 'write', pathStr));
         }
       });
     });
@@ -277,7 +297,7 @@ async function writeFile(path: string, data: string | Uint8Array | unknown) {
         outputStream.close_finish(res);
         resolve();
       } catch (err: unknown) {
-        reject(createNodeError(err, 'close', path));
+        reject(createNodeError(err, 'close', pathStr));
       }
     });
   });
@@ -294,20 +314,21 @@ async function writeFile(path: string, data: string | Uint8Array | unknown) {
  * @return Fulfills with `undefined` upon success.
  */
 async function rmdir(path: PathLike, _options?: RmDirOptions): Promise<void> {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   // Check if it's a directory
   const info = await new Promise<Gio.FileInfo>((resolve, reject) => {
     file.query_info_async('standard::type', Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
       try {
         resolve(file.query_info_finish(res));
       } catch (err: unknown) {
-        reject(createNodeError(err, 'rmdir', path));
+        reject(createNodeError(err, 'rmdir', pathStr));
       }
     });
   });
   if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
     const err = Object.assign(new Error(), { code: 4 }); // Gio.IOErrorEnum.NOT_DIRECTORY
-    throw createNodeError(err, 'rmdir', path);
+    throw createNodeError(err, 'rmdir', pathStr);
   }
   // Check if empty
   const children = await new Promise<Gio.FileEnumerator>((resolve, reject) => {
@@ -315,14 +336,14 @@ async function rmdir(path: PathLike, _options?: RmDirOptions): Promise<void> {
       try {
         resolve(file.enumerate_children_finish(res));
       } catch (err: unknown) {
-        reject(createNodeError(err, 'rmdir', path));
+        reject(createNodeError(err, 'rmdir', pathStr));
       }
     });
   });
   const firstChild = children.next_file(null);
   if (firstChild !== null) {
     const err = Object.assign(new Error(), { code: 5 }); // Gio.IOErrorEnum.NOT_EMPTY
-    throw createNodeError(err, 'rmdir', path);
+    throw createNodeError(err, 'rmdir', pathStr);
   }
   // Delete the empty directory
   await new Promise<void>((resolve, reject) => {
@@ -331,29 +352,30 @@ async function rmdir(path: PathLike, _options?: RmDirOptions): Promise<void> {
         file.delete_finish(res);
         resolve();
       } catch (err: unknown) {
-        reject(createNodeError(err, 'rmdir', path));
+        reject(createNodeError(err, 'rmdir', pathStr));
       }
     });
   });
 }
 
-async function unlink(path: string): Promise<void> {
-  const file = Gio.File.new_for_path(path);
+async function unlink(path: PathLike): Promise<void> {
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   await new Promise<void>((resolve, reject) => {
     file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
       try {
         file.delete_finish(res);
         resolve();
       } catch (err: unknown) {
-        reject(createNodeError(err, 'unlink', path));
+        reject(createNodeError(err, 'unlink', pathStr));
       }
     });
   });
 }
 
-async function open(path: PathLike, flags?: OpenFlags, mode?: Mode): Promise<FileHandle> {
+async function open(path: PathLike, flags?: OpenFlags | number, mode?: Mode): Promise<FileHandle> {
   // FileHandle constructor maps GLib.FileError to NodeJS.ErrnoException on failure.
-  return new FileHandle({ path, flags, mode });
+  return new FileHandle({ path, flags: flags as OpenFlags | undefined, mode });
 }
 
 async function write<TBuffer extends Uint8Array>(
@@ -425,14 +447,15 @@ async function _writeStr(
 // --- helpers ---
 
 function queryInfoAsync(path: PathLike, flags: Gio.FileQueryInfoFlags, syscall: string, options?: { bigint?: boolean }): Promise<Stats | BigIntStats> {
+  const pathStr = normalizePath(path);
   return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(path.toString());
+    const file = Gio.File.new_for_path(pathStr);
     file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
       try {
         const info = file.query_info_finish(res);
-        resolve(options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+        resolve(options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
       } catch (err: unknown) {
-        reject(createNodeError(err, syscall, path));
+        reject(createNodeError(err, syscall, pathStr));
       }
     });
   });
@@ -463,14 +486,16 @@ async function realpath(path: PathLike): Promise<string> {
 }
 
 async function symlink(target: PathLike, path: PathLike, _type?: string): Promise<void> {
+  const pathStr = normalizePath(path);
+  const targetStr = normalizePath(target);
   return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(path.toString());
-    file.make_symbolic_link_async(target.toString(), GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+    const file = Gio.File.new_for_path(pathStr);
+    file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
       try {
         file.make_symbolic_link_finish(res);
         resolve();
       } catch (err: unknown) {
-        reject(createNodeError(err, 'symlink', target, path));
+        reject(createNodeError(err, 'symlink', targetStr, pathStr));
       }
     });
   });
@@ -482,7 +507,7 @@ async function symlink(target: PathLike, path: PathLike, _type?: string): Promis
  * @return Fulfills with `undefined` upon success.
  */
 async function rm(path: PathLike, options?: RmOptions): Promise<void> {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
   const force = options?.force || false;
@@ -568,6 +593,8 @@ async function link(existingPath: PathLike, newPath: PathLike): Promise<void> {
   linkSync(existingPath, newPath);
 }
 
+export type { Dir };
+
 export {
   readFile,
   mkdir,
@@ -592,6 +619,25 @@ export {
   chmod,
   chown,
   link,
+  cpAsync as cp,
+  opendirAsync as opendir,
+  globAsync as glob,
+  watchAsync as watch,
+  statfsAsync as statfs,
+  utimesAsync as utimes,
+  lutimesAsync as lutimes,
+  lchownAsync as lchown,
+  lchmodAsync as lchmod,
+  fstatAsync as fstat,
+  ftruncateAsync as ftruncate,
+  fdatasyncAsync as fdatasync,
+  fsyncAsync as fsync,
+  fchmodAsync as fchmod,
+  fchownAsync as fchown,
+  futimesAsync as futimes,
+  readvAsync as readv,
+  writevAsync as writev,
+  openAsBlob,
 };
 
 export default {
@@ -618,4 +664,23 @@ export default {
   chmod,
   chown,
   link,
+  cp: cpAsync,
+  opendir: opendirAsync,
+  glob: globAsync,
+  watch: watchAsync,
+  statfs: statfsAsync,
+  utimes: utimesAsync,
+  lutimes: lutimesAsync,
+  lchown: lchownAsync,
+  lchmod: lchmodAsync,
+  fstat: fstatAsync,
+  ftruncate: ftruncateAsync,
+  fdatasync: fdatasyncAsync,
+  fsync: fsyncAsync,
+  fchmod: fchmodAsync,
+  fchown: fchownAsync,
+  futimes: futimesAsync,
+  readv: readvAsync,
+  writev: writevAsync,
+  openAsBlob,
 };

package/src/read-stream.ts

@@ -6,7 +6,7 @@ import Gio from '@girs/gio-2.0';
 import GLib from '@girs/glib-2.0';
 import { Buffer } from "node:buffer";
 import { Readable } from "node:stream";
-import { URL, fileURLToPath } from "node:url";
+import { normalizePath } from './utils.js';
 
 import type { CreateReadStreamOptions } from 'node:fs/promises';
 import type { PathLike, ReadStream as IReadStream } from 'node:fs';
@@ -19,13 +19,15 @@ export class ReadStream extends Readable implements IReadStream {
 
   private _gioFile: Gio.File;
   private _inputStream: Gio.FileInputStream | null = null;
+  private _cancellable = new Gio.Cancellable();
   private _start: number;
   private _end: number;
   private _pos: number;
 
   close(callback?: (err?: NodeJS.ErrnoException | null) => void): void {
+    this._cancellable.cancel();
     if (this._inputStream) {
-      try { this._inputStream.close(null); } catch {}
+      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
       this._inputStream = null;
     }
     this.destroy();
@@ -33,9 +35,7 @@ export class ReadStream extends Readable implements IReadStream {
   }
 
   constructor(path: PathLike, opts?: CreateReadStreamOptions) {
-    if (path instanceof URL) {
-      path = fileURLToPath(path);
-    }
+    const pathStr = normalizePath(path);
 
     super({
       highWaterMark: opts?.highWaterMark ?? 64 * 1024,
@@ -43,40 +43,41 @@ export class ReadStream extends Readable implements IReadStream {
       objectMode: false,
     });
 
-    this.path = path.toString();
-    this._gioFile = Gio.File.new_for_path(this.path.toString());
+    this.path = pathStr;
+    this._gioFile = Gio.File.new_for_path(pathStr);
     this._start = (opts?.start as number) ?? 0;
     this._end = (opts?.end as number) ?? Infinity;
     this._pos = this._start;
+  }
 
-    // Validate file existence eagerly (like Node.js) to emit error event
-    Promise.resolve().then(() => {
-      if (!this._inputStream && !this.destroyed) {
-        try {
-          this._inputStream = this._gioFile.read(null);
-          this.pending = false;
-          this.emit('open', 0);
-          this.emit('ready');
-          if (this._start > 0 && this._inputStream.can_seek()) {
-            this._inputStream.seek(this._start, GLib.SeekType.SET, null);
-          }
-        } catch (err) {
-          this.destroy(err as Error);
+  // Use _construct() for async file opening so the stream machinery defers
+  // _read() until the file is open. This avoids the fragile _pendingReadSize
+  // pattern and correctly handles backpressure via the constructed flag.
+  override _construct(callback: (err?: Error | null) => void): void {
+    this._gioFile.read_async(GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+      if (this.destroyed) { callback(); return; }
+      try {
+        this._inputStream = this._gioFile.read_finish(asyncResult);
+        this.pending = false;
+        this.emit('open', 0);
+        this.emit('ready');
+        if (this._start > 0 && this._inputStream!.can_seek()) {
+          this._inputStream!.seek(this._start, GLib.SeekType.SET, null);
+        }
+        callback();
+      } catch (err) {
+        if (!this._cancellable.is_cancelled()) {
+          callback(err as Error);
         }
       }
     });
   }
 
   override _read(size: number): void {
-    // Stream is opened eagerly in constructor; if not yet ready, wait
-    if (!this._inputStream) {
-      if (this.destroyed) return;
-      // Retry on next tick (constructor's async open hasn't completed yet)
-      Promise.resolve().then(() => this._read(size));
-      return;
-    }
+    this._doRead(size);
+  }
 
-    // Calculate how many bytes to read
+  private _doRead(size: number): void {
     let toRead = size;
     if (this._end !== Infinity) {
       const remaining = this._end - this._pos + 1;
@@ -87,27 +88,32 @@ export class ReadStream extends Readable implements IReadStream {
       toRead = Math.min(size, remaining);
     }
 
-    try {
-      const gbytes = this._inputStream!.read_bytes(toRead, null);
-      const data = gbytes.get_data();
+    const stream = this._inputStream!;
+    stream.read_bytes_async(toRead, GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+      try {
+        const gbytes = stream.read_bytes_finish(asyncResult);
+        const data = gbytes.get_data();
 
-      if (!data || data.length === 0) {
-        // EOF
-        this.push(null);
-        return;
-      }
+        if (!data || data.length === 0) {
+          this.push(null);
+          return;
+        }
 
-      this.bytesRead += data.length;
-      this._pos += data.length;
-      this.push(Buffer.from(data));
-    } catch (err) {
-      this.destroy(err as Error);
-    }
+        this.bytesRead += data.length;
+        this._pos += data.length;
+        this.push(Buffer.from(data));
+      } catch (err) {
+        if (!this._cancellable.is_cancelled()) {
+          this.destroy(err as Error);
+        }
+      }
+    });
   }
 
   override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
+    this._cancellable.cancel();
     if (this._inputStream) {
-      try { this._inputStream.close(null); } catch {}
+      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
       this._inputStream = null;
     }
     callback(error);

package/src/stat-watcher.ts

@@ -0,0 +1,116 @@
+// Reference: Node.js lib/internal/fs/watchers.js (StatWatcher)
+// Reimplemented for GJS using setInterval polling
+
+import { EventEmitter } from 'node:events';
+import { statSync } from './sync.js';
+
+import type { PathLike, Stats } from 'node:fs';
+
+function zeroedStat(): Stats {
+  return {
+    dev: 0, ino: 0, mode: 0, nlink: 0, uid: 0, gid: 0, rdev: 0,
+    size: 0, blksize: 0, blocks: 0,
+    atimeMs: 0, mtimeMs: 0, ctimeMs: 0, birthtimeMs: 0,
+    atime: new Date(0), mtime: new Date(0), ctime: new Date(0), birthtime: new Date(0),
+    isFile: () => false, isDirectory: () => false, isBlockDevice: () => false,
+    isCharacterDevice: () => false, isSymbolicLink: () => false, isFIFO: () => false,
+    isSocket: () => false,
+  } as unknown as Stats;
+}
+
+export class StatWatcher extends EventEmitter {
+  private _path: string;
+  private _interval: number;
+  private _timerId: ReturnType<typeof setInterval> | null = null;
+  private _prev: Stats;
+  private _changeCount = 0;
+
+  constructor(path: string, interval: number) {
+    super();
+    this._path = path;
+    this._interval = interval;
+    this._prev = zeroedStat();
+  }
+
+  start(): void {
+    try { this._prev = statSync(this._path) as unknown as Stats; } catch {}
+    this._timerId = setInterval(() => {
+      let curr: Stats;
+      try { curr = statSync(this._path) as unknown as Stats; } catch { curr = zeroedStat(); }
+      const prev = this._prev;
+      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size || curr.ino !== prev.ino) {
+        this._prev = curr;
+        this.emit('change', curr, prev);
+      }
+    }, this._interval);
+  }
+
+  stop(): void {
+    if (this._timerId !== null) {
+      clearInterval(this._timerId);
+      this._timerId = null;
+    }
+    this.emit('stop');
+  }
+
+  addChangeListener(listener: (curr: Stats, prev: Stats) => void): void {
+    this._changeCount++;
+    this.on('change', listener);
+  }
+
+  removeChangeListener(listener: (curr: Stats, prev: Stats) => void): void {
+    this._changeCount--;
+    this.removeListener('change', listener);
+  }
+
+  removeAllChangeListeners(): void {
+    this._changeCount = 0;
+    this.removeAllListeners('change');
+  }
+
+  get changeListenerCount(): number {
+    return this._changeCount;
+  }
+}
+
+const statWatchers = new Map<string, StatWatcher>();
+
+export function watchFile(
+  filename: PathLike,
+  options: { persistent?: boolean; interval?: number } | ((curr: Stats, prev: Stats) => void),
+  listener?: (curr: Stats, prev: Stats) => void,
+): StatWatcher {
+  if (typeof options === 'function') {
+    listener = options;
+    options = {};
+  }
+  const interval = (options as { interval?: number }).interval ?? 5007;
+  const resolved = filename.toString();
+
+  let watcher = statWatchers.get(resolved);
+  if (!watcher) {
+    watcher = new StatWatcher(resolved, interval);
+    watcher.start();
+    statWatchers.set(resolved, watcher);
+  }
+  if (listener) watcher.addChangeListener(listener);
+  return watcher;
+}
+
+export function unwatchFile(
+  filename: PathLike,
+  listener?: (curr: Stats, prev: Stats) => void,
+): void {
+  const resolved = filename.toString();
+  const watcher = statWatchers.get(resolved);
+  if (!watcher) return;
+  if (listener) {
+    watcher.removeChangeListener(listener);
+  } else {
+    watcher.removeAllChangeListeners();
+  }
+  if (watcher.changeListenerCount === 0) {
+    watcher.stop();
+    statWatchers.delete(resolved);
+  }
+}

package/src/statfs.spec.ts

@@ -0,0 +1,67 @@
+// Ported from refs/node-test/parallel/test-fs-statfs.js (behavior)
+// Original: MIT, Node.js contributors.
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+
+import { describe, it, expect } from '@gjsify/unit';
+import { statfsSync, statfs, promises } from 'node:fs';
+import { tmpdir } from 'node:os';
+
+const TMP = tmpdir();
+
+export default async () => {
+  await describe('fs.statfs / fs.promises.statfs', async () => {
+    await it('statfsSync returns object with expected shape', async () => {
+      const result = statfsSync(TMP);
+      expect(typeof result.type).toBe('number');
+      expect(typeof result.bsize).toBe('number');
+      expect(typeof result.blocks).toBe('number');
+      expect(typeof result.bfree).toBe('number');
+      expect(typeof result.bavail).toBe('number');
+      expect(typeof result.files).toBe('number');
+      expect(typeof result.ffree).toBe('number');
+    });
+
+    await it('statfsSync returns plausible values', async () => {
+      const result = statfsSync(TMP);
+      expect(result.bsize).toBe(4096);
+      expect(result.blocks).toBeGreaterThan(0);
+      expect(result.bfree).toBeGreaterThanOrEqual(0);
+      expect(result.bavail).toBeGreaterThanOrEqual(0);
+    });
+
+    await it('statfs callback form returns same shape', async () => {
+      const result = await new Promise<any>((resolve, reject) => {
+        statfs(TMP, (err, stats) => {
+          if (err) reject(err);
+          else resolve(stats);
+        });
+      });
+      expect(typeof result.type).toBe('number');
+      expect(typeof result.bsize).toBe('number');
+      expect(result.bsize).toBe(4096);
+      expect(result.blocks).toBeGreaterThan(0);
+    });
+
+    await it('promises.statfs returns same shape', async () => {
+      const result = await promises.statfs(TMP);
+      expect(typeof result.type).toBe('number');
+      expect(typeof result.bsize).toBe('number');
+      expect(result.bsize).toBe(4096);
+      expect(result.blocks).toBeGreaterThan(0);
+    });
+
+    await it('statfsSync with bigint:true returns bigint fields', async () => {
+      const result = statfsSync(TMP, { bigint: true });
+      expect(typeof result.type).toBe('bigint');
+      expect(typeof result.bsize).toBe('bigint');
+      expect(typeof result.blocks).toBe('bigint');
+      expect(typeof result.bfree).toBe('bigint');
+      expect(result.bsize).toBe(4096n);
+      expect(result.blocks > 0n).toBe(true);
+    });
+
+    await it('statfsSync throws on non-existent path', async () => {
+      expect(() => statfsSync('/nonexistent-gjsify-test-path-xyz')).toThrow();
+    });
+  });
+};