@gjsify/fs 0.0.4 → 0.1.1

package/src/read-stream.ts

@@ -1,92 +1,116 @@
-// Credits https://github.com/denoland/deno_std/blob/main/node/_fs/_fs_streams.ts
+// SPDX-License-Identifier: MIT
+// Adapted from Deno (refs/deno/ext/node/polyfills/_fs/_fs_streams.ts)
+// Copyright (c) 2018-2026 the Deno authors. MIT license.
+// Modifications: Rewritten to use Gio.File / Gio.FileInputStream for GJS
+import Gio from '@girs/gio-2.0';
 import GLib from '@girs/glib-2.0';
-import { notImplemented } from "@gjsify/utils";
-import { Buffer } from "buffer";
-import { Readable } from "stream";
-import { URL } from "url";
+import { Buffer } from "node:buffer";
+import { Readable } from "node:stream";
+import { URL, fileURLToPath } from "node:url";
 
-import type { CreateReadStreamOptions } from 'fs/promises'; // Types from @types/node
-import type { PathLike, ReadStream as IReadStream } from 'fs'; // Types from @types/node
-
-/**
- * Converts a file URL to a path string.
- *
- * ```ts
- *      import { fromFileUrl } from "./posix.ts";
- *      fromFileUrl("file:///home/foo"); // "/home/foo"
- * ```
- * @param url of a file URL
- * @credits https://github.com/denoland/deno_std/blob/44d05e7a8d445888d989d49eb3e59eee3055f2c5/node/path/posix.ts#L486
- */
-export function fromFileUrl(url: string | URL): string {
-  url = url instanceof URL ? url : new URL(url);
-  if (url.protocol != "file:") {
-    throw new TypeError("Must be a file URL.");
-  }
-  return decodeURIComponent(
-    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
-  );
-}
+import type { CreateReadStreamOptions } from 'node:fs/promises';
+import type { PathLike, ReadStream as IReadStream } from 'node:fs';
 
 export class ReadStream extends Readable implements IReadStream {
+  bytesRead = 0;
+  path: string | Buffer;
+  pending = true;
+  fd: number | null = null;
+
+  private _gioFile: Gio.File;
+  private _inputStream: Gio.FileInputStream | null = null;
+  private _start: number;
+  private _end: number;
+  private _pos: number;
+
   close(callback?: (err?: NodeJS.ErrnoException | null) => void): void {
-    // TODO
-    callback(notImplemented('ReadStream.close'));
+    if (this._inputStream) {
+      try { this._inputStream.close(null); } catch {}
+      this._inputStream = null;
+    }
+    this.destroy();
+    if (callback) callback(null);
   }
-  /**
-   * The number of bytes that have been read so far.
-   * @since v6.4.0
-   */
-  bytesRead: number;
-  /**
-   * The path to the file the stream is reading from as specified in the first
-   * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
-   * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
-   * @since v0.1.93
-   */
-  path: string | Buffer;
-  /**
-   * This property is `true` if the underlying file has not been opened yet,
-   * i.e. before the `'ready'` event is emitted.
-   * @since v11.2.0, v10.16.0
-   */
-  pending: boolean;
 
   constructor(path: PathLike, opts?: CreateReadStreamOptions) {
-    path = path instanceof URL ? fromFileUrl(path) : path;
-    const hasBadOptions = opts && (
-      opts.start || opts.end
-    );
-    if (hasBadOptions) {
-      notImplemented(
-        `fs.ReadStream.prototype.constructor with unsupported options (${
-          JSON.stringify(opts)
-        })`,
-      );
+    if (path instanceof URL) {
+      path = fileURLToPath(path);
     }
-    const file = GLib.IOChannel.new_file(path.toString(), "r")
-    const buffer = "";
+
     super({
-      autoDestroy: true,
-      emitClose: true,
+      highWaterMark: opts?.highWaterMark ?? 64 * 1024,
+      encoding: opts?.encoding as BufferEncoding | undefined,
       objectMode: false,
-      read: async function (_size) {
+    });
+
+    this.path = path.toString();
+    this._gioFile = Gio.File.new_for_path(this.path.toString());
+    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 {
-          let n = 0
-          file.read(buffer, 16 * 1024, n);
-          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
+          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);
         }
-      },
-      destroy: (err, cb) => {
-        try {
-          file.close();
-        } catch {}
-        cb(err);
-      },
+      }
     });
-    this.path = path.toString();
+  }
+
+  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;
+    }
+
+    // Calculate how many bytes to read
+    let toRead = size;
+    if (this._end !== Infinity) {
+      const remaining = this._end - this._pos + 1;
+      if (remaining <= 0) {
+        this.push(null);
+        return;
+      }
+      toRead = Math.min(size, remaining);
+    }
+
+    try {
+      const gbytes = this._inputStream!.read_bytes(toRead, null);
+      const data = gbytes.get_data();
+
+      if (!data || data.length === 0) {
+        // EOF
+        this.push(null);
+        return;
+      }
+
+      this.bytesRead += data.length;
+      this._pos += data.length;
+      this.push(Buffer.from(data));
+    } catch (err) {
+      this.destroy(err as Error);
+    }
+  }
+
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
+    if (this._inputStream) {
+      try { this._inputStream.close(null); } catch {}
+      this._inputStream = null;
+    }
+    callback(error);
   }
 }
 
@@ -95,4 +119,4 @@ export function createReadStream(
   options?: CreateReadStreamOptions,
 ): ReadStream {
   return new ReadStream(path, options);
-}
+}

package/src/stat.spec.ts

@@ -1,19 +1,18 @@
 import { describe, it, expect } from '@gjsify/unit';
-// import { join, dirname } from 'path';
-// import { fileURLToPath } from "url";
-
-// const __filename = fileURLToPath(import.meta.url)
-// const __dirname = dirname(__filename)
-
-import { statSync } from 'fs';
-import { stat } from 'fs/promises';
+import { statSync, mkdtempSync, writeFileSync, rmSync, rmdirSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 
 export default async () => {
 	await describe('fs.statSync', async () => {
 
 		await it('Should return the file stat', async () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-stat-'));
+			const filePath = join(dir, 'test.txt');
+			writeFileSync(filePath, 'stat test data');
 
-            const s = statSync('tsconfig.json');
+            const s = statSync(filePath);
 
             expect(s.atime instanceof Date).toBeTruthy();
             expect(s.atimeMs).toBeGreaterThan(0);
@@ -24,7 +23,7 @@ export default async () => {
             expect(s.ctime instanceof Date).toBeTruthy();
             expect(s.ctimeMs).toBeGreaterThan(0);
             expect(s.dev).toBeGreaterThan(0);
-            expect(s.gid).toBeGreaterThan(0);
+            expect(s.gid).toBeGreaterThan(-1);
             expect(s.ino).toBeGreaterThan(0);
             expect(s.mode).toBeGreaterThan(0);
             expect(s.mtime instanceof Date).toBeTruthy();
@@ -32,7 +31,7 @@ export default async () => {
             expect(s.nlink).toBeGreaterThan(0);
             expect(s.rdev).toBeGreaterThan(-1);
             expect(s.size).toBeGreaterThan(0);
-            expect(s.uid).toBeGreaterThan(0);
+            expect(s.uid).toBeGreaterThan(-1);
             expect(s.isBlockDevice()).toBeFalsy();
             expect(s.isCharacterDevice()).toBeFalsy();
             expect(s.isDirectory()).toBeFalsy();
@@ -40,14 +39,20 @@ export default async () => {
             expect(s.isFile()).toBeTruthy();
             expect(s.isSocket()).toBeFalsy();
             expect(s.isSymbolicLink()).toBeFalsy();
+
+			rmSync(filePath);
+			rmdirSync(dir);
 		});
 	});
 
 	await describe('fs.stat (promise)', async () => {
 
 		await it('Should return the file stat', async () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-pstat-'));
+			const filePath = join(dir, 'test.txt');
+			writeFileSync(filePath, 'stat test data');
 
-            const s = await stat('tsconfig.json');
+            const s = await stat(filePath);
 
             expect(s.atime instanceof Date).toBeTruthy();
             expect(s.atimeMs).toBeGreaterThan(0);
@@ -58,7 +63,7 @@ export default async () => {
             expect(s.ctime instanceof Date).toBeTruthy();
             expect(s.ctimeMs).toBeGreaterThan(0);
             expect(s.dev).toBeGreaterThan(0);
-            expect(s.gid).toBeGreaterThan(0);
+            expect(s.gid).toBeGreaterThan(-1);
             expect(s.ino).toBeGreaterThan(0);
             expect(s.mode).toBeGreaterThan(0);
             expect(s.mtime instanceof Date).toBeTruthy();
@@ -66,7 +71,7 @@ export default async () => {
             expect(s.nlink).toBeGreaterThan(0);
             expect(s.rdev).toBeGreaterThan(-1);
             expect(s.size).toBeGreaterThan(0);
-            expect(s.uid).toBeGreaterThan(0);
+            expect(s.uid).toBeGreaterThan(-1);
             expect(s.isBlockDevice()).toBeFalsy();
             expect(s.isCharacterDevice()).toBeFalsy();
             expect(s.isDirectory()).toBeFalsy();
@@ -74,6 +79,9 @@ export default async () => {
             expect(s.isFile()).toBeTruthy();
             expect(s.isSocket()).toBeFalsy();
             expect(s.isSymbolicLink()).toBeFalsy();
+
+			rmSync(filePath);
+			rmdirSync(dir);
 		});
 	});
 }

package/src/stats.ts

@@ -1,67 +1,54 @@
+// Reference: Node.js lib/internal/fs/utils.js (Stats class)
+// Reimplemented for GJS using Gio.FileInfo attributes
+
 import Gio from '@girs/gio-2.0';
 import { Dirent } from './dirent.js';
-import { basename } from 'path';
+import { basename } from 'node:path';
+
+import type { Stats as NodeStats, BigIntStats as NodeBigIntStats, PathLike } from 'node:fs';
+
+// Query all attributes needed for a full Node.js Stats object
+export const STAT_ATTRIBUTES = 'standard::*,time::*,unix::*';
 
-import type { Stats as NodeStats, PathLike } from 'fs';
+function populateFromInfo(info: Gio.FileInfo) {
+    const atimeSec = info.get_attribute_uint64('time::access');
+    const atimeUsec = info.get_attribute_uint32('time::access-usec') || 0;
+    const mtimeSec = info.get_attribute_uint64('time::modified');
+    const mtimeUsec = info.get_attribute_uint32('time::modified-usec') || 0;
+    const ctimeSec = info.get_attribute_uint64('time::changed');
+    const ctimeUsec = info.get_attribute_uint32('time::changed-usec') || 0;
+    const createdSec = info.get_attribute_uint64('time::created');
+    const createdUsec = info.get_attribute_uint32('time::created-usec') || 0;
+
+    const atimeMs = atimeSec * 1000 + atimeUsec / 1000;
+    const mtimeMs = mtimeSec * 1000 + mtimeUsec / 1000;
+    const ctimeMs = ctimeSec ? ctimeSec * 1000 + ctimeUsec / 1000 : mtimeMs;
+    const birthtimeMs = createdSec ? createdSec * 1000 + createdUsec / 1000 : ctimeMs;
+
+    return {
+        dev: info.get_attribute_uint32('unix::device') || 0,
+        ino: Number(info.get_attribute_uint64('unix::inode') || 0),
+        mode: info.get_attribute_uint32('unix::mode') || 0,
+        nlink: info.get_attribute_uint32('unix::nlink') || 0,
+        uid: info.get_attribute_uint32('unix::uid') || 0,
+        gid: info.get_attribute_uint32('unix::gid') || 0,
+        rdev: info.get_attribute_uint32('unix::rdev') || 0,
+        size: Number(info.get_size() || 0),
+        blksize: info.get_attribute_uint32('unix::block-size') || 4096,
+        blocks: Number(info.get_attribute_uint64('unix::blocks') || 0),
+        atimeMs,
+        mtimeMs,
+        ctimeMs,
+        birthtimeMs,
+        atime: new Date(atimeMs),
+        mtime: new Date(mtimeMs),
+        ctime: new Date(ctimeMs),
+        birthtime: new Date(birthtimeMs),
+    };
+}
 
 /**
  * A `fs.Stats` object provides information about a file.
- *
- * Objects returned from {@link stat}, {@link lstat} and {@link fstat} and
- * their synchronous counterparts are of this type.
- * If `bigint` in the `options` passed to those methods is true, the numeric values
- * will be `bigint` instead of `number`, and the object will contain additional
- * nanosecond-precision properties suffixed with `Ns`.
- *
- * ```console
- * Stats {
- *   dev: 2114,
- *   ino: 48064969,
- *   mode: 33188,
- *   nlink: 1,
- *   uid: 85,
- *   gid: 100,
- *   rdev: 0,
- *   size: 527,
- *   blksize: 4096,
- *   blocks: 8,
- *   atimeMs: 1318289051000.1,
- *   mtimeMs: 1318289051000.1,
- *   ctimeMs: 1318289051000.1,
- *   birthtimeMs: 1318289051000.1,
- *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
- * ```
- *
- * `bigint` version:
- *
- * ```console
- * BigIntStats {
- *   dev: 2114n,
- *   ino: 48064969n,
- *   mode: 33188n,
- *   nlink: 1n,
- *   uid: 85n,
- *   gid: 100n,
- *   rdev: 0n,
- *   size: 527n,
- *   blksize: 4096n,
- *   blocks: 8n,
- *   atimeMs: 1318289051000n,
- *   mtimeMs: 1318289051000n,
- *   ctimeMs: 1318289051000n,
- *   birthtimeMs: 1318289051000n,
- *   atimeNs: 1318289051000000000n,
- *   mtimeNs: 1318289051000000000n,
- *   ctimeNs: 1318289051000000000n,
- *   birthtimeNs: 1318289051000000000n,
- *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
- *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
- * ```
  * @since v0.1.21
  */
 export class Stats extends Dirent implements NodeStats {
@@ -78,29 +65,143 @@ export class Stats extends Dirent implements NodeStats {
     atimeMs: number;
     mtimeMs: number;
     ctimeMs: number;
-    /** The timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. */
-    get birthtimeMs(): number {
-        const creationDateTime = this._info.get_creation_date_time();
-        return creationDateTime.get_microsecond() * 1000;
-    }
+    birthtimeMs: number;
     atime: Date;
     mtime: Date;
     ctime: Date;
-    /** The timestamp indicating the creation time of this file. */
-    get birthtime(): Date {
-        const creationDateTime = this._info.get_creation_date_time();
-        return new Date(creationDateTime.format_iso8601());
+    birthtime: Date;
+
+    protected _info: Gio.FileInfo;
+
+    /**
+     * Create Stats from a pre-queried FileInfo, or from a path.
+     * @param infoOrPath - A Gio.FileInfo or a file path
+     * @param pathOrFilename - The file path (when first arg is FileInfo) or filename
+     * @param filename - Optional filename (when first arg is FileInfo)
+     */
+    constructor(info: Gio.FileInfo, path: PathLike, filename?: string);
+    constructor(path: PathLike, filename?: string);
+    constructor(
+        infoOrPath: Gio.FileInfo | PathLike,
+        pathOrFilename?: PathLike | string,
+        filename?: string
+    ) {
+        let info: Gio.FileInfo;
+        let pathStr: string;
+
+        if (infoOrPath instanceof Gio.FileInfo) {
+            info = infoOrPath;
+            pathStr = (pathOrFilename as PathLike).toString();
+            if (!filename) filename = basename(pathStr);
+        } else {
+            pathStr = infoOrPath.toString();
+            if (typeof pathOrFilename === 'string') filename = pathOrFilename;
+            if (!filename) filename = basename(pathStr);
+            const file = Gio.File.new_for_path(pathStr);
+            info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+        }
+
+        super(pathStr, filename, info.get_file_type());
+        this._info = info;
+
+        const data = populateFromInfo(info);
+        this.dev = data.dev;
+        this.ino = data.ino;
+        this.mode = data.mode;
+        this.nlink = data.nlink;
+        this.uid = data.uid;
+        this.gid = data.gid;
+        this.rdev = data.rdev;
+        this.size = data.size;
+        this.blksize = data.blksize;
+        this.blocks = data.blocks;
+        this.atimeMs = data.atimeMs;
+        this.mtimeMs = data.mtimeMs;
+        this.ctimeMs = data.ctimeMs;
+        this.birthtimeMs = data.birthtimeMs;
+        this.atime = data.atime;
+        this.mtime = data.mtime;
+        this.ctime = data.ctime;
+        this.birthtime = data.birthtime;
     }
+}
+
+/**
+ * BigIntStats — same as Stats but with bigint fields and nanosecond precision.
+ */
+export class BigIntStats extends Dirent implements NodeBigIntStats {
+    dev: bigint;
+    ino: bigint;
+    mode: bigint;
+    nlink: bigint;
+    uid: bigint;
+    gid: bigint;
+    rdev: bigint;
+    size: bigint;
+    blksize: bigint;
+    blocks: bigint;
+    atimeMs: bigint;
+    mtimeMs: bigint;
+    ctimeMs: bigint;
+    birthtimeMs: bigint;
+    atimeNs: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+    birthtimeNs: bigint;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
 
     protected _info: Gio.FileInfo;
 
-    constructor(path: PathLike, filename?: string) {
-        const pathStr = path.toString();
-        if (!filename) filename = basename(pathStr);
-        super(pathStr, filename);
-        if(!this._file) {
-            throw new TypeError('this._file is not defined!');
+    constructor(info: Gio.FileInfo, path: PathLike, filename?: string);
+    constructor(path: PathLike, filename?: string);
+    constructor(
+        infoOrPath: Gio.FileInfo | PathLike,
+        pathOrFilename?: PathLike | string,
+        filename?: string
+    ) {
+        let info: Gio.FileInfo;
+        let pathStr: string;
+
+        if (infoOrPath instanceof Gio.FileInfo) {
+            info = infoOrPath;
+            pathStr = (pathOrFilename as PathLike).toString();
+            if (!filename) filename = basename(pathStr);
+        } else {
+            pathStr = infoOrPath.toString();
+            if (typeof pathOrFilename === 'string') filename = pathOrFilename;
+            if (!filename) filename = basename(pathStr);
+            const file = Gio.File.new_for_path(pathStr);
+            info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
         }
-        this._info = this._file.query_info('standard::', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+
+        super(pathStr, filename, info.get_file_type());
+        this._info = info;
+
+        const data = populateFromInfo(info);
+        this.dev = BigInt(data.dev);
+        this.ino = BigInt(data.ino);
+        this.mode = BigInt(data.mode);
+        this.nlink = BigInt(data.nlink);
+        this.uid = BigInt(data.uid);
+        this.gid = BigInt(data.gid);
+        this.rdev = BigInt(data.rdev);
+        this.size = BigInt(data.size);
+        this.blksize = BigInt(data.blksize);
+        this.blocks = BigInt(data.blocks);
+        this.atimeMs = BigInt(Math.trunc(data.atimeMs));
+        this.mtimeMs = BigInt(Math.trunc(data.mtimeMs));
+        this.ctimeMs = BigInt(Math.trunc(data.ctimeMs));
+        this.birthtimeMs = BigInt(Math.trunc(data.birthtimeMs));
+        this.atimeNs = this.atimeMs * 1000000n;
+        this.mtimeNs = this.mtimeMs * 1000000n;
+        this.ctimeNs = this.ctimeMs * 1000000n;
+        this.birthtimeNs = this.birthtimeMs * 1000000n;
+        this.atime = data.atime;
+        this.mtime = data.mtime;
+        this.ctime = data.ctime;
+        this.birthtime = data.birthtime;
     }
-}
+}