@zenfs/core 1.11.3 → 2.0.0

package/dist/vfs/dir.js

@@ -1,5 +1,6 @@
+import { isBlockDevice, isCharacterDevice, isDirectory, isFIFO, isFile, isSocket, isSymbolicLink } from '../internal/inode.js';
 import { Errno, ErrnoError } from '../internal/error.js';
-import { basename } from './path.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);
     }
 }
 /**

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,235 @@
+import { defaultContext } from '../internal/contexts.js';
+import { Errno, ErrnoError } from '../internal/error.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);
+    }
+    sync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        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 ErrnoError.With('EBADF', this.path, 'close');
+        this.sync();
+        this.dispose();
+    }
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    dispose(force) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'dispose');
+        if (this.dirty && !force)
+            throw ErrnoError.With('EBUSY', this.path, 'dispose');
+        this.closed = true;
+    }
+    stat() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
+        return this.inode;
+    }
+    truncate(length) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'truncate');
+        this.dirty = true;
+        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR)) {
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'truncate');
+        }
+        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 ErrnoError.With('EBADF', this.path, 'write');
+        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'write');
+        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 ErrnoError.With('EBADF', this.path, 'read');
+        if (this.flag & c.O_WRONLY)
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
+        if (!(this.inode.flags & InodeFlags.NoAtime)) {
+            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 ErrnoError.With('EBADF', this.path, 'chmod');
+        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 ErrnoError.With('EBADF', this.path, 'chown');
+        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 ErrnoError.With('EBADF', this.path, 'utimes');
+        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 ErrnoError.With('EBADF', this.path, 'streamRead');
+        return this.fs.streamRead(this.internalPath, options);
+    }
+    /**
+     * Create a stream for writing the file.
+     */
+    streamWrite(options) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'streamWrite');
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'streamWrite');
+        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 new ErrnoError(Errno.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;

package/dist/vfs/flags.js

@@ -0,0 +1,62 @@
+import { Errno, ErrnoError } from '../internal/error.js';
+import * as c from './constants.js';
+export const pattern = /[rwasx]{1,2}\+?/;
+/**
+ * @internal @hidden
+ */
+export function parse(flag) {
+    if (typeof flag == 'number')
+        return flag;
+    if (!pattern.test(flag)) {
+        throw new ErrnoError(Errno.EINVAL, 'Invalid flag string: ' + flag);
+    }
+    return toNumber(flag);
+}
+/**
+ * @internal @hidden
+ */
+export function toString(flag) {
+    let string = flag & c.O_RDONLY ? 'r' : flag & c.O_APPEND ? 'a' : flag & c.O_TRUNC ? 'w' : '';
+    if (flag & c.O_SYNC)
+        string += 's';
+    if (flag & c.O_EXCL)
+        string += 'x';
+    if (flag & c.O_RDWR)
+        string += '+';
+    return string;
+}
+/**
+ * @internal @hidden
+ */
+export function toNumber(flag) {
+    if (!flag.includes('r') && !flag.includes('w') && !flag.includes('a')) {
+        throw new ErrnoError(Errno.EINVAL, 'Invalid flag string: ' + flag);
+    }
+    let n = flag.includes('r') ? c.O_RDONLY : c.O_CREAT;
+    if (flag.includes('w'))
+        n |= c.O_TRUNC;
+    if (flag.includes('a'))
+        n |= c.O_APPEND;
+    if (flag.includes('+'))
+        n |= c.O_RDWR;
+    else if (!flag.includes('r'))
+        n |= c.O_WRONLY;
+    if (flag.includes('s'))
+        n |= c.O_SYNC;
+    if (flag.includes('x'))
+        n |= c.O_EXCL;
+    return n;
+}
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ * @internal @hidden
+ */
+export function toMode(flag) {
+    let mode = 0;
+    if (!(flag & c.O_WRONLY))
+        mode |= c.R_OK;
+    if (flag & c.O_WRONLY || flag & c.O_RDWR)
+        mode |= c.W_OK;
+    return mode;
+}

package/dist/vfs/index.d.ts

@@ -1,16 +1,10 @@
-export { BigIntStatsFs, Stats, StatsFs } from '../stats.js';
 export * from './async.js';
 export * as constants from './constants.js';
 export * from './dir.js';
+export * from './ioctl.js';
 export * as promises from './promises.js';
-export { chroot, mount, mountObject, 
-/**
- * The map of mount points.
- * Using `fs.mounts` instead of the `mounts` export is a security issue and not recommended.
- * The deprecation here propagates to the correct `mounts` export for some reason.
- * @todo [BREAKING] remove `fs.mounts` for security.
- * @deprecated Use the `mounts` export that isn't an `fs` property!
- */
-mounts, umount, } from './shared.js';
+export { chroot, mount, umount } from './shared.js';
+export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export * as xattr from './xattr.js';

package/dist/vfs/index.js

@@ -1,19 +1,10 @@
-export { BigIntStatsFs, Stats, StatsFs } from '../stats.js';
 export * from './async.js';
 export * as constants from './constants.js';
 export * from './dir.js';
+export * from './ioctl.js';
 export * as promises from './promises.js';
-export { chroot, mount, mountObject, 
-/* node:coverage disable */
-/**
- * The map of mount points.
- * Using `fs.mounts` instead of the `mounts` export is a security issue and not recommended.
- * The deprecation here propagates to the correct `mounts` export for some reason.
- * @todo [BREAKING] remove `fs.mounts` for security.
- * @deprecated Use the `mounts` export that isn't an `fs` property!
- */
-mounts, 
-/* node:coverage enable */
-umount, } from './shared.js';
+export { chroot, mount, umount } from './shared.js';
+export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export * as xattr from './xattr.js';

package/dist/vfs/ioctl.d.ts

@@ -0,0 +1,87 @@
+import type { V_Context } from '../context.js';
+import { Inode } from '../internal/inode.js';
+declare class fsxattr {
+    /** xflags field value */
+    xflags: number;
+    /** extsize field value */
+    extsize: number;
+    /** nextents field value */
+    nextents: number;
+    /** project identifier */
+    projid: number;
+    /** CoW extsize field value */
+    cowextsize: number;
+    protected pad: never[];
+    constructor(inode?: Inode);
+}
+/**
+ * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export declare enum IOC {
+    GetFlags = 2148034049,
+    SetFlags = 1074292226,
+    GetVersion = 2148038145,
+    SetVersion = 1074296322,
+    Fiemap = 3223348747,
+    GetXattr = 2149341215,
+    SetXattr = 1075599392,
+    GetLabel = 2164298801,
+    SetLabel = 1090556978,
+    GetUUID = 2148603136,
+    GetSysfsPath = 2155943169
+}
+/**
+ * `FS_IOC32_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export declare enum IOC32 {
+    GetFlags = 2147771905,
+    SetFlags = 1074030082,
+    GetVersion = 2147776001,
+    SetVersion = 1074034178
+}
+/** Used by `ioctl` for type inference */
+interface _ioc_ops {
+    [IOC.GetFlags](): number;
+    [IOC.SetFlags](flags: number): void;
+    [IOC.GetVersion](): number;
+    [IOC.SetVersion](version: number): void;
+    [IOC.Fiemap](): never;
+    [IOC.GetXattr](name: string): fsxattr;
+    [IOC.SetXattr](name: string, value: fsxattr): never;
+    [IOC.GetLabel](): string;
+    [IOC.SetLabel](label: string): void;
+    [IOC.GetUUID](): string;
+    [IOC.GetSysfsPath](): string;
+}
+/** Used by `ioctl` for type inference */
+interface _ioc32_ops extends Record<keyof IOC32, (...args: any[]) => any> {
+    [IOC32.GetFlags](): number;
+    [IOC32.SetFlags](flags: number): void;
+    [IOC32.GetVersion](): number;
+    [IOC32.SetVersion](version: number): void;
+}
+/** Used by `ioctl` for type inference */
+type __ioctl_args__<T extends number> = T extends IOC ? Parameters<_ioc_ops[T]> : T extends IOC32 ? Parameters<_ioc32_ops[T]> : any[];
+/** Used by `ioctl` for type inference */
+type __ioctl_return__<T extends number> = T extends IOC ? ReturnType<_ioc_ops[T]> : T extends IOC32 ? ReturnType<_ioc32_ops[T]> : any;
+/** Perform an `ioctl` on a file or file system. */
+export declare function ioctl<const Command extends number, const Args extends __ioctl_args__<Command>, const Return extends __ioctl_return__<Command>>(this: V_Context, 
+/** The path to the file or file system to perform the `ioctl` on */
+path: string, 
+/** The command to perform (uint32) */
+command: Command, 
+/** The arguments to pass to the command */
+...args: Args): Promise<Return>;
+/** Perform an `ioctl` on a file or file system */
+export declare function ioctlSync<const Command extends number, const Args extends __ioctl_args__<Command>, const Return extends __ioctl_return__<Command>>(this: V_Context, 
+/** The path to the file or file system to perform the `ioctl` on */
+path: string, 
+/** The command to perform (uint32) */
+command: Command, 
+/** The arguments to pass to the command */
+...args: Args): Return;
+export {};