@zenfs/core 2.7.5 → 2.7.7

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

@@ -55,7 +55,7 @@ import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
-import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
+import { assertRemovable, hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
 import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import '../polyfills.js';
 import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
@@ -63,8 +63,7 @@ import * as _async from '../vfs/async.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
-import { _statfs, resolveMount } from '../vfs/shared.js';
-import { cacheOf, lockPath } from '../vfs/vcache.js';
+import { _statfs } from '../vfs/shared.js';
 import { emitChange, FSWatcher } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { createInterface } from './readline.js';
@@ -535,7 +534,7 @@ export async function exists(path) {
         return await fs.exists(resolved);
     }
     catch (e) {
-        if (e instanceof Exception && e.code == 'ENOENT') {
+        if (e instanceof Exception && (e.code == 'ENOENT' || e.code == 'ENOTDIR' || e.code == 'EACCES')) {
             return false;
         }
         throw e;
@@ -580,14 +579,13 @@ export async function unlink(path) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = resolveMount(path, this);
         const $ex = { syscall: 'unlink', path };
-        const stats = await fs.stat(resolved).catch(rethrow($ex));
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', $ex);
-        const _ = __addDisposableResource(env_2, await lockPath(fs, dirname(resolved), 'rw'), false);
+        const { fs, cache, path: resolved } = await _async.resolve(this, path, true, $ex);
+        const stats = await cache.stat(resolved).catch(rethrow($ex));
+        assertRemovable(this, await cache.stat(dirname(resolved)).catch(rethrow($ex)), stats, $ex);
+        const _ = __addDisposableResource(env_2, await cache.lock(dirname(resolved), 'rw'), false);
         await fs.unlink(resolved).catch(rethrow($ex));
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_2) {
@@ -692,18 +690,17 @@ export async function rmdir(path) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = await _async.resolve(this, path);
+        const { fs, cache, path: resolved } = await _async.resolve(this, path, true);
         const $ex = { syscall: 'rmdir', path };
-        const stats = await fs.stat(resolved).catch(rethrow($ex));
+        const stats = await cache.stat(resolved).catch(rethrow($ex));
         if (!stats)
             throw UV('ENOENT', $ex);
         if (!isDirectory(stats))
             throw UV('ENOTDIR', $ex);
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', $ex);
-        const _ = __addDisposableResource(env_6, await lockPath(fs, dirname(resolved), 'rw'), false);
+        assertRemovable(this, await cache.stat(dirname(resolved)).catch(rethrow($ex)), stats, $ex);
+        const _ = __addDisposableResource(env_6, await cache.lock(dirname(resolved), 'rw'), false);
         await fs.rmdir(resolved).catch(rethrow($ex));
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_6) {
@@ -761,7 +758,7 @@ export async function symlink(dest, path, type = 'file') {
         const handle = __addDisposableResource(env_7, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         const encoded = encodeUTF8(normalizePath.call(this, dest, true));
         await handle.write(encoded, 0, encoded.length, 0);
-        await handle.chmod(constants.S_IFLNK);
+        await handle.chmod(constants.S_IFLNK | 0o777);
     }
     catch (e_7) {
         env_7.error = e_7;
@@ -1018,7 +1015,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 +1022,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.
@@ -1079,8 +1076,7 @@ export async function cp(source, destination, opts) {
             const [entries] = await Promise.all([
                 readdir.call(this, source, { withFileTypes: true }),
                 mkdir.call(this, destination, { recursive: true }),
-            ] // Ensure the destination directory exists
-            );
+            ]);
             const _cp = async (dirent) => {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
                     return; // Skip if the filter returns false
@@ -1117,8 +1113,8 @@ export async function cp(source, destination, opts) {
 cp;
 export async function statfs(path, opts) {
     path = normalizePath.call(this, path);
-    const { fs } = resolveMount(path, this);
-    return Promise.resolve(_statfs(fs, opts?.bigint));
+    const { fs } = await _async.resolve(this, path);
+    return _statfs(fs, opts?.bigint);
 }
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];