@zenfs/core 0.16.4 → 0.17.1

package/dist/filesystem.js

@@ -1,52 +1,3 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        function next() {
-            while (env.stack.length) {
-                var rec = env.stack.pop();
-                try {
-                    var result = rec.dispose && rec.dispose.call(rec.value);
-                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { rootCred } from './cred.js';
-import { join } from './emulation/path.js';
-import { Errno, ErrnoError } from './error.js';
-import { PreloadFile, parseFlag } from './file.js';
 import { ZenFsType } from './stats.js';
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
@@ -74,7 +25,7 @@ export class FileSystem {
     constructor(...args) { }
     async ready() { }
     /**
-     * Test whether or not the given path exists by checking with the file system.
+     * Test whether or not the given path exists.
      */
     async exists(path, cred) {
         try {
@@ -86,7 +37,7 @@ export class FileSystem {
         }
     }
     /**
-     * Test whether or not the given path exists by checking with the file system.
+     * Test whether or not the given path exists.
      */
     existsSync(path, cred) {
         try {
@@ -98,265 +49,3 @@ export class FileSystem {
         }
     }
 }
-/**
- * Implements the asynchronous API in terms of the synchronous API.
- */
-export function Sync(FS) {
-    class SyncFS extends FS {
-        async exists(path, cred) {
-            return this.existsSync(path, cred);
-        }
-        async rename(oldPath, newPath, cred) {
-            return this.renameSync(oldPath, newPath, cred);
-        }
-        async stat(path, cred) {
-            return this.statSync(path, cred);
-        }
-        async createFile(path, flag, mode, cred) {
-            return this.createFileSync(path, flag, mode, cred);
-        }
-        async openFile(path, flag, cred) {
-            return this.openFileSync(path, flag, cred);
-        }
-        async unlink(path, cred) {
-            return this.unlinkSync(path, cred);
-        }
-        async rmdir(path, cred) {
-            return this.rmdirSync(path, cred);
-        }
-        async mkdir(path, mode, cred) {
-            return this.mkdirSync(path, mode, cred);
-        }
-        async readdir(path, cred) {
-            return this.readdirSync(path, cred);
-        }
-        async link(srcpath, dstpath, cred) {
-            return this.linkSync(srcpath, dstpath, cred);
-        }
-        async sync(path, data, stats) {
-            return this.syncSync(path, data, stats);
-        }
-    }
-    return SyncFS;
-}
-/**
- * Async() implements synchronous methods on an asynchronous file system
- *
- * Implementing classes must define `_sync` for the synchronous file system used as a cache.
- * Synchronous methods on an asynchronous FS are implemented by:
- *	- Performing operations over the in-memory copy,
- * 	while asynchronously pipelining them to the backing store.
- * 	- During loading, the contents of the async file system are preloaded into the synchronous store.
- *
- */
-export function Async(FS) {
-    class AsyncFS extends FS {
-        constructor() {
-            super(...arguments);
-            /**
-             * Queue of pending asynchronous operations.
-             */
-            this._queue = [];
-            this._isInitialized = false;
-        }
-        get _queueRunning() {
-            return !!this._queue.length;
-        }
-        queueDone() {
-            return new Promise(resolve => {
-                const check = () => (this._queueRunning ? setTimeout(check) : resolve());
-                check();
-            });
-        }
-        async ready() {
-            await super.ready();
-            if (this._isInitialized || this._disableSync) {
-                return;
-            }
-            this.checkSync();
-            await this._sync.ready();
-            try {
-                await this.crossCopy('/');
-                this._isInitialized = true;
-            }
-            catch (e) {
-                this._isInitialized = false;
-                throw e;
-            }
-        }
-        checkSync(path, syscall) {
-            if (this._disableSync) {
-                throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);
-            }
-            if (!this._sync) {
-                throw new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall);
-            }
-        }
-        renameSync(oldPath, newPath, cred) {
-            this.checkSync(oldPath, 'rename');
-            this._sync.renameSync(oldPath, newPath, cred);
-            this.queue('rename', oldPath, newPath, cred);
-        }
-        statSync(path, cred) {
-            this.checkSync(path, 'stat');
-            return this._sync.statSync(path, cred);
-        }
-        createFileSync(path, flag, mode, cred) {
-            this.checkSync(path, 'createFile');
-            this._sync.createFileSync(path, flag, mode, cred);
-            this.queue('createFile', path, flag, mode, cred);
-            return this.openFileSync(path, flag, cred);
-        }
-        openFileSync(path, flag, cred) {
-            this.checkSync(path, 'openFile');
-            const file = this._sync.openFileSync(path, flag, cred);
-            const stats = file.statSync();
-            const buffer = new Uint8Array(stats.size);
-            file.readSync(buffer);
-            return new PreloadFile(this, path, flag, stats, buffer);
-        }
-        unlinkSync(path, cred) {
-            this.checkSync(path, 'unlinkSync');
-            this._sync.unlinkSync(path, cred);
-            this.queue('unlink', path, cred);
-        }
-        rmdirSync(path, cred) {
-            this.checkSync(path, 'rmdir');
-            this._sync.rmdirSync(path, cred);
-            this.queue('rmdir', path, cred);
-        }
-        mkdirSync(path, mode, cred) {
-            this.checkSync(path, 'mkdir');
-            this._sync.mkdirSync(path, mode, cred);
-            this.queue('mkdir', path, mode, cred);
-        }
-        readdirSync(path, cred) {
-            this.checkSync(path, 'readdir');
-            return this._sync.readdirSync(path, cred);
-        }
-        linkSync(srcpath, dstpath, cred) {
-            this.checkSync(srcpath, 'link');
-            this._sync.linkSync(srcpath, dstpath, cred);
-            this.queue('link', srcpath, dstpath, cred);
-        }
-        syncSync(path, data, stats) {
-            this.checkSync(path, 'sync');
-            this._sync.syncSync(path, data, stats);
-            this.queue('sync', path, data, stats);
-        }
-        existsSync(path, cred) {
-            this.checkSync(path, 'exists');
-            return this._sync.existsSync(path, cred);
-        }
-        /**
-         * @internal
-         */
-        async crossCopy(path) {
-            this.checkSync(path, 'crossCopy');
-            const stats = await this.stat(path, rootCred);
-            if (stats.isDirectory()) {
-                if (path !== '/') {
-                    const stats = await this.stat(path, rootCred);
-                    this._sync.mkdirSync(path, stats.mode, stats.cred());
-                }
-                const files = await this.readdir(path, rootCred);
-                for (const file of files) {
-                    await this.crossCopy(join(path, file));
-                }
-            }
-            else {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const asyncFile = __addDisposableResource(env_1, await this.openFile(path, parseFlag('r'), rootCred), true);
-                    const syncFile = __addDisposableResource(env_1, this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats.cred()), false);
-                    const buffer = new Uint8Array(stats.size);
-                    await asyncFile.read(buffer);
-                    syncFile.writeSync(buffer, 0, stats.size);
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    const result_1 = __disposeResources(env_1);
-                    if (result_1)
-                        await result_1;
-                }
-            }
-        }
-        /**
-         * @internal
-         */
-        async _next() {
-            if (!this._queueRunning) {
-                return;
-            }
-            const [method, ...args] = this._queue.shift();
-            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-            await this[method](...args);
-            await this._next();
-        }
-        /**
-         * @internal
-         */
-        queue(...op) {
-            this._queue.push(op);
-            void this._next();
-        }
-    }
-    return AsyncFS;
-}
-/**
- * Implements the non-readonly methods to throw `EROFS`
- */
-export function Readonly(FS) {
-    class ReadonlyFS extends FS {
-        metadata() {
-            return { ...super.metadata(), readonly: true };
-        }
-        /* eslint-disable @typescript-eslint/no-unused-vars */
-        async rename(oldPath, newPath, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        renameSync(oldPath, newPath, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async createFile(path, flag, mode, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        createFileSync(path, flag, mode, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async unlink(path, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        unlinkSync(path, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async rmdir(path, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        rmdirSync(path, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async mkdir(path, mode, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        mkdirSync(path, mode, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async link(srcpath, dstpath, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        linkSync(srcpath, dstpath, cred) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        async sync(path, data, stats) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-        syncSync(path, data, stats) {
-            throw new ErrnoError(Errno.EROFS);
-        }
-    }
-    return ReadonlyFS;
-}

package/dist/index.d.ts

@@ -2,8 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/index/fs.js';
-export * from './backends/locked.js';
+export * from './backends/file_index.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';
 export * from './backends/store/simple.js';
@@ -14,6 +13,7 @@ export * from './cred.js';
 export * from './file.js';
 export * from './filesystem.js';
 export * from './inode.js';
+export * from './mixins/index.js';
 export * from './stats.js';
 export * from './utils.js';
 export * from './emulation/index.js';

package/dist/index.js

@@ -2,8 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/index/fs.js';
-export * from './backends/locked.js';
+export * from './backends/file_index.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';
 export * from './backends/store/simple.js';
@@ -14,6 +13,7 @@ export * from './cred.js';
 export * from './file.js';
 export * from './filesystem.js';
 export * from './inode.js';
+export * from './mixins/index.js';
 export * from './stats.js';
 export * from './utils.js';
 export * from './emulation/index.js';

package/dist/mixins/async.d.ts

@@ -0,0 +1,39 @@
+import { type Cred } from '../cred.js';
+import { type File } from '../file.js';
+import type { FileSystem } from '../filesystem.js';
+import type { Stats } from '../stats.js';
+import type { _AsyncFSMethods, Mixin } from './shared.js';
+/**
+ * @internal
+ */
+export type AsyncOperation = {
+    [K in keyof _AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
+}[keyof _AsyncFSMethods];
+/**
+ * Async() implements synchronous methods on an asynchronous file system
+ *
+ * Implementing classes must define `_sync` for the synchronous file system used as a cache.
+ * Synchronous methods on an asynchronous FS are implemented by:
+ *	- Performing operations over the in-memory copy,
+ * 	while asynchronously pipelining them to the backing store.
+ * 	- During loading, the contents of the async file system are preloaded into the synchronous store.
+ *
+ */
+export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
+    /**
+     * @internal @protected
+     */
+    _sync?: FileSystem;
+    queueDone(): Promise<void>;
+    ready(): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    statSync(path: string, cred: Cred): Stats;
+    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
+    openFileSync(path: string, flag: string, cred: Cred): File;
+    unlinkSync(path: string, cred: Cred): void;
+    rmdirSync(path: string, cred: Cred): void;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
+    readdirSync(path: string, cred: Cred): string[];
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}>;

package/dist/mixins/async.js

@@ -0,0 +1,216 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { rootCred } from '../cred.js';
+import { join } from '../emulation/path.js';
+import { Errno, ErrnoError } from '../error.js';
+import { PreloadFile, parseFlag } from '../file.js';
+/**
+ * Async() implements synchronous methods on an asynchronous file system
+ *
+ * Implementing classes must define `_sync` for the synchronous file system used as a cache.
+ * Synchronous methods on an asynchronous FS are implemented by:
+ *	- Performing operations over the in-memory copy,
+ * 	while asynchronously pipelining them to the backing store.
+ * 	- During loading, the contents of the async file system are preloaded into the synchronous store.
+ *
+ */
+export function Async(FS) {
+    class AsyncFS extends FS {
+        constructor() {
+            super(...arguments);
+            /**
+             * Queue of pending asynchronous operations.
+             */
+            this._queue = [];
+            this._isInitialized = false;
+        }
+        get _queueRunning() {
+            return !!this._queue.length;
+        }
+        queueDone() {
+            return new Promise(resolve => {
+                const check = () => (this._queueRunning ? setTimeout(check) : resolve());
+                check();
+            });
+        }
+        async ready() {
+            await super.ready();
+            if (this._isInitialized || this._disableSync) {
+                return;
+            }
+            this.checkSync();
+            await this._sync.ready();
+            try {
+                await this.crossCopy('/');
+                this._isInitialized = true;
+            }
+            catch (e) {
+                this._isInitialized = false;
+                throw e;
+            }
+        }
+        checkSync(path, syscall) {
+            if (this._disableSync) {
+                throw new ErrnoError(Errno.ENOTSUP, 'Sync caching has been disabled for this async file system', path, syscall);
+            }
+            if (!this._sync) {
+                throw new ErrnoError(Errno.ENOTSUP, 'No sync cache is attached to this async file system', path, syscall);
+            }
+        }
+        renameSync(oldPath, newPath, cred) {
+            this.checkSync(oldPath, 'rename');
+            this._sync.renameSync(oldPath, newPath, cred);
+            this.queue('rename', oldPath, newPath, cred);
+        }
+        statSync(path, cred) {
+            this.checkSync(path, 'stat');
+            return this._sync.statSync(path, cred);
+        }
+        createFileSync(path, flag, mode, cred) {
+            this.checkSync(path, 'createFile');
+            this._sync.createFileSync(path, flag, mode, cred);
+            this.queue('createFile', path, flag, mode, cred);
+            return this.openFileSync(path, flag, cred);
+        }
+        openFileSync(path, flag, cred) {
+            this.checkSync(path, 'openFile');
+            const file = this._sync.openFileSync(path, flag, cred);
+            const stats = file.statSync();
+            const buffer = new Uint8Array(stats.size);
+            file.readSync(buffer);
+            return new PreloadFile(this, path, flag, stats, buffer);
+        }
+        unlinkSync(path, cred) {
+            this.checkSync(path, 'unlinkSync');
+            this._sync.unlinkSync(path, cred);
+            this.queue('unlink', path, cred);
+        }
+        rmdirSync(path, cred) {
+            this.checkSync(path, 'rmdir');
+            this._sync.rmdirSync(path, cred);
+            this.queue('rmdir', path, cred);
+        }
+        mkdirSync(path, mode, cred) {
+            this.checkSync(path, 'mkdir');
+            this._sync.mkdirSync(path, mode, cred);
+            this.queue('mkdir', path, mode, cred);
+        }
+        readdirSync(path, cred) {
+            this.checkSync(path, 'readdir');
+            return this._sync.readdirSync(path, cred);
+        }
+        linkSync(srcpath, dstpath, cred) {
+            this.checkSync(srcpath, 'link');
+            this._sync.linkSync(srcpath, dstpath, cred);
+            this.queue('link', srcpath, dstpath, cred);
+        }
+        syncSync(path, data, stats) {
+            this.checkSync(path, 'sync');
+            this._sync.syncSync(path, data, stats);
+            this.queue('sync', path, data, stats);
+        }
+        existsSync(path, cred) {
+            this.checkSync(path, 'exists');
+            return this._sync.existsSync(path, cred);
+        }
+        /**
+         * @internal
+         */
+        async crossCopy(path) {
+            this.checkSync(path, 'crossCopy');
+            const stats = await this.stat(path, rootCred);
+            if (stats.isDirectory()) {
+                if (path !== '/') {
+                    const stats = await this.stat(path, rootCred);
+                    this._sync.mkdirSync(path, stats.mode, stats.cred());
+                }
+                const files = await this.readdir(path, rootCred);
+                for (const file of files) {
+                    await this.crossCopy(join(path, file));
+                }
+            }
+            else {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const asyncFile = __addDisposableResource(env_1, await this.openFile(path, parseFlag('r'), rootCred), true);
+                    const syncFile = __addDisposableResource(env_1, this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats.cred()), false);
+                    const buffer = new Uint8Array(stats.size);
+                    await asyncFile.read(buffer);
+                    syncFile.writeSync(buffer, 0, stats.size);
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    const result_1 = __disposeResources(env_1);
+                    if (result_1)
+                        await result_1;
+                }
+            }
+        }
+        /**
+         * @internal
+         */
+        async _next() {
+            if (!this._queueRunning) {
+                return;
+            }
+            const [method, ...args] = this._queue.shift();
+            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
+            await this[method](...args);
+            await this._next();
+        }
+        /**
+         * @internal
+         */
+        queue(...op) {
+            this._queue.push(op);
+            void this._next();
+        }
+    }
+    return AsyncFS;
+}

package/dist/mixins/index.d.ts

@@ -0,0 +1,4 @@
+export * from './async.js';
+export * from './mutexed.js';
+export * from './readonly.js';
+export * from './sync.js';

package/dist/mixins/index.js

@@ -0,0 +1,4 @@
+export * from './async.js';
+export * from './mutexed.js';
+export * from './readonly.js';
+export * from './sync.js';

package/dist/mixins/mutexed.d.ts

@@ -0,0 +1,33 @@
+import type { FileSystem } from '../filesystem.js';
+import '../polyfills.js';
+import type { Mixin } from './shared.js';
+export declare class MutexLock {
+    readonly path: string;
+    protected readonly previous?: MutexLock | undefined;
+    protected current: PromiseWithResolvers<void>;
+    protected _isLocked: boolean;
+    get isLocked(): boolean;
+    constructor(path: string, previous?: MutexLock | undefined);
+    done(): Promise<void>;
+    unlock(): void;
+    [Symbol.dispose](): void;
+}
+/**
+ * This serializes access to an underlying async filesystem.
+ * For example, on an OverlayFS instance with an async lower
+ * directory operations like rename and rmdir may involve multiple
+ * requests involving both the upper and lower filesystems -- they
+ * are not executed in a single atomic step. OverlayFS uses this
+ * to avoid having to reason about the correctness of
+ * multiple requests interleaving.
+ *
+ * Note: `@ts-expect-error 2513` is needed because `FS` is not properly detected as being concrete
+ *
+ * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
+ * @internal
+ */
+export declare function Mutexed<T extends new (...args: any[]) => FileSystem>(FS: T): Mixin<T, {
+    lock(path: string): Promise<MutexLock>;
+    lockSync(path: string): MutexLock;
+    isLocked(path: string): boolean;
+}>;