@gjsify/fs 0.3.21 → 0.4.3

package/src/fd-ops.spec.ts

@@ -1,234 +0,0 @@
-// Ported from refs/node-test/parallel/test-fs-read-sync.js + test-fs-write-sync.js (behavior)
-// Original: MIT, Node.js contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  openSync, closeSync,
-  fstatSync, fstat,
-  ftruncateSync,
-  fdatasync, fsync,
-  fchmodSync,
-  readSync, writeSync,
-  readv, writev,
-  exists,
-  openAsBlob,
-  promises,
-  writeFileSync, unlinkSync, readFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const TMP = tmpdir();
-
-function tmpFile(name: string, content = 'hello world'): string {
-  const p = join(TMP, `gjsify-fdops-${name}-${process.pid}`);
-  writeFileSync(p, content);
-  return p;
-}
-
-export default async () => {
-  await describe('fs fd-based operations', async () => {
-    await it('fstatSync returns Stats with correct size', async () => {
-      const f = tmpFile('fstat', 'hello');
-      const fd = openSync(f, 'r');
-      try {
-        const st = fstatSync(fd);
-        expect(st.size).toBe(5);
-        expect(typeof st.mtime).toBe('object');
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('fstat callback returns Stats', async () => {
-      const f = tmpFile('fstat-cb', 'world');
-      const fd = openSync(f, 'r');
-      try {
-        const st = await new Promise<any>((resolve, reject) => {
-          fstat(fd, (err, s) => err ? reject(err) : resolve(s));
-        });
-        expect(st.size).toBe(5);
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('promises.fstat returns Stats', async () => {
-      const f = tmpFile('fstat-p', 'gjsify');
-      const fh = await promises.open(f, 'r');
-      try {
-        const st = await fh.stat();
-        expect(st.size).toBe(6);
-      } finally {
-        await fh.close();
-        unlinkSync(f);
-      }
-    });
-
-    await it('ftruncateSync truncates file', async () => {
-      const f = tmpFile('ftrunc', '0123456789');
-      const fd = openSync(f, 'r+');
-      try {
-        ftruncateSync(fd, 4);
-        const data = readFileSync(f, 'utf8');
-        expect(data).toBe('0123');
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('fdatasync callback completes without error', async () => {
-      const f = tmpFile('fdatasync', 'data');
-      const fd = openSync(f, 'r+');
-      try {
-        await new Promise<void>((resolve, reject) => {
-          fdatasync(fd, (err) => err ? reject(err) : resolve());
-        });
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('fsync callback completes without error', async () => {
-      const f = tmpFile('fsync', 'data');
-      const fd = openSync(f, 'r+');
-      try {
-        await new Promise<void>((resolve, reject) => {
-          fsync(fd, (err) => err ? reject(err) : resolve());
-        });
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('fchmodSync changes file permissions', async () => {
-      const f = tmpFile('fchmod', 'x');
-      const fd = openSync(f, 'r');
-      try {
-        fchmodSync(fd, 0o600);
-        const st = fstatSync(fd);
-        expect(st.mode & 0o777).toBe(0o600);
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('closeSync closes the fd', async () => {
-      const f = tmpFile('close', 'c');
-      const fd = openSync(f, 'r');
-      closeSync(fd);
-      expect(() => fstatSync(fd)).toThrow();
-      unlinkSync(f);
-    });
-
-    await it('readSync reads bytes from position 0', async () => {
-      const f = tmpFile('rsync', 'abcdef');
-      const fd = openSync(f, 'r');
-      try {
-        const buf = Buffer.alloc(3);
-        const n = readSync(fd, buf, 0, 3, 0);
-        expect(n).toBe(3);
-        expect(buf.toString()).toBe('abc');
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('readSync reads into buffer at offset', async () => {
-      const f = tmpFile('rsync-off', 'hello');
-      const fd = openSync(f, 'r');
-      try {
-        const buf = Buffer.alloc(8);
-        const n = readSync(fd, buf, 2, 5, 0);
-        expect(n).toBe(5);
-        expect(buf.slice(2, 7).toString()).toBe('hello');
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('writeSync writes bytes to file', async () => {
-      const f = tmpFile('wsync', '-----');
-      const fd = openSync(f, 'r+');
-      try {
-        const n = writeSync(fd, Buffer.from('XYZ'), 0, 3, 0);
-        expect(n).toBe(3);
-        closeSync(fd);
-        expect(readFileSync(f, 'utf8').slice(0, 3)).toBe('XYZ');
-      } finally {
-        unlinkSync(f);
-      }
-    });
-
-    await it('readv reads into multiple buffers', async () => {
-      const f = tmpFile('readv', 'abcdef');
-      const fd = openSync(f, 'r');
-      try {
-        const b1 = Buffer.alloc(2);
-        const b2 = Buffer.alloc(3);
-        await new Promise<void>((resolve, reject) => {
-          readv(fd, [b1, b2], 0, (err, bytesRead) => {
-            if (err) return reject(err);
-            expect(bytesRead).toBe(5);
-            expect(b1.toString()).toBe('ab');
-            expect(b2.toString()).toBe('cde');
-            resolve();
-          });
-        });
-      } finally {
-        closeSync(fd);
-        unlinkSync(f);
-      }
-    });
-
-    await it('writev writes multiple buffers', async () => {
-      const f = tmpFile('writev', '------');
-      const fd = openSync(f, 'r+');
-      try {
-        const b1 = Buffer.from('AB');
-        const b2 = Buffer.from('CDE');
-        await new Promise<void>((resolve, reject) => {
-          writev(fd, [b1, b2], 0, (err, bytesWritten) => {
-            if (err) return reject(err);
-            expect(bytesWritten).toBe(5);
-            resolve();
-          });
-        });
-        closeSync(fd);
-        expect(readFileSync(f, 'utf8').slice(0, 5)).toBe('ABCDE');
-      } finally {
-        unlinkSync(f);
-      }
-    });
-
-    await it('exists returns true for existing path, false for missing', async () => {
-      const f = tmpFile('exists', 'e');
-      const existing = await new Promise<boolean>((resolve) => {
-        exists(f, (v) => resolve(v));
-      });
-      expect(existing).toBe(true);
-      const missing = await new Promise<boolean>((resolve) => {
-        exists(join(TMP, 'gjsify-nonexistent-xyz-123'), (v) => resolve(v));
-      });
-      expect(missing).toBe(false);
-      unlinkSync(f);
-    });
-
-    await it('openAsBlob returns Blob with correct size', async () => {
-      const f = tmpFile('blob', 'blobdata');
-      const blob = await openAsBlob(f);
-      expect(blob.size).toBe(8);
-      expect(blob instanceof Blob).toBe(true);
-      unlinkSync(f);
-    });
-  });
-};

package/src/fd-ops.ts

@@ -1,251 +0,0 @@
-// Reference: Node.js lib/fs.js (fd-based ops, readSync, writeSync, readv, writev, exists, openAsBlob)
-// Reimplemented for GJS using FileHandle + Gio streams
-
-import GLib from '@girs/glib-2.0';
-import Gio from '@girs/gio-2.0';
-import { FileHandle } from './file-handle.js';
-import { Stats, BigIntStats } from './stats.js';
-import { statSync, truncateSync, chmodSync, chownSync, readFileSync } from './sync.js';
-import { utimesSync } from './utimes.js';
-import { normalizePath } from './utils.js';
-
-import type { PathLike, TimeLike, StatOptions } from 'node:fs';
-
-function getFH(fd: number | FileHandle): FileHandle {
-  if (fd instanceof FileHandle) return FileHandle.getInstance(fd.fd);
-  return FileHandle.getInstance(fd as number);
-}
-
-// ─── fstat ────────────────────────────────────────────────────────────────────
-
-export function fstatSync(fd: number, options?: { bigint?: false }): Stats;
-export function fstatSync(fd: number, options: { bigint: true }): BigIntStats;
-export function fstatSync(fd: number, options?: { bigint?: boolean }): Stats | BigIntStats {
-  return statSync(normalizePath(getFH(fd).options.path), options as any);
-}
-
-export function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-export function fstat(fd: number, options: StatOptions, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
-export function fstat(fd: number, optionsOrCb: any, callback?: any): void {
-  if (typeof optionsOrCb === 'function') { callback = optionsOrCb; optionsOrCb = {}; }
-  Promise.resolve()
-    .then(() => fstatSync(fd, optionsOrCb))
-    .then(s => callback(null, s), callback);
-}
-
-export async function fstatAsync(fd: number, options?: StatOptions): Promise<Stats | BigIntStats> {
-  return fstatSync(fd, options as any);
-}
-
-// ─── ftruncate ────────────────────────────────────────────────────────────────
-
-export function ftruncateSync(fd: number, len = 0): void {
-  truncateSync(normalizePath(getFH(fd).options.path), len);
-}
-
-export function ftruncate(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
-export function ftruncate(fd: number, len: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
-export function ftruncate(fd: number, lenOrCb: any, callback?: any): void {
-  if (typeof lenOrCb === 'function') { callback = lenOrCb; lenOrCb = 0; }
-  Promise.resolve()
-    .then(() => ftruncateSync(fd, lenOrCb))
-    .then(() => callback(null), callback);
-}
-
-export async function ftruncateAsync(fd: number, len = 0): Promise<void> {
-  ftruncateSync(fd, len);
-}
-
-// ─── fdatasync / fsync ────────────────────────────────────────────────────────
-// Best-effort: flush the IOChannel write buffer (equivalent to fdatasync on GJS).
-
-export function fdatasyncSync(fd: number): void { getFH(fd)._flushSync(); }
-export function fdatasync(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void {
-  Promise.resolve().then(() => fdatasyncSync(fd)).then(() => callback(null), callback);
-}
-export async function fdatasyncAsync(fd: number): Promise<void> { fdatasyncSync(fd); }
-
-export function fsyncSync(fd: number): void { getFH(fd)._flushSync(); }
-export function fsync(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void {
-  Promise.resolve().then(() => fsyncSync(fd)).then(() => callback(null), callback);
-}
-export async function fsyncAsync(fd: number): Promise<void> { fsyncSync(fd); }
-
-// ─── fchmod / fchown / futimes ────────────────────────────────────────────────
-
-export function fchmodSync(fd: number, mode: number | string): void {
-  chmodSync(normalizePath(getFH(fd).options.path), mode);
-}
-export function fchmod(fd: number, mode: number | string, callback: (err: NodeJS.ErrnoException | null) => void): void {
-  Promise.resolve().then(() => fchmodSync(fd, mode)).then(() => callback(null), callback);
-}
-export async function fchmodAsync(fd: number, mode: number | string): Promise<void> { fchmodSync(fd, mode); }
-
-export function fchownSync(fd: number, uid: number, gid: number): void {
-  chownSync(normalizePath(getFH(fd).options.path), uid, gid);
-}
-export function fchown(fd: number, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void {
-  Promise.resolve().then(() => fchownSync(fd, uid, gid)).then(() => callback(null), callback);
-}
-export async function fchownAsync(fd: number, uid: number, gid: number): Promise<void> { fchownSync(fd, uid, gid); }
-
-export function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void {
-  utimesSync(normalizePath(getFH(fd).options.path), atime, mtime);
-}
-export function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: (err: NodeJS.ErrnoException | null) => void): void {
-  Promise.resolve().then(() => futimesSync(fd, atime, mtime)).then(() => callback(null), callback);
-}
-export async function futimesAsync(fd: number, atime: TimeLike, mtime: TimeLike): Promise<void> { futimesSync(fd, atime, mtime); }
-
-// ─── closeSync ────────────────────────────────────────────────────────────────
-
-export function closeSync(fd: number): void {
-  getFH(fd)._closeSync();
-}
-
-// ─── readSync ─────────────────────────────────────────────────────────────────
-
-export function readSync(
-  fd: number,
-  buffer: NodeJS.ArrayBufferView,
-  offset?: number | null,
-  length?: number | null,
-  position?: number | null,
-): number;
-export function readSync(
-  fd: number,
-  buffer: NodeJS.ArrayBufferView,
-  options: { offset?: number; length?: number; position?: number | null },
-): number;
-export function readSync(
-  fd: number,
-  buffer: NodeJS.ArrayBufferView,
-  offsetOrOptions?: number | null | { offset?: number; length?: number; position?: number | null },
-  length?: number | null,
-  position?: number | null,
-): number {
-  let offset = 0;
-  if (offsetOrOptions !== null && typeof offsetOrOptions === 'object') {
-    offset = (offsetOrOptions as any).offset ?? 0;
-    length = (offsetOrOptions as any).length ?? buffer.byteLength;
-    position = (offsetOrOptions as any).position ?? null;
-  } else {
-    offset = (offsetOrOptions as number | null | undefined) ?? 0;
-    length = length ?? buffer.byteLength - offset;
-  }
-  return getFH(fd)._readSync(buffer, offset, length!, position ?? null);
-}
-
-// ─── writeSync ────────────────────────────────────────────────────────────────
-
-export function writeSync(
-  fd: number,
-  buffer: NodeJS.ArrayBufferView,
-  offset?: number | null,
-  length?: number | null,
-  position?: number | null,
-): number;
-export function writeSync(
-  fd: number,
-  string: string,
-  position?: number | null,
-  encoding?: BufferEncoding | null,
-): number;
-export function writeSync(
-  fd: number,
-  bufferOrString: NodeJS.ArrayBufferView | string,
-  offsetOrPosition?: number | null,
-  lengthOrEncoding?: number | string | null,
-  position?: number | null,
-): number {
-  let data: Uint8Array;
-  if (typeof bufferOrString === 'string') {
-    data = new TextEncoder().encode(bufferOrString);
-    if (typeof offsetOrPosition === 'number') position = offsetOrPosition;
-  } else {
-    const offset = (typeof offsetOrPosition === 'number' ? offsetOrPosition : 0);
-    const len = (typeof lengthOrEncoding === 'number' ? lengthOrEncoding : bufferOrString.byteLength - offset);
-    data = new Uint8Array((bufferOrString as any).buffer, (bufferOrString as any).byteOffset + offset, len);
-  }
-  return getFH(fd)._writeSync(data, position ?? null);
-}
-
-// ─── readvSync / readv ────────────────────────────────────────────────────────
-
-export function readvSync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): number {
-  let bytesRead = 0;
-  for (const buf of buffers) {
-    const n = readSync(fd, buf, 0, buf.byteLength, position != null ? position + bytesRead : null);
-    bytesRead += n;
-    if (n < buf.byteLength) break;
-  }
-  return bytesRead;
-}
-
-export function readv(
-  fd: number,
-  buffers: NodeJS.ArrayBufferView[],
-  callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void,
-): void;
-export function readv(
-  fd: number,
-  buffers: NodeJS.ArrayBufferView[],
-  position: number | null,
-  callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void,
-): void;
-export function readv(fd: number, buffers: NodeJS.ArrayBufferView[], positionOrCb: any, callback?: any): void {
-  if (typeof positionOrCb === 'function') { callback = positionOrCb; positionOrCb = null; }
-  Promise.resolve()
-    .then(() => ({ bytesRead: readvSync(fd, buffers, positionOrCb), buffers }))
-    .then(r => callback(null, r.bytesRead, r.buffers), callback);
-}
-
-export async function readvAsync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null) {
-  return { bytesRead: readvSync(fd, buffers, position), buffers };
-}
-
-// ─── writevSync / writev ──────────────────────────────────────────────────────
-
-export function writevSync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): number {
-  let bytesWritten = 0;
-  for (const buf of buffers) {
-    const n = writeSync(fd, buf, 0, buf.byteLength, position != null ? position + bytesWritten : null);
-    bytesWritten += n;
-  }
-  return bytesWritten;
-}
-
-export function writev(
-  fd: number,
-  buffers: NodeJS.ArrayBufferView[],
-  callback: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void,
-): void;
-export function writev(
-  fd: number,
-  buffers: NodeJS.ArrayBufferView[],
-  position: number | null,
-  callback: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void,
-): void;
-export function writev(fd: number, buffers: NodeJS.ArrayBufferView[], positionOrCb: any, callback?: any): void {
-  if (typeof positionOrCb === 'function') { callback = positionOrCb; positionOrCb = null; }
-  Promise.resolve()
-    .then(() => ({ bytesWritten: writevSync(fd, buffers, positionOrCb), buffers }))
-    .then(r => callback(null, r.bytesWritten, r.buffers), callback);
-}
-
-export async function writevAsync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null) {
-  return { bytesWritten: writevSync(fd, buffers, position), buffers };
-}
-
-// ─── exists (deprecated) ──────────────────────────────────────────────────────
-
-export function exists(path: PathLike, callback: (exists: boolean) => void): void {
-  try { statSync(normalizePath(path)); callback(true); } catch { callback(false); }
-}
-
-// ─── openAsBlob ───────────────────────────────────────────────────────────────
-
-export async function openAsBlob(path: PathLike, options?: { type?: string }): Promise<Blob> {
-  const data = readFileSync(normalizePath(path)) as unknown as ArrayBuffer;
-  return new Blob([data], { type: options?.type ?? '' });
-}

package/src/file-handle.spec.ts

@@ -1,115 +0,0 @@
-// Ported from refs/node-test/parallel/test-fs-promises-file-handle-*.js
-// Original: MIT license, Node.js contributors
-import { describe, it, expect } from '@gjsify/unit';
-import { promises, mkdtempSync, rmdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { Buffer } from 'node:buffer';
-
-export default async () => {
-  await describe('FileHandle', async () => {
-    await it('should open a file for writing and return correct bytesWritten', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-'));
-      const path = join(dir, 'write.txt');
-      const fh = await promises.open(path, 'w+', 0o666);
-      const buf = Buffer.from('Hello World', 'utf8');
-      const res = await fh.write(buf, 0, buf.length, 0);
-      expect(res.bytesWritten).toBe(buf.length);
-      expect(res.buffer).toBe(buf);
-      await fh.close();
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should read back written content via read()', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-read-'));
-      const path = join(dir, 'rw.txt');
-      const fh = await promises.open(path, 'w+');
-      const written = Buffer.from('Read back test');
-      await fh.write(written, 0, written.length, 0);
-
-      const readBuf = Buffer.alloc(written.length);
-      const { bytesRead } = await fh.read(readBuf, 0, written.length, 0);
-      expect(bytesRead).toBe(written.length);
-      expect(readBuf.toString()).toBe('Read back test');
-
-      await fh.close();
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should read entire file via readFile()', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-rf-'));
-      const path = join(dir, 'rf.txt');
-      await promises.writeFile(path, 'FileHandle readFile content');
-      const fh = await promises.open(path, 'r');
-      const content = await fh.readFile({ encoding: 'utf8' });
-      expect(content).toBe('FileHandle readFile content');
-      await fh.close();
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should stat the opened file', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-stat-'));
-      const path = join(dir, 'stat.txt');
-      await promises.writeFile(path, 'stat content');
-      const fh = await promises.open(path, 'r');
-      const s = await fh.stat();
-      expect(s.isFile()).toBe(true);
-      expect(s.size).toBeGreaterThan(0);
-      await fh.close();
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should truncate the file via truncate()', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-trunc-'));
-      const path = join(dir, 'trunc.txt');
-      await promises.writeFile(path, 'Hello World Truncate');
-      const fh = await promises.open(path, 'r+');
-      await fh.truncate(5);
-      await fh.close();
-      const content = await promises.readFile(path, { encoding: 'utf8' });
-      expect(content).toBe('Hello');
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should append content via appendFile()', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-app-'));
-      const path = join(dir, 'append.txt');
-      await promises.writeFile(path, 'start');
-      const fh = await promises.open(path, 'a');
-      await fh.appendFile(' appended');
-      await fh.close();
-      const content = await promises.readFile(path, { encoding: 'utf8' });
-      expect(content).toBe('start appended');
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-
-    await it('should throw when opening a non-existent file for reading', async () => {
-      let threw = false;
-      try {
-        await promises.open('/nonexistent/path/abc123.txt', 'r');
-      } catch (e: unknown) {
-        threw = true;
-        expect((e as NodeJS.ErrnoException).code).toBe('ENOENT');
-      }
-      expect(threw).toBe(true);
-    });
-
-    await it('should writeFile via FileHandle', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-fh-wf-'));
-      const path = join(dir, 'wf.txt');
-      const fh = await promises.open(path, 'w');
-      await fh.writeFile('written via FileHandle.writeFile');
-      await fh.close();
-      const content = await promises.readFile(path, { encoding: 'utf8' });
-      expect(content).toBe('written via FileHandle.writeFile');
-      await promises.rm(path);
-      rmdirSync(dir);
-    });
-  });
-};