@zenfs/core 2.7.5 → 2.7.6

package/dist/internal/rpc.js

@@ -160,11 +160,6 @@ export function request(request, { port, timeout: ms = 1000, fs }) {
     port.send({ ...request, _zenfs: true, id, stack });
     return promise;
 }
-// Why Typescript, WHY does the type need to be asserted even when the method is explicitly checked?
-function __requestMethod(req) { }
-function __responseMethod(res, ...t) {
-    return t.includes(res.method);
-}
 export function handleResponse(response) {
     if (!isMessage(response))
         return;
@@ -182,7 +177,7 @@ export function handleResponse(response) {
         return;
     }
     disposeExecutors(response.id);
-    resolve(__responseMethod(response, 'stat', 'createFile', 'mkdir') ? new Inode(response.value) : response.value);
+    resolve(['stat', 'createFile', 'mkdir'].includes(response.method) ? new Inode(response.value) : response.value);
     return;
 }
 export function attach(port, handler) {
@@ -214,11 +209,9 @@ export async function handleRequest(port, fs, request) {
     if (!isMessage(request))
         return;
     let value, error;
-    const transferList = [];
     try {
         switch (request.method) {
             case 'read': {
-                __requestMethod(request);
                 const [path, buffer, start, end] = request.args;
                 await fs.read(path, buffer, start, end);
                 value = buffer;
@@ -227,7 +220,6 @@ export async function handleRequest(port, fs, request) {
             case 'stat':
             case 'createFile':
             case 'mkdir': {
-                __requestMethod(request);
                 // @ts-expect-error 2556
                 const md = await fs[request.method](...request.args);
                 const inode = md instanceof Inode ? md : new Inode(md);
@@ -235,7 +227,6 @@ export async function handleRequest(port, fs, request) {
                 break;
             }
             case 'touch': {
-                __requestMethod(request);
                 const [path, metadata] = request.args;
                 await fs.touch(path, new Inode(metadata));
                 value = undefined;
@@ -249,5 +240,5 @@ export async function handleRequest(port, fs, request) {
     catch (e) {
         error = e instanceof Exception ? e.toJSON() : pick(e, 'message', 'stack');
     }
-    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value }, transferList);
+    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value });
 }

package/dist/mixins/mutexed.d.ts

@@ -1,28 +1,17 @@
+import { RwLockable } from 'kerium/locks';
 import type { UUID } from 'node:crypto';
 import type { Concrete } from 'utilium';
 import type { CreationOptions, FileSystem, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { IoctlContext } from '../internal/ioctl.js';
 import '../polyfills.js';
-/**
- * @category Internals
- * @internal
- */
-export declare class MutexLock {
-    protected readonly previous?: MutexLock | undefined;
-    protected current: PromiseWithResolvers<void>;
-    protected _isLocked: boolean;
-    get isLocked(): boolean;
-    constructor(previous?: MutexLock | undefined);
-    done(): Promise<void>;
-    unlock(): void;
-    [Symbol.dispose](): void;
-}
 /**
  * @hidden
  * @category Internals
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
-export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
+export declare class _MutexedFS<T extends FileSystem> extends RwLockable implements FileSystem {
     /**
      * @internal
      */
@@ -38,31 +27,6 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     ready(): Promise<void>;
     readySync(): void;
     usage(): UsageInfo;
-    /**
-     * The current locks
-     */
-    private currentLock?;
-    /**
-     * Adds a lock for a path
-     */
-    protected addLock(): MutexLock;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, waits for it to be unlocked.
-     * @internal
-     */
-    lock(timeout?: number): Promise<MutexLock>;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, an error will be thrown
-     * @internal
-     */
-    lockSync(): MutexLock;
-    /**
-     * Whether `path` is locked
-     * @internal
-     */
-    get isLocked(): boolean;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
     stat(path: string): Promise<InodeLike>;
@@ -110,9 +74,10 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
  * @category Internals
  * @internal
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
 export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof _MutexedFS<InstanceType<T>> & {
     new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;

package/dist/mixins/mutexed.js

@@ -51,40 +51,15 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { withErrno } from 'kerium';
-import { err } from 'kerium/log';
+import { RwLockable } from 'kerium/locks';
 import '../polyfills.js';
-/**
- * @category Internals
- * @internal
- */
-export class MutexLock {
-    previous;
-    current = Promise.withResolvers();
-    _isLocked = true;
-    get isLocked() {
-        return this._isLocked;
-    }
-    constructor(previous) {
-        this.previous = previous;
-    }
-    async done() {
-        await this.previous?.done();
-        await this.current.promise;
-    }
-    unlock() {
-        this.current.resolve();
-        this._isLocked = false;
-    }
-    [Symbol.dispose]() {
-        this.unlock();
-    }
-}
 /**
  * @hidden
  * @category Internals
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
-export class _MutexedFS {
+export class _MutexedFS extends RwLockable {
     /**
      * @internal
      */
@@ -122,59 +97,10 @@ export class _MutexedFS {
     usage() {
         return this._fs.usage();
     }
-    /**
-     * The current locks
-     */
-    currentLock;
-    /**
-     * Adds a lock for a path
-     */
-    addLock() {
-        const lock = new MutexLock(this.currentLock);
-        this.currentLock = lock;
-        return lock;
-    }
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, waits for it to be unlocked.
-     * @internal
-     */
-    async lock(timeout = 5000) {
-        const previous = this.currentLock;
-        const lock = this.addLock();
-        const stack = new Error().stack;
-        setTimeout(() => {
-            if (lock.isLocked) {
-                const error = withErrno('EDEADLK');
-                error.stack += stack?.slice('Error'.length);
-                throw err(error);
-            }
-        }, timeout);
-        await previous?.done();
-        return lock;
-    }
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, an error will be thrown
-     * @internal
-     */
-    lockSync() {
-        if (this.currentLock?.isLocked) {
-            throw err(withErrno('EBUSY'));
-        }
-        return this.addLock();
-    }
-    /**
-     * Whether `path` is locked
-     * @internal
-     */
-    get isLocked() {
-        return !!this.currentLock?.isLocked;
-    }
     async rename(oldPath, newPath) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_1, await this.lock(), false);
+            const _ = __addDisposableResource(env_1, await this.lock('rw'), false);
             await this._fs.rename(oldPath, newPath);
         }
         catch (e_1) {
@@ -188,7 +114,7 @@ export class _MutexedFS {
     renameSync(oldPath, newPath) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_2, this.lockSync(), false);
+            const _ = __addDisposableResource(env_2, this.lockSync('rw'), false);
             return this._fs.renameSync(oldPath, newPath);
         }
         catch (e_2) {
@@ -202,7 +128,7 @@ export class _MutexedFS {
     async stat(path) {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_3, await this.lock(), false);
+            const _ = __addDisposableResource(env_3, await this.lock('ro'), false);
             return await this._fs.stat(path);
         }
         catch (e_3) {
@@ -216,7 +142,7 @@ export class _MutexedFS {
     statSync(path) {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_4, this.lockSync(), false);
+            const _ = __addDisposableResource(env_4, this.lockSync('ro'), false);
             return this._fs.statSync(path);
         }
         catch (e_4) {
@@ -230,7 +156,7 @@ export class _MutexedFS {
     async touch(path, metadata) {
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_5, await this.lock(), false);
+            const _ = __addDisposableResource(env_5, await this.lock('rw'), false);
             await this._fs.touch(path, metadata);
         }
         catch (e_5) {
@@ -244,7 +170,7 @@ export class _MutexedFS {
     touchSync(path, metadata) {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_6, this.lockSync(), false);
+            const _ = __addDisposableResource(env_6, this.lockSync('rw'), false);
             this._fs.touchSync(path, metadata);
         }
         catch (e_6) {
@@ -258,7 +184,7 @@ export class _MutexedFS {
     async createFile(path, options) {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_7, await this.lock(), false);
+            const _ = __addDisposableResource(env_7, await this.lock('rw'), false);
             return await this._fs.createFile(path, options);
         }
         catch (e_7) {
@@ -272,7 +198,7 @@ export class _MutexedFS {
     createFileSync(path, options) {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_8, this.lockSync(), false);
+            const _ = __addDisposableResource(env_8, this.lockSync('rw'), false);
             return this._fs.createFileSync(path, options);
         }
         catch (e_8) {
@@ -286,7 +212,7 @@ export class _MutexedFS {
     async unlink(path) {
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_9, await this.lock(), false);
+            const _ = __addDisposableResource(env_9, await this.lock('rw'), false);
             await this._fs.unlink(path);
         }
         catch (e_9) {
@@ -300,7 +226,7 @@ export class _MutexedFS {
     unlinkSync(path) {
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_10, this.lockSync(), false);
+            const _ = __addDisposableResource(env_10, this.lockSync('rw'), false);
             return this._fs.unlinkSync(path);
         }
         catch (e_10) {
@@ -314,7 +240,7 @@ export class _MutexedFS {
     async rmdir(path) {
         const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_11, await this.lock(), false);
+            const _ = __addDisposableResource(env_11, await this.lock('rw'), false);
             await this._fs.rmdir(path);
         }
         catch (e_11) {
@@ -328,7 +254,7 @@ export class _MutexedFS {
     rmdirSync(path) {
         const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_12, this.lockSync(), false);
+            const _ = __addDisposableResource(env_12, this.lockSync('rw'), false);
             return this._fs.rmdirSync(path);
         }
         catch (e_12) {
@@ -342,7 +268,7 @@ export class _MutexedFS {
     async mkdir(path, options) {
         const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_13, await this.lock(), false);
+            const _ = __addDisposableResource(env_13, await this.lock('rw'), false);
             return await this._fs.mkdir(path, options);
         }
         catch (e_13) {
@@ -356,7 +282,7 @@ export class _MutexedFS {
     mkdirSync(path, options) {
         const env_14 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_14, this.lockSync(), false);
+            const _ = __addDisposableResource(env_14, this.lockSync('rw'), false);
             return this._fs.mkdirSync(path, options);
         }
         catch (e_14) {
@@ -370,7 +296,7 @@ export class _MutexedFS {
     async readdir(path) {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_15, await this.lock(), false);
+            const _ = __addDisposableResource(env_15, await this.lock('ro'), false);
             return await this._fs.readdir(path);
         }
         catch (e_15) {
@@ -384,7 +310,7 @@ export class _MutexedFS {
     readdirSync(path) {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_16, this.lockSync(), false);
+            const _ = __addDisposableResource(env_16, this.lockSync('ro'), false);
             return this._fs.readdirSync(path);
         }
         catch (e_16) {
@@ -398,7 +324,7 @@ export class _MutexedFS {
     async exists(path) {
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_17, await this.lock(), false);
+            const _ = __addDisposableResource(env_17, await this.lock('ro'), false);
             return await this._fs.exists(path);
         }
         catch (e_17) {
@@ -412,7 +338,7 @@ export class _MutexedFS {
     existsSync(path) {
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_18, this.lockSync(), false);
+            const _ = __addDisposableResource(env_18, this.lockSync('ro'), false);
             return this._fs.existsSync(path);
         }
         catch (e_18) {
@@ -426,7 +352,7 @@ export class _MutexedFS {
     async link(srcpath, dstpath) {
         const env_19 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_19, await this.lock(), false);
+            const _ = __addDisposableResource(env_19, await this.lock('rw'), false);
             await this._fs.link(srcpath, dstpath);
         }
         catch (e_19) {
@@ -440,7 +366,7 @@ export class _MutexedFS {
     linkSync(srcpath, dstpath) {
         const env_20 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_20, this.lockSync(), false);
+            const _ = __addDisposableResource(env_20, this.lockSync('rw'), false);
             return this._fs.linkSync(srcpath, dstpath);
         }
         catch (e_20) {
@@ -454,7 +380,7 @@ export class _MutexedFS {
     async sync() {
         const env_21 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_21, await this.lock(), false);
+            const _ = __addDisposableResource(env_21, await this.lock('rw'), false);
             await this._fs.sync();
         }
         catch (e_21) {
@@ -468,7 +394,7 @@ export class _MutexedFS {
     syncSync() {
         const env_22 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_22, this.lockSync(), false);
+            const _ = __addDisposableResource(env_22, this.lockSync('rw'), false);
             return this._fs.syncSync();
         }
         catch (e_22) {
@@ -482,7 +408,7 @@ export class _MutexedFS {
     async read(path, buffer, offset, end) {
         const env_23 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_23, await this.lock(), false);
+            const _ = __addDisposableResource(env_23, await this.lock('ro'), false);
             return await this._fs.read(path, buffer, offset, end);
         }
         catch (e_23) {
@@ -496,7 +422,7 @@ export class _MutexedFS {
     readSync(path, buffer, offset, end) {
         const env_24 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_24, this.lockSync(), false);
+            const _ = __addDisposableResource(env_24, this.lockSync('ro'), false);
             return this._fs.readSync(path, buffer, offset, end);
         }
         catch (e_24) {
@@ -510,7 +436,7 @@ export class _MutexedFS {
     async write(path, buffer, offset) {
         const env_25 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_25, await this.lock(), false);
+            const _ = __addDisposableResource(env_25, await this.lock('rw'), false);
             return await this._fs.write(path, buffer, offset);
         }
         catch (e_25) {
@@ -524,7 +450,7 @@ export class _MutexedFS {
     writeSync(path, buffer, offset) {
         const env_26 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_26, this.lockSync(), false);
+            const _ = __addDisposableResource(env_26, this.lockSync('rw'), false);
             return this._fs.writeSync(path, buffer, offset);
         }
         catch (e_26) {
@@ -538,7 +464,7 @@ export class _MutexedFS {
     streamRead(path, options) {
         const env_27 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_27, this.lockSync(), false);
+            const _ = __addDisposableResource(env_27, this.lockSync('ro'), false);
             return this._fs.streamRead(path, options);
         }
         catch (e_27) {
@@ -552,7 +478,7 @@ export class _MutexedFS {
     streamWrite(path, options) {
         const env_28 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_28, this.lockSync(), false);
+            const _ = __addDisposableResource(env_28, this.lockSync('rw'), false);
             return this._fs.streamWrite(path, options);
         }
         catch (e_28) {
@@ -566,7 +492,7 @@ export class _MutexedFS {
     async ioctl(context, command, ...args) {
         const env_29 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_29, await this.lock(), false);
+            const _ = __addDisposableResource(env_29, await this.lock('rw'), false);
             return await this._fs.ioctl({ ...context, fs: this._fs }, command, ...args);
         }
         catch (e_29) {
@@ -580,7 +506,7 @@ export class _MutexedFS {
     ioctlSync(context, command, ...args) {
         const env_30 = { stack: [], error: void 0, hasError: false };
         try {
-            const _ = __addDisposableResource(env_30, this.lockSync(), false);
+            const _ = __addDisposableResource(env_30, this.lockSync('rw'), false);
             return this._fs.ioctlSync({ ...context, fs: this._fs }, command, ...args);
         }
         catch (e_30) {
@@ -608,9 +534,10 @@ export class _MutexedFS {
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
  * @category Internals
  * @internal
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
 export function Mutexed(FS) {
     class MutexedFS extends _MutexedFS {

package/dist/mixins/sync.js

@@ -2,7 +2,6 @@
  * Implements the asynchronous API in terms of the synchronous API.
  * @category Internals
  */
-/* eslint-disable @typescript-eslint/require-await */
 export function Sync(FS) {
     class SyncFS extends FS {
         async exists(path) {
@@ -50,4 +49,3 @@ export function Sync(FS) {
     }
     return SyncFS;
 }
-/* eslint-enable @typescript-eslint/require-await */

package/dist/node/async.js

@@ -7,16 +7,6 @@ import * as promises from './promises.js';
 import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 const nop = () => { };
-/**
- * Helper to collect an async iterator into an array
- */
-async function collectAsyncIterator(it) {
-    const results = [];
-    for await (const result of it) {
-        results.push(result);
-    }
-    return results;
-}
 /**
  * Asynchronous rename. No arguments other than a possible exception are given to the completion callback.
  */
@@ -400,7 +390,7 @@ watch;
 export function createReadStream(path, options) {
     options = typeof options == 'object' ? options : { encoding: options };
     const _handle = promises.open.call(this, path, 'r', options?.mode);
-    return new ReadStream({ ...options, autoClose: true }, _handle);
+    return new ReadStream({ ...options, autoClose: true, signal: options?.signal ?? undefined }, _handle);
 }
 createReadStream;
 /**
@@ -490,7 +480,7 @@ openAsBlob;
 export function glob(pattern, options, callback = nop) {
     callback = typeof options == 'function' ? options : callback;
     const it = promises.glob.call(this, pattern, typeof options === 'function' ? undefined : options);
-    collectAsyncIterator(it)
+    Array.fromAsync(it)
         .then(results => callback(null, results ?? []))
         .catch((e) => callback(e));
 }

package/dist/node/index.d.ts

@@ -3,7 +3,7 @@ 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 type { StatsLike } from '../internal/inode.js';
 export * from './streams.js';
 export * from './sync.js';
 export { Utf8Stream } from './utf8stream.js';

package/dist/node/promises.d.ts

@@ -356,13 +356,8 @@ export declare function mkdtemp(this: V_Context, prefix: string, options?: fs.Bu
  * When the object is disposed, the directory and its contents will be removed asynchronously if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has an async `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
-export declare function mkdtempDisposable(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): Promise<{
-    path: string;
-    remove(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}>;
+export declare function mkdtempDisposable(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): Promise<promises.DisposableTempDir>;
 /**
  * Asynchronous `copyFile`. Copies a file.
  * @param src The source file.

package/dist/node/promises.js

@@ -1018,7 +1018,6 @@ mkdtemp;
  * When the object is disposed, the directory and its contents will be removed asynchronously if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has an async `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
 export async function mkdtempDisposable(prefix, options) {
     const path = _tempDirName(prefix);
@@ -1026,6 +1025,7 @@ export async function mkdtempDisposable(prefix, options) {
     const remove = () => rm(path, { recursive: true, force: true });
     return { path, remove, [Symbol.asyncDispose]: remove };
 }
+mkdtempDisposable;
 /**
  * Asynchronous `copyFile`. Copies a file.
  * @param src The source file.