@zenfs/core 1.7.2 → 1.8.0

package/dist/backends/backend.js

@@ -20,8 +20,8 @@ export async function checkOptions(backend, options) {
             }
             throw new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName);
         }
-        const isType = (value) => (typeof opt.type == 'function' ? value instanceof opt.type : typeof value === opt.type);
-        if (Array.isArray(opt.type) ? !opt.type.some(isType) : !isType(value)) {
+        const isType = (type, _ = value) => (typeof type == 'function' ? value instanceof type : typeof value === type);
+        if (Array.isArray(opt.type) ? !opt.type.some(v => isType(v)) : !isType(opt.type)) {
             // The type of the value as a string
             const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
             // The expected type (as a string)
@@ -29,9 +29,8 @@ export async function checkOptions(backend, options) {
             const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
             throw new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`);
         }
-        if (opt.validator) {
+        if (opt.validator)
             await opt.validator(value);
-        }
         // Otherwise: All good!
     }
 }

package/dist/backends/fetch.d.ts

@@ -1,7 +1,6 @@
-import type { FileSystemMetadata } from '../filesystem.js';
-import type { Stats } from '../stats.js';
-import type { IndexData } from './file_index.js';
-import { IndexFS } from './file_index.js';
+import { StoreFS } from './store/fs.js';
+import { type IndexData } from './store/file_index.js';
+import type { Store } from './store/store.js';
 /**
  * Configuration options for FetchFS.
  */
@@ -19,6 +18,11 @@ export interface FetchOptions {
      * Default: Fetch files relative to the index.
      */
     baseUrl?: string;
+    /**
+     * A store to use for caching content.
+     * Defaults to an in-memory store
+     */
+    cache?: Store;
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
@@ -31,7 +35,7 @@ export interface FetchOptions {
  * 	"version": 1,
  * 	"entries": {
  * 		"/home": { ... },
- * 		"/home/jvilk": { ... },
+ * 		"/home/john": { ... },
  * 		"/home/james": { ... }
  * 	}
  * }
@@ -39,21 +43,12 @@ export interface FetchOptions {
  *
  * Each entry contains the stats associated with the file.
  */
-export declare class FetchFS extends IndexFS {
+export declare class FetchFS extends StoreFS {
     readonly baseUrl: string;
-    readonly requestInit?: RequestInit;
+    readonly requestInit?: RequestInit | undefined;
+    private indexData;
     ready(): Promise<void>;
-    constructor({ index, baseUrl, requestInit }: FetchOptions);
-    metadata(): FileSystemMetadata;
-    /**
-     * Preload the `path` into the index.
-     */
-    preload(path: string, buffer: Uint8Array): void;
-    /**
-     * @todo Be lazier about actually requesting the data?
-     */
-    protected getData(path: string, stats: Stats): Promise<Uint8Array>;
-    protected getDataSync(path: string, stats: Stats): Uint8Array;
+    constructor(index?: IndexData | string, cache?: Store, baseUrl?: string, requestInit?: RequestInit | undefined);
 }
 declare const _Fetch: {
     readonly name: "Fetch";
@@ -70,6 +65,10 @@ declare const _Fetch: {
             readonly type: "object";
             readonly required: false;
         };
+        readonly cache: {
+            readonly type: "object";
+            readonly required: false;
+        };
     };
     readonly isAvailable: () => boolean;
     readonly create: (options: FetchOptions) => FetchFS;

package/dist/backends/fetch.js

@@ -1,5 +1,61 @@
+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, inner;
+        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 (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        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;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            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 { Errno, ErrnoError } from '../error.js';
-import { IndexFS } from './file_index.js';
+import { S_IFREG } from '../vfs/constants.js';
+import { InMemoryStore } from './memory.js';
+import { StoreFS } from './store/fs.js';
+import { Index } from './store/file_index.js';
+import { normalizePath } from '../utils.js';
 async function fetchFile(path, type, init) {
     const response = await fetch(path, init).catch((e) => {
         throw new ErrnoError(Errno.EIO, e.message, path);
@@ -33,7 +89,7 @@ async function fetchFile(path, type, init) {
  * 	"version": 1,
  * 	"entries": {
  * 		"/home": { ... },
- * 		"/home/jvilk": { ... },
+ * 		"/home/john": { ... },
  * 		"/home/james": { ... }
  * 	}
  * }
@@ -41,68 +97,46 @@ async function fetchFile(path, type, init) {
  *
  * Each entry contains the stats associated with the file.
  */
-export class FetchFS extends IndexFS {
+export class FetchFS extends StoreFS {
     async ready() {
-        if (this._isInitialized) {
-            return;
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (this._initialized)
+                return;
+            await super.ready();
+            const index = new Index();
+            index.fromJSON(await this.indexData);
+            await this.loadIndex(index);
+            if (this._disableSync)
+                return;
+            const tx = __addDisposableResource(env_1, this.store.transaction(), true);
+            // Iterate over all of the files and cache their contents
+            for (const [path, node] of index) {
+                if (!(node.mode & S_IFREG))
+                    continue;
+                const content = await fetchFile(this.baseUrl + path, 'buffer', this.requestInit);
+                await tx.set(node.data, content);
+            }
+            await tx.commit();
         }
-        await super.ready();
-        if (this._disableSync) {
-            return;
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
-        /**
-         * Iterate over all of the files and cache their contents
-         */
-        for (const [path, stats] of this.index.files()) {
-            await this.getData(path, stats);
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
         }
     }
-    constructor({ index = 'index.json', baseUrl = '', requestInit }) {
-        // prefix url must end in a directory separator.
-        if (baseUrl.at(-1) != '/') {
-            baseUrl += '/';
-        }
-        super(typeof index != 'string' ? index : fetchFile(index, 'json', requestInit));
+    constructor(index = 'index.json', cache = new InMemoryStore('fetch'), baseUrl = '', requestInit) {
+        super(cache);
         this.baseUrl = baseUrl;
         this.requestInit = requestInit;
-    }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: FetchFS.name,
-            readonly: true,
-        };
-    }
-    /**
-     * Preload the `path` into the index.
-     */
-    preload(path, buffer) {
-        const stats = this.index.get(path);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'preload');
-        }
-        if (!stats.isFile()) {
-            throw ErrnoError.With('EISDIR', path, 'preload');
-        }
-        stats.size = buffer.length;
-        stats.fileData = buffer;
-    }
-    /**
-     * @todo Be lazier about actually requesting the data?
-     */
-    async getData(path, stats) {
-        if (stats.fileData) {
-            return stats.fileData;
-        }
-        const data = await fetchFile(this.baseUrl + (path.startsWith('/') ? path.slice(1) : path), 'buffer', this.requestInit);
-        stats.fileData = data;
-        return data;
-    }
-    getDataSync(path, stats) {
-        if (stats.fileData) {
-            return stats.fileData;
-        }
-        throw new ErrnoError(Errno.ENODATA, '', path, 'getData');
+        // prefix url must end in a directory separator.
+        if (baseUrl.at(-1) == '/')
+            this.baseUrl = baseUrl.slice(0, -1);
+        this.indexData = typeof index != 'string' ? index : fetchFile(index, 'json', requestInit);
     }
 }
 const _Fetch = {
@@ -111,12 +145,15 @@ const _Fetch = {
         index: { type: ['string', 'object'], required: false },
         baseUrl: { type: 'string', required: false },
         requestInit: { type: 'object', required: false },
+        cache: { type: 'object', required: false },
     },
     isAvailable() {
         return typeof globalThis.fetch == 'function';
     },
     create(options) {
-        return new FetchFS(options);
+        const url = new URL(options.baseUrl || '');
+        url.pathname = normalizePath(url.pathname);
+        return new FetchFS(options.index, options.cache, url.toString(), options.requestInit);
     },
 };
 export const Fetch = _Fetch;

package/dist/backends/index.d.ts

@@ -1,11 +1,12 @@
 export * from './backend.js';
 export * from './fetch.js';
-export * from './file_index.js';
 export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './store/fs.js';
+export * from './store/file_index.js';
+export * from './store/index_fs.js';
 export * from './store/inode.js';
 export * from './store/simple.js';
 export * from './store/store.js';

package/dist/backends/index.js

@@ -1,11 +1,12 @@
 export * from './backend.js';
 export * from './fetch.js';
-export * from './file_index.js';
 export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './store/fs.js';
+export * from './store/file_index.js';
+export * from './store/index_fs.js';
 export * from './store/inode.js';
 export * from './store/simple.js';
 export * from './store/store.js';

package/dist/backends/memory.d.ts

@@ -3,7 +3,7 @@ import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
 /**
  * A simple in-memory store
  */
-export declare class InMemoryStore extends Map<bigint, Uint8Array> implements SimpleSyncStore {
+export declare class InMemoryStore extends Map<number, Uint8Array> implements SimpleSyncStore {
     name: string;
     constructor(name?: string);
     sync(): Promise<void>;

package/dist/backends/overlay.d.ts

@@ -1,6 +1,7 @@
 import type { File } from '../file.js';
 import type { CreationOptions, FileSystemMetadata } from '../filesystem.js';
 import type { Stats } from '../stats.js';
+import type { InodeLike } from './store/inode.js';
 import { FileSystem } from '../filesystem.js';
 /**
  * Configuration options for OverlayFS instances.
@@ -36,8 +37,12 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
     metadata(): FileSystemMetadata;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
+    read(path: string, offset: number, length: number): Promise<Uint8Array>;
+    readSync(path: string, offset: number, length: number): Uint8Array;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): void;
     /**
      * Called once to load up metadata stored on the writable file system.
      * @internal

package/dist/backends/overlay.js

@@ -54,8 +54,8 @@ import { Errno, ErrnoError } from '../error.js';
 import { PreloadFile, parseFlag } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Mutexed } from '../mixins/mutexed.js';
-import { decodeUTF8, encodeUTF8 } from '../utils.js';
-import { dirname } from '../vfs/path.js';
+import { canary, decodeUTF8, encodeUTF8 } from '../utils.js';
+import { dirname, join } from '../vfs/path.js';
 /** @internal */
 const deletionLogPath = '/.deleted';
 /**
@@ -97,15 +97,26 @@ export class UnmutexedOverlayFS extends FileSystem {
     }
     async sync(path, data, stats) {
         await this.copyForWrite(path);
-        if (!(await this.writable.exists(path))) {
-            await this.writable.createFile(path, 'w', 0o644, stats);
-        }
         await this.writable.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
         this.copyForWriteSync(path);
         this.writable.syncSync(path, data, stats);
     }
+    async read(path, offset, length) {
+        return (await this.writable.exists(path)) ? await this.writable.read(path, offset, length) : await this.readable.read(path, offset, length);
+    }
+    readSync(path, offset, length) {
+        return this.writable.existsSync(path) ? this.writable.readSync(path, offset, length) : this.readable.readSync(path, offset, length);
+    }
+    async write(path, buffer, offset) {
+        await this.copyForWrite(path);
+        return await this.writable.write(path, buffer, offset);
+    }
+    writeSync(path, buffer, offset) {
+        this.copyForWriteSync(path);
+        return this.writable.writeSync(path, buffer, offset);
+    }
     /**
      * Called once to load up metadata stored on the writable file system.
      * @internal
@@ -421,10 +432,12 @@ export class UnmutexedOverlayFS extends FileSystem {
     createParentDirectoriesSync(path) {
         let parent = dirname(path);
         const toCreate = [];
+        const silence = canary(path);
         while (!this.writable.existsSync(parent)) {
             toCreate.push(parent);
             parent = dirname(parent);
         }
+        silence();
         for (const path of toCreate.reverse()) {
             const { uid, gid, mode } = this.statSync(path);
             this.writable.mkdirSync(path, mode, { uid, gid });
@@ -437,10 +450,12 @@ export class UnmutexedOverlayFS extends FileSystem {
     async createParentDirectories(path) {
         let parent = dirname(path);
         const toCreate = [];
+        const silence = canary(path);
         while (!(await this.writable.exists(parent))) {
             toCreate.push(parent);
             parent = dirname(parent);
         }
+        silence();
         for (const path of toCreate.reverse()) {
             const { uid, gid, mode } = await this.stat(path);
             await this.writable.mkdir(path, mode, { uid, gid });
@@ -453,7 +468,7 @@ export class UnmutexedOverlayFS extends FileSystem {
      */
     copyForWriteSync(path) {
         if (!this.existsSync(path)) {
-            throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+            throw ErrnoError.With('ENOENT', path, '[copyForWrite]');
         }
         if (!this.writable.existsSync(dirname(path))) {
             this.createParentDirectoriesSync(path);
@@ -464,7 +479,7 @@ export class UnmutexedOverlayFS extends FileSystem {
     }
     async copyForWrite(path) {
         if (!(await this.exists(path))) {
-            throw ErrnoError.With('ENOENT', path, 'copyForWrite');
+            throw ErrnoError.With('ENOENT', path, '[copyForWrite]');
         }
         if (!(await this.writable.exists(dirname(path)))) {
             await this.createParentDirectories(path);
@@ -481,14 +496,18 @@ export class UnmutexedOverlayFS extends FileSystem {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const stats = this.statSync(path);
+            stats.mode |= 0o222;
             if (stats.isDirectory()) {
                 this.writable.mkdirSync(path, stats.mode, stats);
+                for (const k of this.readable.readdirSync(path)) {
+                    this.copyToWritableSync(join(path, k));
+                }
                 return;
             }
             const data = new Uint8Array(stats.size);
             const readable = __addDisposableResource(env_1, this.readable.openFileSync(path, 'r'), false);
             readable.readSync(data);
-            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode | 0o222, stats), false);
+            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode, stats), false);
             writable.writeSync(data);
         }
         catch (e_1) {
@@ -503,14 +522,18 @@ export class UnmutexedOverlayFS extends FileSystem {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const stats = await this.stat(path);
+            stats.mode |= 0o222;
             if (stats.isDirectory()) {
                 await this.writable.mkdir(path, stats.mode, stats);
+                for (const k of await this.readable.readdir(path)) {
+                    await this.copyToWritable(join(path, k));
+                }
                 return;
             }
             const data = new Uint8Array(stats.size);
             const readable = __addDisposableResource(env_2, await this.readable.openFile(path, 'r'), true);
             await readable.read(data);
-            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode | 0o222, stats), true);
+            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode, stats), true);
             await writable.write(data);
         }
         catch (e_2) {

package/dist/backends/passthrough.d.ts

@@ -93,6 +93,10 @@ export declare class PassthroughFS extends FileSystem {
      * Create a hard link synchronously.
      */
     linkSync(target: string, link: string): void;
+    read(path: string, offset: number, length: number): Promise<Uint8Array>;
+    readSync(path: string, offset: number, length: number): Uint8Array;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): void;
 }
 declare const _Passthrough: {
     readonly name: "Passthrough";

package/dist/backends/passthrough.js

@@ -1,3 +1,55 @@
+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, inner;
+        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 (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        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;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            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 { FileSystem } from '../filesystem.js';
 import { ErrnoError } from '../error.js';
 import { Stats } from '../stats.js';
@@ -320,6 +372,82 @@ export class PassthroughFS extends FileSystem {
             this.error(err, target);
         }
     }
+    async read(path, offset, length) {
+        try {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_1, await this.nodeFS.promises.open(this.path(path), 'r'), true);
+                const buffer = new Uint8Array(length);
+                await handle.read({ buffer, offset, length });
+                return buffer;
+            }
+            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;
+            }
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    readSync(path, offset, length) {
+        let fd;
+        try {
+            fd = this.nodeFS.openSync(this.path(path), 'r');
+            const buffer = new Uint8Array(length);
+            this.nodeFS.readSync(fd, buffer, { offset, length });
+            return buffer;
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+        finally {
+            if (fd)
+                this.nodeFS.closeSync(fd);
+        }
+        // unreachable
+        throw ErrnoError.With('EIO', path, 'read');
+    }
+    async write(path, buffer, offset) {
+        try {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+                await handle.write(buffer, offset);
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                const result_2 = __disposeResources(env_2);
+                if (result_2)
+                    await result_2;
+            }
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+    }
+    writeSync(path, buffer, offset) {
+        let fd;
+        try {
+            fd = this.nodeFS.openSync(this.path(path), 'w');
+            this.nodeFS.writeSync(fd, buffer, offset);
+        }
+        catch (err) {
+            this.error(err, path);
+        }
+        finally {
+            if (fd)
+                this.nodeFS.closeSync(fd);
+        }
+    }
 }
 const _Passthrough = {
     name: 'Passthrough',