@zenfs/core 2.4.1 → 2.4.2

package/dist/vfs/file.js

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { UV, withErrno } from 'kerium';
+import * as c from '../constants.js';
 import { defaultContext } from '../internal/contexts.js';
-import { InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
+import { _chown, 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 {
+export class Handle {
     context;
     path;
     fs;
@@ -43,6 +42,9 @@ export class SyncHandle {
      * Whether the file is open or closed
      */
     closed = false;
+    get isClosed() {
+        return this.closed;
+    }
     /**
      * Creates a file with `path` and, optionally, the given contents.
      * Note that, if contents is specified, it will be mutated by the file.
@@ -55,13 +57,13 @@ export class SyncHandle {
         this.flag = flag;
         this.inode = inode;
     }
-    [Symbol.dispose]() {
-        this.close();
-    }
     get _isSync() {
         return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync || this.fs.attributes.has('sync'));
     }
-    sync() {
+    [Symbol.dispose]() {
+        this.closeSync();
+    }
+    syncSync() {
         if (this.closed)
             throw UV('EBADF', 'sync', this.path);
         if (!this.dirty)
@@ -73,13 +75,153 @@ export class SyncHandle {
     /**
      * Default implementation maps to `syncSync`.
      */
+    datasyncSync() {
+        return this.syncSync();
+    }
+    closeSync() {
+        if (this.closed)
+            throw UV('EBADF', 'close', this.path);
+        this.syncSync();
+        this.disposeSync();
+    }
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    disposeSync(force) {
+        if (this.closed)
+            throw UV('EBADF', 'close', this.path);
+        if (this.dirty && !force)
+            throw UV('EBUSY', 'close', this.path);
+        this.closed = true;
+    }
+    truncateSync(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.syncSync();
+    }
+    /**
+     * 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
+     */
+    writeSync(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.syncSync();
+        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
+     */
+    readSync(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.syncSync();
+        return end - position;
+    }
+    chmodSync(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.syncSync();
+    }
+    chownSync(uid, gid) {
+        if (this.closed)
+            throw UV('EBADF', 'chmod', this.path);
+        this.dirty = true;
+        _chown(this.inode, uid, gid);
+        if (this._isSync)
+            this.syncSync();
+    }
+    /**
+     * Change the file timestamps of the file.
+     */
+    utimesSync(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.syncSync();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    async sync() {
+        if (this.closed)
+            throw UV('EBADF', 'sync', this.path);
+        if (!this.dirty)
+            return;
+        if (!this.fs.attributes.has('no_write'))
+            await this.fs.touch(this.internalPath, this.inode);
+        this.dirty = false;
+    }
+    /**
+     * Default implementation maps to `sync`.
+     */
     datasync() {
         return this.sync();
     }
-    close() {
+    async close() {
         if (this.closed)
             throw UV('EBADF', 'close', this.path);
-        this.sync();
+        await this.sync();
         this.dispose();
     }
     /**
@@ -97,7 +239,7 @@ export class SyncHandle {
             throw UV('EBADF', 'stat', this.path);
         return this.inode;
     }
-    truncate(length) {
+    async truncate(length) {
         if (length < 0)
             throw UV('EINVAL', 'truncate', this.path);
         if (this.closed)
@@ -113,7 +255,7 @@ export class SyncHandle {
         this.inode.size = length;
         this.inode.ctimeMs = Date.now();
         if (this._isSync)
-            this.sync();
+            await this.sync();
     }
     /**
      * Write buffer to the file.
@@ -124,7 +266,7 @@ export class SyncHandle {
      * 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) {
+    async 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))
@@ -141,9 +283,9 @@ export class SyncHandle {
         this.inode.mtimeMs = Date.now();
         this.inode.ctimeMs = Date.now();
         this._position = position + slice.byteLength;
-        this.fs.writeSync(this.internalPath, slice, position);
+        await this.fs.write(this.internalPath, slice, position);
         if (this._isSync)
-            this.sync();
+            await this.sync();
         return slice.byteLength;
     }
     /**
@@ -155,7 +297,7 @@ export class SyncHandle {
      * 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) {
+    async 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)
@@ -170,38 +312,38 @@ export class SyncHandle {
         }
         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);
+        await this.fs.read(this.internalPath, uint8.subarray(offset, offset + length), position, end);
         if (this._isSync)
-            this.sync();
+            await this.sync();
         return end - position;
     }
-    chmod(mode) {
+    async 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();
+            await this.sync();
     }
-    chown(uid, gid) {
+    async chown(uid, gid) {
         if (this.closed)
-            throw UV('EBADF', 'chmod', this.path);
+            throw UV('EBADF', 'chown', this.path);
         this.dirty = true;
         _chown(this.inode, uid, gid);
         if (this._isSync)
-            this.sync();
+            await this.sync();
     }
     /**
      * Change the file timestamps of the file.
      */
-    utimes(atime, mtime) {
+    async 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();
+            await this.sync();
     }
     /**
      * Create a stream for reading the file.

package/dist/vfs/flags.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
-import * as c from './constants.js';
+import * as c from '../constants.js';
 export const pattern = /[rwasx]{1,2}\+?/;
 /**
  * @internal @hidden

package/dist/vfs/index.d.ts

@@ -1,10 +1,7 @@
 export * from './async.js';
-export * as constants from './constants.js';
 export * from './dir.js';
+export * from './file.js';
 export * from './ioctl.js';
-export * as promises from './promises.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 sync from './sync.js';
 export * as xattr from './xattr.js';

package/dist/vfs/index.js

@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 export * from './async.js';
-export * as constants from './constants.js';
 export * from './dir.js';
+export * from './file.js';
 export * from './ioctl.js';
-export * as promises from './promises.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 sync from './sync.js';
 export * as xattr from './xattr.js';

package/dist/vfs/shared.d.ts

@@ -2,6 +2,7 @@ import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { FileSystem } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
+import { type ExceptionExtra } from 'kerium';
 import { type AbsolutePath } from '../path.js';
 /**
  * @internal @hidden
@@ -46,7 +47,7 @@ export interface ResolvedPath extends ResolvedMount {
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
  * @internal @hidden
  */
-export declare function resolveMount(path: string, ctx: V_Context): ResolvedMount;
+export declare function resolveMount(path: string, ctx: V_Context, extra?: ExceptionExtra): ResolvedMount;
 /**
  * @internal @hidden
  */
@@ -56,3 +57,26 @@ export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?
  * @category Backends and Configuration
  */
 export declare function chroot(this: V_Context, path: string): void;
+export type FileContents = ArrayBufferView | string;
+/**
+ * @internal @hidden Used for the internal `_open` functions
+ */
+export interface OpenOptions {
+    flag: fs.OpenMode;
+    mode?: fs.Mode | null;
+    /**
+     * If true, do not resolve symlinks
+     */
+    preserveSymlinks?: boolean;
+    /**
+     * If true, allows opening directories
+     */
+    allowDirectory?: boolean;
+}
+export interface MkdirOptions {
+    mode?: number;
+    recursive?: boolean;
+}
+export interface ReaddirOptions {
+    recursive?: boolean;
+}

package/dist/vfs/shared.js

@@ -3,11 +3,12 @@
 import { Errno, Exception, UV, withErrno } from 'kerium';
 import { alert, debug, err, info, notice, warn } from 'kerium/log';
 import { InMemory } from '../backends/memory.js';
+import { size_max } from '../constants.js';
 import { defaultContext } from '../internal/contexts.js';
+import { credentialsAllowRoot } from '../internal/credentials.js';
+import { withExceptionContext } from '../internal/error.js';
 import { join, resolve } from '../path.js';
 import { normalizePath } from '../utils.js';
-import { size_max } from './constants.js';
-import { credentialsAllowRoot } from '../internal/credentials.js';
 /**
  * The map of mount points
  * @category Backends and Configuration
@@ -51,8 +52,9 @@ export function umount(mountPoint) {
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
  * @internal @hidden
  */
-export function resolveMount(path, ctx) {
+export function resolveMount(path, ctx, extra) {
     const root = ctx?.root || defaultContext.root;
+    const _exceptionContext = { path, ...extra };
     path = normalizePath(join(root, path));
     const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // descending order of the string length
     for (const [mountPoint, fs] of sortedMounts) {
@@ -67,7 +69,7 @@ export function resolveMount(path, ctx) {
             path = path.toLowerCase();
         if (case_fold === 'upper')
             path = path.toUpperCase();
-        return { fs, path, mountPoint, root };
+        return { fs: withExceptionContext(fs, _exceptionContext), path, mountPoint, root };
     }
     throw alert(new Exception(Errno.EIO, 'No file system for ' + path));
 }