@gjsify/fs 0.3.21 → 0.4.3

package/src/dir.spec.ts

@@ -1,204 +0,0 @@
-// Ported from refs/bun/test/js/node/fs/dir.test.ts
-// Original: MIT, Oven & contributors.
-// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
-
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  Dir,
-  opendirSync,
-  opendir,
-  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-dir-'));
-}
-
-export default async () => {
-  await describe('fs.opendirSync', async () => {
-    await it('returns a Dir instance', async () => {
-      const tmp = makeTmp();
-      const dir = opendirSync(tmp);
-      expect(dir).toBeDefined();
-      expect(dir instanceof Dir).toBe(true);
-      dir.closeSync();
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('dir.path reflects the opened path', async () => {
-      const tmp = makeTmp();
-      const dir = opendirSync(tmp);
-      expect(dir.path).toBe(tmp);
-      dir.closeSync();
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('readSync returns null on empty directory', async () => {
-      const tmp = makeTmp();
-      const dir = opendirSync(tmp);
-      const entry = dir.readSync();
-      expect(entry).toBeNull();
-      dir.closeSync();
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('readSync returns Dirent entries for directory contents', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'a.txt'), 'a');
-      writeFileSync(join(tmp, 'b.txt'), 'b');
-
-      const dir = opendirSync(tmp);
-      const names: string[] = [];
-      let entry = dir.readSync();
-      while (entry !== null) {
-        names.push(entry.name);
-        entry = dir.readSync();
-      }
-      dir.closeSync();
-
-      expect(names.sort()).toStrictEqual(['a.txt', 'b.txt']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('Dirent has correct type flags', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'file.txt'), 'x');
-      mkdirSync(join(tmp, 'subdir'));
-
-      const dir = opendirSync(tmp);
-      const entries: { name: string; isFile: boolean; isDirectory: boolean }[] = [];
-      let entry = dir.readSync();
-      while (entry !== null) {
-        entries.push({ name: entry.name, isFile: entry.isFile(), isDirectory: entry.isDirectory() });
-        entry = dir.readSync();
-      }
-      dir.closeSync();
-
-      entries.sort((a, b) => a.name.localeCompare(b.name));
-      expect(entries).toStrictEqual([
-        { name: 'file.txt', isFile: true, isDirectory: false },
-        { name: 'subdir', isFile: false, isDirectory: true },
-      ]);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('closeSync throws after close', async () => {
-      const tmp = makeTmp();
-      const dir = opendirSync(tmp);
-      dir.closeSync();
-
-      let threw = false;
-      try {
-        dir.closeSync();
-      } catch (e: any) {
-        threw = true;
-        expect(e.code).toBe('ERR_DIR_CLOSED');
-      }
-      expect(threw).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('readSync throws after close', async () => {
-      const tmp = makeTmp();
-      const dir = opendirSync(tmp);
-      dir.closeSync();
-
-      let threw = false;
-      try {
-        dir.readSync();
-      } catch (e: any) {
-        threw = true;
-        expect(e.code).toBe('ERR_DIR_CLOSED');
-      }
-      expect(threw).toBe(true);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('read() returns Dirent or null asynchronously', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'hello.txt'), 'hi');
-
-      const dir = opendirSync(tmp);
-      const entry = await dir.read();
-      expect(entry).toBeDefined();
-      expect(entry!.name).toBe('hello.txt');
-
-      const next = await dir.read();
-      expect(next).toBeNull();
-      await dir.close();
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('[Symbol.asyncIterator] iterates all entries', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'x.ts'), '');
-      writeFileSync(join(tmp, 'y.ts'), '');
-
-      const dir = opendirSync(tmp);
-      const names: string[] = [];
-      for await (const entry of dir) {
-        names.push(entry.name);
-      }
-
-      expect(names.sort()).toStrictEqual(['x.ts', 'y.ts']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-
-  await describe('fs.opendir (callback)', async () => {
-    await it('opens directory and returns Dir instance via callback', async () => {
-      const tmp = makeTmp();
-      await new Promise<void>((resolve, reject) => {
-        opendir(tmp, (err, dir) => {
-          if (err) return reject(err);
-          expect(dir instanceof Dir).toBe(true);
-          expect(dir.path).toBe(tmp);
-          dir.closeSync();
-          rmSync(tmp, { recursive: true, force: true });
-          resolve();
-        });
-      });
-    });
-
-    await it('throws if callback is not a function', async () => {
-      let threw = false;
-      try {
-        (opendir as any)('/tmp');
-      } catch (e: any) {
-        threw = true;
-      }
-      expect(threw).toBe(true);
-    });
-  });
-
-  await describe('fs.promises.opendir', async () => {
-    await it('opens directory and returns Dir instance', async () => {
-      const tmp = makeTmp();
-      const dir = await promises.opendir(tmp);
-      expect(dir instanceof Dir).toBe(true);
-      await dir.close();
-      rmSync(tmp, { recursive: true, force: true });
-    });
-
-    await it('async iterates directory entries', async () => {
-      const tmp = makeTmp();
-      writeFileSync(join(tmp, 'alpha.txt'), '');
-      writeFileSync(join(tmp, 'beta.txt'), '');
-
-      const dir = await promises.opendir(tmp);
-      const names: string[] = [];
-      for await (const entry of dir) {
-        names.push(entry.name);
-      }
-
-      expect(names.sort()).toStrictEqual(['alpha.txt', 'beta.txt']);
-      rmSync(tmp, { recursive: true, force: true });
-    });
-  });
-};

package/src/dir.ts

@@ -1,199 +0,0 @@
-// Reference: Node.js lib/internal/fs/dir.js
-// Reimplemented for GJS using Gio.FileEnumerator
-
-import Gio from '@girs/gio-2.0';
-import GLib from '@girs/glib-2.0';
-import { normalizePath } from './utils.js';
-import { Dirent } from './dirent.js';
-import { createNodeError } from './errors.js';
-import type { PathLike } from 'node:fs';
-
-const DIR_ATTRS = 'standard::name,standard::type,standard::is-symlink,standard::size,standard::symlink-target,unix::uid,unix::gid,unix::mode,time::modified,time::access,time::created';
-
-export class Dir {
-  readonly path: string;
-  private _enumerator: Gio.FileEnumerator | null;
-  private _closed = false;
-
-  constructor(path: string, enumerator: Gio.FileEnumerator) {
-    this.path = path;
-    this._enumerator = enumerator;
-  }
-
-  private _assertOpen(): void {
-    if (this._closed) {
-      const err = new Error('Directory handle was closed') as NodeJS.ErrnoException;
-      err.code = 'ERR_DIR_CLOSED';
-      throw err;
-    }
-  }
-
-  readSync(): Dirent | null {
-    this._assertOpen();
-    try {
-      const info = this._enumerator!.next_file(null);
-      if (info === null) return null;
-      const name = info.get_name();
-      const fileType = info.get_file_type();
-      const childPath = this.path.endsWith('/') ? this.path + name : this.path + '/' + name;
-      return new Dirent(childPath, name, fileType);
-    } catch (err: unknown) {
-      throw createNodeError(err, 'readdir', this.path);
-    }
-  }
-
-  read(): Promise<Dirent | null>;
-  read(callback: (err: NodeJS.ErrnoException | null, dirent: Dirent | null) => void): void;
-  read(callback?: (err: NodeJS.ErrnoException | null, dirent: Dirent | null) => void): Promise<Dirent | null> | void {
-    if (callback !== undefined) {
-      if (typeof callback !== 'function') {
-        throw new TypeError('The "callback" argument must be of type function');
-      }
-      try {
-        this._assertOpen();
-        const dirent = this.readSync();
-        Promise.resolve().then(() => callback(null, dirent));
-      } catch (err: unknown) {
-        Promise.resolve().then(() => callback(err as NodeJS.ErrnoException, null));
-      }
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        this._assertOpen();
-        resolve(this.readSync());
-      } catch (err: unknown) {
-        reject(err);
-      }
-    });
-  }
-
-  closeSync(): void {
-    this._assertOpen();
-    this._closed = true;
-    try {
-      this._enumerator!.close(null);
-    } catch {
-      // ignore close errors
-    }
-    this._enumerator = null;
-  }
-
-  close(): Promise<void>;
-  close(callback: (err: NodeJS.ErrnoException | null) => void): void;
-  close(callback?: (err: NodeJS.ErrnoException | null) => void): Promise<void> | void {
-    if (callback !== undefined) {
-      if (typeof callback !== 'function') {
-        throw new TypeError('The "callback" argument must be of type function');
-      }
-      try {
-        this.closeSync();
-        Promise.resolve().then(() => callback(null));
-      } catch (err: unknown) {
-        Promise.resolve().then(() => callback(err as NodeJS.ErrnoException));
-      }
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      try {
-        this.closeSync();
-        resolve();
-      } catch (err: unknown) {
-        reject(err);
-      }
-    });
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
-    try {
-      while (true) {
-        const dirent = await this.read();
-        if (dirent === null) break;
-        yield dirent;
-      }
-    } finally {
-      if (!this._closed) {
-        await this.close();
-      }
-    }
-  }
-}
-
-function _openDir(pathStr: string): Dir {
-  const file = Gio.File.new_for_path(pathStr);
-  let enumerator: Gio.FileEnumerator;
-  try {
-    enumerator = file.enumerate_children(DIR_ATTRS, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-  } catch (err: unknown) {
-    throw createNodeError(err, 'opendir', pathStr);
-  }
-  return new Dir(pathStr, enumerator);
-}
-
-export function opendirSync(path: PathLike): Dir {
-  return _openDir(normalizePath(path));
-}
-
-export function opendir(
-  path: PathLike,
-  callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
-): void;
-export function opendir(
-  path: PathLike,
-  options: { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean },
-  callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
-): void;
-export function opendir(
-  path: PathLike,
-  optionsOrCallback:
-    | { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean }
-    | ((err: NodeJS.ErrnoException | null, dir: Dir) => void),
-  callback?: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
-): void {
-  let cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void;
-  if (typeof optionsOrCallback === 'function') {
-    cb = optionsOrCallback;
-  } else {
-    cb = callback!;
-  }
-
-  if (typeof cb !== 'function') {
-    throw new TypeError('The "callback" argument must be of type function');
-  }
-
-  Promise.resolve().then(() => {
-    try {
-      const dir = opendirSync(path);
-      cb(null, dir);
-    } catch (err: unknown) {
-      cb(err as NodeJS.ErrnoException, null as unknown as Dir);
-    }
-  });
-}
-
-// promises.opendir
-export async function opendirAsync(
-  path: PathLike,
-  _options?: { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean },
-): Promise<Dir> {
-  return new Promise<Dir>((resolve, reject) => {
-    const pathStr = normalizePath(path);
-    const file = Gio.File.new_for_path(pathStr);
-    file.enumerate_children_async(
-      DIR_ATTRS,
-      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
-      GLib.PRIORITY_DEFAULT,
-      null,
-      (_source: unknown, result: Gio.AsyncResult) => {
-        try {
-          const enumerator = file.enumerate_children_finish(result);
-          resolve(new Dir(pathStr, enumerator));
-        } catch (err: unknown) {
-          reject(createNodeError(err, 'opendir', pathStr));
-        }
-      },
-    );
-  });
-}

package/src/dirent.ts

@@ -1,165 +0,0 @@
-// Reference: Node.js lib/internal/fs/utils.js (Dirent class)
-// Reimplemented for GJS using Gio.FileInfo
-
-import Gio from '@girs/gio-2.0';
-import { basename, dirname } from 'node:path';
-
-import type { Dirent as OriginalDirent } from 'node:fs'; // Types from @types/node
-
-// POSIX file type constants from stat mode bits (S_IFMT mask = 0o170000)
-const S_IFMT   = 0o170000;
-const S_IFSOCK = 0o140000;
-const S_IFLNK  = 0o120000;
-const S_IFREG  = 0o100000;
-const S_IFBLK  = 0o060000;
-const S_IFDIR  = 0o040000;
-const S_IFCHR  = 0o020000;
-const S_IFIFO  = 0o010000;
-
-/**
- * A representation of a directory entry, which can be a file or a subdirectory
- * within the directory, as returned by reading from an `fs.Dir`. The
- * directory entry is a combination of the file name and file type pairs.
- *
- * Additionally, when {@link readdir} or {@link readdirSync} is called with
- * the `withFileTypes` option set to `true`, the resulting array is filled with `fs.Dirent` objects, rather than strings or `Buffer` s.
- * @since v10.10.0
- */
-export class Dirent implements OriginalDirent {
-
-    /**
-     * The file name that this `fs.Dirent` object refers to. The type of this
-     * value is determined by the `options.encoding` passed to {@link readdir} or {@link readdirSync}.
-     * @since v10.10.0
-     */
-    name: string;
-
-    /**
-     * The path to the parent directory of the file this `fs.Dirent` object refers to.
-     * @since v20.12.0, v18.20.0
-     */
-    parentPath: string;
-
-    private _isFile = false;
-    private _isDirectory = false;
-    private _isBlockDevice = false;
-    private _isCharacterDevice = false;
-    private _isSymbolicLink = false;
-    private _isFIFO = false;
-    private _isSocket = false;
-
-    /** This is not part of node.fs and is used internal by gjsify */
-    protected _file: Gio.File;
-
-    /** This is not part of node.fs and is used internal by gjsify */
-    constructor(path: string, filename?: string, fileType?: Gio.FileType) {
-        if (!filename) filename = basename(path);
-        this.name = filename;
-        this.parentPath = dirname(path);
-        this._file = Gio.File.new_for_path(path);
-        const type = fileType ?? this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
-
-        switch (type) {
-            case Gio.FileType.DIRECTORY:
-                this._isDirectory = true;
-                break;
-            case Gio.FileType.MOUNTABLE:
-                break;
-            case Gio.FileType.REGULAR:
-                this._isFile = true;
-                break;
-            case Gio.FileType.SYMBOLIC_LINK:
-            case Gio.FileType.SHORTCUT:
-                this._isSymbolicLink = true; // ?
-                break;
-            case Gio.FileType.SPECIAL:
-                // File is a "special" file, such as a socket, fifo, block device, or character device.
-                // Use unix::mode from Gio.FileInfo to distinguish the exact type via POSIX S_IFMT bits.
-                this._classifySpecialFile(path);
-                break;
-        }
-
-    }
-
-    /**
-     * Classify a SPECIAL file type using the unix::mode attribute from Gio.FileInfo.
-     * Falls back to marking nothing if the mode attribute is unavailable.
-     */
-    private _classifySpecialFile(path: string): void {
-        try {
-            const file = Gio.File.new_for_path(path);
-            const info = file.query_info('unix::mode', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-            const mode = info.get_attribute_uint32('unix::mode');
-            if (mode === 0) return;
-            const fmt = mode & S_IFMT;
-            switch (fmt) {
-                case S_IFBLK:
-                    this._isBlockDevice = true;
-                    break;
-                case S_IFCHR:
-                    this._isCharacterDevice = true;
-                    break;
-                case S_IFSOCK:
-                    this._isSocket = true;
-                    break;
-                case S_IFIFO:
-                    this._isFIFO = true;
-                    break;
-            }
-        } catch {
-            // If we can't query the mode (e.g. permission denied), leave all flags as false
-        }
-    }
-
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a regular file.
-     * @since v10.10.0
-     */
-    isFile(): boolean {
-        return this._isFile;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a file system
-     * directory.
-     * @since v10.10.0
-     */
-    isDirectory(): boolean {
-        return this._isDirectory;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a block device.
-     * @since v10.10.0
-     */
-    isBlockDevice(): boolean {
-        return this._isBlockDevice;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a character device.
-     * @since v10.10.0
-     */
-    isCharacterDevice(): boolean {
-        return this._isCharacterDevice;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a symbolic link.
-     * @since v10.10.0
-     */
-    isSymbolicLink(): boolean {
-        return this._isSymbolicLink;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a first-in-first-out
-     * (FIFO) pipe.
-     * @since v10.10.0
-     */
-    isFIFO(): boolean {
-        return this._isFIFO;
-    }
-    /**
-     * Returns `true` if the `fs.Dirent` object describes a socket.
-     * @since v10.10.0
-     */
-    isSocket(): boolean {
-        return this._isSocket;
-    }
-}

package/src/encoding.ts

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Adapted from Deno (refs/deno/ext/node/polyfills/_fs/_fs_mkdtemp.ts)
-// Copyright (c) 2018-2026 the Deno authors. MIT license.
-// Modifications: Extracted encoding helpers, adapted for GJS
-
-import { Buffer } from 'node:buffer';
-
-import type { ReadOptions } from './types/index.js';
-import type { ObjectEncodingOptions, BufferEncodingOption } from 'node:fs'; // Types from @types/node
-
-export function getEncodingFromOptions(options: ReadOptions | ObjectEncodingOptions | BufferEncodingOption= { encoding: null, flag: 'r' }, defaultEncoding: null | BufferEncoding | "buffer" = 'utf8'): BufferEncoding | 'buffer' {
-  if (options === null) {
-    return defaultEncoding;
-  }
-
-  if (typeof options === 'string') {
-    return options as BufferEncoding | 'buffer';
-  }
-
-  if (typeof options === 'object' && typeof options.encoding === 'string') {
-    return options.encoding;
-  }
-
-  return defaultEncoding;
-}
-
-export function encodeUint8Array(encoding: BufferEncoding | 'buffer', data: Uint8Array) {
-  if (encoding === 'buffer') {
-    return Buffer.from(data);
-  }
-
-  const decoder = new TextDecoder(encoding);
-  return decoder.decode(data);
-  // return byteArray.toString(data);
-}
-
-// Credits https://github.com/denoland/deno_std/blob/63be40277264e71af60f9b118a2cb569e02beeab/node/_fs/_fs_mkdtemp.ts#L82
-export function decode(str: string, encoding?: string): string {
-  if (!encoding) return str;
-  else {
-    const decoder = new TextDecoder(encoding);
-    const encoder = new TextEncoder();
-    return decoder.decode(encoder.encode(str));
-  }
-}