@zenfs/core 2.4.1 → 2.4.2

package/dist/node/dir.js

@@ -0,0 +1,150 @@
+import { Buffer } from 'buffer';
+import { withErrno } from 'kerium';
+import { warn } from 'kerium/log';
+import { parse } from '../path.js';
+import { DirType } from '../vfs/dir.js';
+import { readdir } from './promises.js';
+import { readdirSync } from './sync.js';
+export class Dirent {
+    ino;
+    type;
+    _name;
+    get name() {
+        const name = Buffer.from(this._name);
+        return (this._encoding == 'buffer' ? name : name.toString(this._encoding));
+    }
+    /**
+     * @internal @protected
+     */
+    _encoding;
+    /**
+     * @internal @protected
+     */
+    _parentPath;
+    get parentPath() {
+        return this._parentPath;
+    }
+    /**
+     * @deprecated Removed in Node v24, use `parentPath` instead.
+     */
+    get path() {
+        warn('Dirent.path was removed in Node v24, use parentPath instead');
+        return this._parentPath;
+    }
+    /**
+     * @internal
+     */
+    static from(vfs, encoding) {
+        const dirent = new Dirent();
+        const { base, dir } = parse(vfs.path);
+        dirent._parentPath = dir || '.';
+        dirent._name = base;
+        dirent.ino = vfs.ino;
+        dirent.type = vfs.type;
+        dirent._encoding = encoding;
+        return dirent;
+    }
+    isFile() {
+        return this.type === DirType.REG;
+    }
+    isDirectory() {
+        return this.type === DirType.DIR;
+    }
+    isBlockDevice() {
+        return this.type === DirType.BLK;
+    }
+    isCharacterDevice() {
+        return this.type === DirType.CHR;
+    }
+    isSymbolicLink() {
+        return this.type === DirType.LNK;
+    }
+    isFIFO() {
+        return this.type === DirType.FIFO;
+    }
+    isSocket() {
+        return this.type === DirType.SOCK;
+    }
+}
+/**
+ * A class representing a directory stream.
+ */
+export class Dir {
+    path;
+    context;
+    closed = false;
+    checkClosed() {
+        if (this.closed)
+            throw withErrno('EBADF', 'Can not use closed Dir');
+    }
+    _entries;
+    constructor(path, context) {
+        this.path = path;
+        this.context = context;
+    }
+    close(cb) {
+        this.closed = true;
+        if (!cb) {
+            return Promise.resolve();
+        }
+        cb(null);
+    }
+    /**
+     * Synchronously close the directory's underlying resource handle.
+     * Subsequent reads will result in errors.
+     */
+    closeSync() {
+        this.closed = true;
+    }
+    async _read() {
+        this.checkClosed();
+        this._entries ??= await readdir.call(this.context, this.path, {
+            withFileTypes: true,
+        });
+        if (!this._entries.length)
+            return null;
+        return this._entries.shift() ?? null;
+    }
+    read(cb) {
+        if (!cb) {
+            return this._read();
+        }
+        void this._read().then(value => cb(null, value));
+    }
+    /**
+     * Synchronously read the next directory entry via `readdir(3)` as a `Dirent`.
+     * If there are no more directory entries to read, null will be returned.
+     * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
+     */
+    readSync() {
+        this.checkClosed();
+        this._entries ??= readdirSync.call(this.context, this.path, { withFileTypes: true });
+        if (!this._entries.length)
+            return null;
+        return this._entries.shift() ?? null;
+    }
+    async next() {
+        const value = await this._read();
+        if (value) {
+            return { done: false, value };
+        }
+        await this.close();
+        return { done: true, value: undefined };
+    }
+    /**
+     * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
+     */
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    [Symbol.dispose]() {
+        if (this.closed)
+            return;
+        this.closeSync();
+    }
+    async [Symbol.asyncDispose]() {
+        if (this.closed)
+            return;
+        await this.close();
+    }
+}

package/dist/node/index.d.ts

@@ -0,0 +1,8 @@
+export * as constants from '../constants.js';
+export * from './async.js';
+export * from './dir.js';
+export * as promises from './promises.js';
+export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
+export type { StatsLike } from './stats.js';
+export * from './streams.js';
+export * from './sync.js';

package/dist/node/index.js

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+export * as constants from '../constants.js';
+export * from './async.js';
+export * from './dir.js';
+export * as promises from './promises.js';
+export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
+export * from './streams.js';
+export * from './sync.js';

package/dist/{vfs → node}/promises.d.ts

@@ -4,53 +4,22 @@ import type * as promises from 'node:fs/promises';
 import type { Stream } from 'node:stream';
 import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
 import type { V_Context } from '../context.js';
-import type { FileSystem, StreamOptions } from '../internal/filesystem.js';
-import type { InodeLike } from '../internal/inode.js';
-import type { Interface as ReadlineInterface } from '../readline.js';
-import type { FileContents, ReaddirOptions } from './types.js';
+import type { StreamOptions } from '../internal/filesystem.js';
+import type { FileContents } from '../vfs/shared.js';
+import type { Interface as ReadlineInterface } from './readline.js';
+import type { NodeReaddirOptions } from './types.js';
 import { Buffer } from 'buffer';
 import '../polyfills.js';
+import type { Handle } from '../vfs/file.js';
 import { Dir, Dirent } from './dir.js';
-import { SyncHandle } from './file.js';
 import { BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
-export * as constants from './constants.js';
+export * as constants from '../constants.js';
 export declare class FileHandle implements promises.FileHandle {
     protected context: V_Context;
     readonly fd: number;
-    protected _buffer?: Uint8Array;
-    /**
-     * Get the current file position.
-     *
-     * We emulate the following bug mentioned in the Node documentation:
-     *
-     * On Linux, positional writes don't work when the file is opened in append mode.
-     * The kernel ignores the position argument and always appends the data to the end of the file.
-     * @returns The current file position.
-     */
-    get position(): number;
-    set position(value: number);
-    /**
-     * Whether the file has changes which have not been written to the FS
-     */
-    protected dirty: boolean;
-    /**
-     * Whether the file is open or closed
-     */
-    protected closed: boolean;
-    /** The path relative to the context's root */
-    get path(): string;
-    /** The internal FS associated with the handle */
-    protected get fs(): FileSystem;
-    /** The path relative to the `FileSystem`'s root */
-    get internalPath(): string;
-    /** The flag the handle was opened with */
-    get flag(): number;
-    /** Stats for the handle */
-    get inode(): InodeLike;
-    protected _sync: SyncHandle;
+    protected vfs: Handle;
     constructor(context: V_Context, fd: number);
-    private get _isSync();
     private _emitChange;
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
@@ -79,7 +48,7 @@ export declare class FileHandle implements promises.FileHandle {
      * @param atime The last access time. If a string is provided, it will be coerced to number.
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
-    utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    utimes(atime: fs.TimeLike, mtime: fs.TimeLike): Promise<void>;
     /**
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for appending.
@@ -90,18 +59,6 @@ export declare class FileHandle implements promises.FileHandle {
      * - `flag` defaults to `'a'`.
      */
     appendFile(data: string | Uint8Array, _options?: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<void>;
-    /**
-     * Read data from the file.
-     * @param buffer The buffer that the data will be written to.
-     * @param offset The offset within the buffer where writing will start.
-     * @param length An integer specifying the number of bytes to read.
-     * @param position An integer specifying where to begin reading from in the file.
-     * If position is unset, data will be read from the current file position.
-     */
-    protected _read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
-        bytesRead: number;
-        buffer: TBuffer;
-    }>;
     /**
      * Asynchronously reads data from the file.
      * The `FileHandle` must have been opened for reading.
@@ -147,15 +104,6 @@ export declare class FileHandle implements promises.FileHandle {
     stat(opts?: fs.StatOptions & {
         bigint?: false;
     }): Promise<Stats>;
-    /**
-     * Write buffer to the file.
-     * @param buffer Uint8Array containing the data to write to the file.
-     * @param offset Offset in the buffer to start reading data from.
-     * @param length The amount of bytes to write to the file.
-     * @param position Offset from the beginning of the file where this data should be written.
-     * If position is null, the data will be written at  the current position.
-     */
-    protected _write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
     /**
      * Asynchronously writes `string` to the file.
      * The `FileHandle` must have been opened for writing.
@@ -185,10 +133,6 @@ export declare class FileHandle implements promises.FileHandle {
      * Asynchronous close(2) - close a `FileHandle`.
      */
     close(): Promise<void>;
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    protected dispose(force?: boolean): void;
     /**
      * Asynchronous `writev`. Writes from multiple buffers.
      * @param buffers An array of Uint8Array buffers.
@@ -327,7 +271,7 @@ export declare function readdir(this: V_Context, path: fs.PathLike, options: {
     withFileTypes: true;
     recursive?: boolean;
 }): Promise<Dirent<Buffer>[]>;
-export declare function readdir(this: V_Context, path: fs.PathLike, options?: ReaddirOptions): Promise<string[] | Dirent<any>[] | Buffer[]>;
+export declare function readdir(this: V_Context, path: fs.PathLike, options?: NodeReaddirOptions): Promise<string[] | Dirent<any>[] | Buffer[]>;
 export declare function link(this: V_Context, path: fs.PathLike, dest: fs.PathLike): Promise<void>;
 /**
  * `symlink`.
@@ -346,7 +290,7 @@ export declare function lchmod(this: V_Context, path: fs.PathLike, mode: fs.Mode
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
-export declare function utimes(this: V_Context, path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+export declare function utimes(this: V_Context, path: fs.PathLike, atime: fs.TimeLike, mtime: fs.TimeLike): Promise<void>;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */