@zenfs/core 1.11.4 → 2.1.0

package/dist/vfs/async.js

@@ -1,10 +1,9 @@
 import { Buffer } from 'buffer';
-import { Errno, ErrnoError } from '../internal/error.js';
-import { BigIntStats } from '../stats.js';
+import { UV, withErrno } from 'kerium';
 import { normalizeMode, normalizePath } from '../utils.js';
 import { R_OK } from './constants.js';
 import * as promises from './promises.js';
-import { fd2file, fdMap } from './shared.js';
+import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, StatWatcher } from './watchers.js';
 const nop = () => { };
@@ -31,7 +30,7 @@ rename;
 /**
  * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @deprecated Use {@link stat} or {@link access} instead.
+ * According to Node.js: deprecated Use {@link stat} or {@link access} instead.
  */
 export function exists(path, cb = nop) {
     promises.exists
@@ -108,39 +107,39 @@ export function appendFile(filename, data, cbEncOpts, cb = nop) {
 appendFile;
 export function fstat(fd, options, cb = nop) {
     cb = typeof options == 'function' ? options : cb;
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .stat()
         .then(stats => cb(undefined, typeof options == 'object' && (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats))
         .catch(cb);
 }
 fstat;
 export function close(fd, cb = nop) {
-    const close = fd2file(fd).close();
-    fdMap.delete(fd);
-    close.then(() => cb()).catch(cb);
+    new promises.FileHandle(this, fd)
+        .close()
+        .then(() => cb())
+        .catch(cb);
 }
 close;
 export function ftruncate(fd, lenOrCB, cb = nop) {
     const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
     cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
-    const file = fd2file(fd);
-    if (length < 0) {
-        throw new ErrnoError(Errno.EINVAL);
-    }
+    const file = new promises.FileHandle(this, fd);
+    if (length < 0)
+        throw withErrno('EINVAL');
     file.truncate(length)
         .then(() => cb())
         .catch(cb);
 }
 ftruncate;
 export function fsync(fd, cb = nop) {
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .sync()
         .then(() => cb())
         .catch(cb);
 }
 fsync;
 export function fdatasync(fd, cb = nop) {
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .datasync()
         .then(() => cb())
         .catch(cb);
@@ -148,7 +147,7 @@ export function fdatasync(fd, cb = nop) {
 fdatasync;
 export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
     let buffer, offset, length, position, encoding;
-    const handle = new promises.FileHandle(fd, this);
+    const handle = new promises.FileHandle(this, fd);
     if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]], cb?)
         encoding = 'utf8';
@@ -166,7 +165,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
             default:
                 // ...try to find the callback and get out of here!
                 cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(new ErrnoError(Errno.EINVAL, 'Invalid arguments'));
+                cb(withErrno('EINVAL'));
                 return;
         }
         buffer = Buffer.from(data);
@@ -202,21 +201,21 @@ write;
  * @param cb The number is the number of bytes read
  */
 export function read(fd, buffer, offset, length, position, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .read(buffer, offset, length, position)
         .then(({ bytesRead, buffer }) => cb(undefined, bytesRead, buffer))
         .catch(cb);
 }
 read;
 export function fchown(fd, uid, gid, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .chown(uid, gid)
         .then(() => cb())
         .catch(cb);
 }
 fchown;
 export function fchmod(fd, mode, cb) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .chmod(mode)
         .then(() => cb())
         .catch(cb);
@@ -226,7 +225,7 @@ fchmod;
  * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
 export function futimes(fd, atime, mtime, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .utimes(atime, mtime)
         .then(() => cb())
         .catch(cb);
@@ -350,14 +349,13 @@ export function access(path, cbMode, cb = nop) {
 access;
 const statWatchers = new Map();
 export function watchFile(path, options, listener) {
-    const normalizedPath = normalizePath(path.toString());
+    const normalizedPath = normalizePath(path);
     const opts = typeof options != 'function' ? options : {};
     if (typeof options == 'function') {
         listener = options;
     }
-    if (!listener) {
-        throw new ErrnoError(Errno.EINVAL, 'No listener specified', path.toString(), 'watchFile');
-    }
+    if (!listener)
+        throw UV('EINVAL', 'watch', path.toString());
     if (statWatchers.has(normalizedPath)) {
         const entry = statWatchers.get(normalizedPath);
         if (entry) {
@@ -388,7 +386,7 @@ watchFile;
  * @param listener Optional listener to remove.
  */
 export function unwatchFile(path, listener = nop) {
-    const normalizedPath = normalizePath(path.toString());
+    const normalizedPath = normalizePath(path);
     const entry = statWatchers.get(normalizedPath);
     if (entry) {
         if (listener && listener !== nop) {
@@ -465,7 +463,7 @@ export function copyFile(src, dest, flags, callback = nop) {
 copyFile;
 export function readv(fd, buffers, position, cb = nop) {
     cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .readv(buffers, typeof position === 'function' ? undefined : position)
         .then(({ buffers, bytesRead }) => cb(undefined, bytesRead, buffers))
         .catch(cb);
@@ -473,7 +471,7 @@ export function readv(fd, buffers, position, cb = nop) {
 readv;
 export function writev(fd, buffers, position, cb = nop) {
     cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .writev(buffers, typeof position === 'function' ? undefined : position)
         .then(({ buffers, bytesWritten }) => cb(undefined, bytesWritten, buffers))
         .catch(cb);

package/dist/vfs/config.d.ts

@@ -1,18 +1,6 @@
-export declare const config: {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: boolean;
-    /**
-     * Whether to mark a file as dirty after updating its `atime` when read from
-     */
-    updateOnRead: boolean;
-    /**
-     * Whether to immediately sync when files are changed
-     */
-    syncImmediately: boolean;
-    /**
-     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
-     */
-    unsafeBufferReplace: boolean;
-};
+/** Whether to perform access checks */
+export declare let checkAccess: boolean;
+/**
+ * @internal @hidden
+ */
+export declare function _setAccessChecks(value: boolean): void;

package/dist/vfs/config.js

@@ -1,18 +1,8 @@
-export const config = {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: true,
-    /**
-     * Whether to mark a file as dirty after updating its `atime` when read from
-     */
-    updateOnRead: true,
-    /**
-     * Whether to immediately sync when files are changed
-     */
-    syncImmediately: true,
-    /**
-     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
-     */
-    unsafeBufferReplace: false,
-};
+/** Whether to perform access checks */
+export let checkAccess = true;
+/**
+ * @internal @hidden
+ */
+export function _setAccessChecks(value) {
+    checkAccess = value;
+}

package/dist/vfs/dir.d.ts

@@ -1,12 +1,12 @@
 import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { Stats } from '../stats.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { Callback } from '../utils.js';
 export declare class Dirent implements _Dirent {
     path: string;
-    protected stats: Stats;
+    protected stats: InodeLike;
     get name(): string;
-    constructor(path: string, stats: Stats);
+    constructor(path: string, stats: InodeLike);
     get parentPath(): string;
     isFile(): boolean;
     isDirectory(): boolean;

package/dist/vfs/dir.js

@@ -1,5 +1,6 @@
-import { Errno, ErrnoError } from '../internal/error.js';
-import { basename } from './path.js';
+import { withErrno } from 'kerium';
+import { isBlockDevice, isCharacterDevice, isDirectory, isFIFO, isFile, isSocket, isSymbolicLink } from '../internal/inode.js';
+import { basename } from '../path.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';
 export class Dirent {
@@ -14,25 +15,25 @@ export class Dirent {
         return this.path;
     }
     isFile() {
-        return this.stats.isFile();
+        return isFile(this.stats);
     }
     isDirectory() {
-        return this.stats.isDirectory();
+        return isDirectory(this.stats);
     }
     isBlockDevice() {
-        return this.stats.isBlockDevice();
+        return isBlockDevice(this.stats);
     }
     isCharacterDevice() {
-        return this.stats.isCharacterDevice();
+        return isCharacterDevice(this.stats);
     }
     isSymbolicLink() {
-        return this.stats.isSymbolicLink();
+        return isSymbolicLink(this.stats);
     }
     isFIFO() {
-        return this.stats.isFIFO();
+        return isFIFO(this.stats);
     }
     isSocket() {
-        return this.stats.isSocket();
+        return isSocket(this.stats);
     }
 }
 /**
@@ -40,9 +41,8 @@ export class Dirent {
  */
 export class Dir {
     checkClosed() {
-        if (this.closed) {
-            throw new ErrnoError(Errno.EBADF, 'Can not use closed Dir');
-        }
+        if (this.closed)
+            throw withErrno('EBADF', 'Can not use closed Dir');
     }
     constructor(path, context) {
         this.path = path;

package/dist/vfs/file.d.ts

@@ -0,0 +1,106 @@
+import type { V_Context } from '../context.js';
+import type { FileSystem, StreamOptions } from '../internal/filesystem.js';
+import { type InodeLike } from '../internal/inode.js';
+import '../polyfills.js';
+/** @hidden */
+export interface FileReadResult<T extends ArrayBufferView> {
+    bytesRead: number;
+    buffer: T;
+}
+/**
+ * @internal
+ */
+export declare class SyncHandle {
+    readonly context: V_Context;
+    readonly path: string;
+    readonly fs: FileSystem;
+    readonly internalPath: string;
+    readonly flag: number;
+    readonly inode: InodeLike;
+    protected _buffer?: Uint8Array;
+    /**
+     * Current position
+     */
+    protected _position: number;
+    /**
+     * 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;
+    /**
+     * Creates a file with `path` and, optionally, the given contents.
+     * Note that, if contents is specified, it will be mutated by the file.
+     */
+    constructor(context: V_Context, path: string, fs: FileSystem, internalPath: string, flag: number, inode: InodeLike);
+    [Symbol.dispose](): void;
+    private get _isSync();
+    sync(): void;
+    /**
+     * Default implementation maps to `syncSync`.
+     */
+    datasync(): void;
+    close(): void;
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    protected dispose(force?: boolean): void;
+    stat(): InodeLike;
+    truncate(length: number): void;
+    /**
+     * 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.
+     * @returns bytes written
+     */
+    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+    /**
+     * 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 null, data will be read from the current file position.
+     * @returns number of bytes written
+     */
+    read(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    chmod(mode: number): void;
+    chown(uid: number, gid: number): void;
+    /**
+     * Change the file timestamps of the file.
+     */
+    utimes(atime: number, mtime: number): void;
+    /**
+     * Create a stream for reading the file.
+     */
+    streamRead(options: StreamOptions): ReadableStream;
+    /**
+     * Create a stream for writing the file.
+     */
+    streamWrite(options: StreamOptions): WritableStream;
+}
+/**
+ * @internal @hidden
+ */
+export declare function toFD(file: SyncHandle): number;
+/**
+ * @internal @hidden
+ */
+export declare function fromFD($: V_Context, fd: number): SyncHandle;
+export declare function deleteFD($: V_Context, fd: number): boolean;

package/dist/vfs/file.js

@@ -0,0 +1,244 @@
+import { UV, withErrno } from 'kerium';
+import { defaultContext } from '../internal/contexts.js';
+import { InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
+import '../polyfills.js';
+import * as c from './constants.js';
+import { _chown } from './stats.js';
+/**
+ * @internal
+ */
+export class SyncHandle {
+    /**
+     * 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() {
+        return this.flag & c.O_APPEND ? this.inode.size : this._position;
+    }
+    set position(value) {
+        this._position = value;
+    }
+    /**
+     * Creates a file with `path` and, optionally, the given contents.
+     * Note that, if contents is specified, it will be mutated by the file.
+     */
+    constructor(context, path, fs, internalPath, flag, inode) {
+        this.context = context;
+        this.path = path;
+        this.fs = fs;
+        this.internalPath = internalPath;
+        this.flag = flag;
+        this.inode = inode;
+        /**
+         * Current position
+         */
+        this._position = 0;
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
+        this.dirty = false;
+        /**
+         * Whether the file is open or closed
+         */
+        this.closed = false;
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+    get _isSync() {
+        return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync || this.fs.attributes.has('sync'));
+    }
+    sync() {
+        if (this.closed)
+            throw UV('EBADF', 'sync', this.path);
+        if (!this.dirty)
+            return;
+        if (!this.fs.attributes.has('no_write'))
+            this.fs.touchSync(this.internalPath, this.inode);
+        this.dirty = false;
+    }
+    /**
+     * Default implementation maps to `syncSync`.
+     */
+    datasync() {
+        return this.sync();
+    }
+    close() {
+        if (this.closed)
+            throw UV('EBADF', 'close', this.path);
+        this.sync();
+        this.dispose();
+    }
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    dispose(force) {
+        if (this.closed)
+            throw UV('EBADF', 'close', this.path);
+        if (this.dirty && !force)
+            throw UV('EBUSY', 'close', this.path);
+        this.closed = true;
+    }
+    stat() {
+        if (this.closed)
+            throw UV('EBADF', 'stat', this.path);
+        return this.inode;
+    }
+    truncate(length) {
+        if (length < 0)
+            throw UV('EINVAL', 'truncate', this.path);
+        if (this.closed)
+            throw UV('EBADF', 'truncate', this.path);
+        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+            throw UV('EBADF', 'truncate', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'truncate', this.path);
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'truncate', this.path);
+        this.dirty = true;
+        this.inode.mtimeMs = Date.now();
+        this.inode.size = length;
+        this.inode.ctimeMs = Date.now();
+        if (this._isSync)
+            this.sync();
+    }
+    /**
+     * 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.
+     * @returns bytes written
+     */
+    write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        if (this.closed)
+            throw UV('EBADF', 'write', this.path);
+        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+            throw UV('EBADF', 'write', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'write', this.path);
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'write', this.path);
+        this.dirty = true;
+        const end = position + length;
+        const slice = buffer.subarray(offset, offset + length);
+        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
+            this.inode.size = end;
+        this.inode.mtimeMs = Date.now();
+        this.inode.ctimeMs = Date.now();
+        this._position = position + slice.byteLength;
+        this.fs.writeSync(this.internalPath, slice, position);
+        if (this._isSync)
+            this.sync();
+        return slice.byteLength;
+    }
+    /**
+     * 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 null, data will be read from the current file position.
+     * @returns number of bytes written
+     */
+    read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        if (this.closed)
+            throw UV('EBADF', 'read', this.path);
+        if (this.flag & c.O_WRONLY)
+            throw UV('EBADF', 'read', this.path);
+        if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
+            this.dirty = true;
+            this.inode.atimeMs = Date.now();
+        }
+        let end = position + length;
+        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
+            end = position + Math.max(this.inode.size - position, 0);
+        }
+        this._position = end;
+        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this.fs.readSync(this.internalPath, uint8.subarray(offset, offset + length), position, end);
+        if (this._isSync)
+            this.sync();
+        return end - position;
+    }
+    chmod(mode) {
+        if (this.closed)
+            throw UV('EBADF', 'chmod', this.path);
+        this.dirty = true;
+        this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+        if (this._isSync || mode > c.S_IFMT)
+            this.sync();
+    }
+    chown(uid, gid) {
+        if (this.closed)
+            throw UV('EBADF', 'chmod', this.path);
+        this.dirty = true;
+        _chown(this.inode, uid, gid);
+        if (this._isSync)
+            this.sync();
+    }
+    /**
+     * Change the file timestamps of the file.
+     */
+    utimes(atime, mtime) {
+        if (this.closed)
+            throw UV('EBADF', 'utimes', this.path);
+        this.dirty = true;
+        this.inode.atimeMs = atime;
+        this.inode.mtimeMs = mtime;
+        if (this._isSync)
+            this.sync();
+    }
+    /**
+     * Create a stream for reading the file.
+     */
+    streamRead(options) {
+        if (this.closed)
+            throw UV('EBADF', 'streamRead', this.path);
+        return this.fs.streamRead(this.internalPath, options);
+    }
+    /**
+     * Create a stream for writing the file.
+     */
+    streamWrite(options) {
+        if (this.closed)
+            throw UV('EBADF', 'write', this.path);
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'write', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'write', this.path);
+        return this.fs.streamWrite(this.internalPath, options);
+    }
+}
+// descriptors
+/**
+ * @internal @hidden
+ */
+export function toFD(file) {
+    var _a, _b;
+    const map = (_b = (_a = file.context) === null || _a === void 0 ? void 0 : _a.descriptors) !== null && _b !== void 0 ? _b : defaultContext.descriptors;
+    const fd = Math.max(map.size ? Math.max(...map.keys()) + 1 : 0, 4);
+    map.set(fd, file);
+    return fd;
+}
+/**
+ * @internal @hidden
+ */
+export function fromFD($, fd) {
+    var _a;
+    const map = (_a = $ === null || $ === void 0 ? void 0 : $.descriptors) !== null && _a !== void 0 ? _a : defaultContext.descriptors;
+    const value = map.get(fd);
+    if (!value)
+        throw withErrno('EBADF');
+    return value;
+}
+export function deleteFD($, fd) {
+    var _a;
+    return ((_a = $ === null || $ === void 0 ? void 0 : $.descriptors) !== null && _a !== void 0 ? _a : defaultContext.descriptors).delete(fd);
+}

package/dist/vfs/flags.d.ts

@@ -0,0 +1,19 @@
+export declare const pattern: RegExp;
+/**
+ * @internal @hidden
+ */
+export declare function parse(flag: string | number): number;
+/**
+ * @internal @hidden
+ */
+export declare function toString(flag: number): string;
+/**
+ * @internal @hidden
+ */
+export declare function toNumber(flag: string): number;
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ * @internal @hidden
+ */
+export declare function toMode(flag: number): number;