@zenfs/core 0.5.12 → 0.7.0

package/dist/FileIndex.d.ts

@@ -169,6 +169,15 @@ declare const FileIndexFS_base: (abstract new (...args: any[]) => {
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    ready(): Promise<any>;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    statSync(path: string, cred: Cred): Stats;
+    openFile(path: string, flag: string, cred: Cred): Promise<import("./file.js").File>;
+    openFileSync(path: string, flag: string, cred: Cred): import("./file.js").File;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    readdirSync(path: string, cred: Cred): string[];
+    exists(path: string, cred: Cred): Promise<boolean>;
+    existsSync(path: string, cred: Cred): boolean;
 }) & typeof FileSystem;
 export declare abstract class FileIndexFS<TIndex> extends FileIndexFS_base {
     protected _index: FileIndex<TIndex>;
@@ -184,39 +193,14 @@ export declare abstract class FileIndexFS<TIndex> extends FileIndexFS_base {
     protected abstract openFileInode(inode: IndexFileInode<TIndex>, path: string, flag: string): Promise<NoSyncFile<this>>;
     protected abstract openFileInodeSync(inode: IndexFileInode<TIndex>, path: string, flag: string): NoSyncFile<this>;
 }
-declare const SyncFileIndexFS_base: (abstract new (...args: any[]) => {
-    metadata(): import("./filesystem.js").FileSystemMetadata;
-    ready(): Promise<any>;
-    exists(path: string, cred: Cred): Promise<boolean>;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    stat(path: string, cred: Cred): Promise<Stats>;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("./file.js").File>;
-    openFile(path: string, flag: string, cred: Cred): Promise<import("./file.js").File>;
-    unlink(path: string, cred: Cred): Promise<void>;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    readdir(path: string, cred: Cred): Promise<string[]>;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    statSync(path: string, cred: Cred): Stats;
-    openFileSync(path: string, flag: string, cred: Cred): import("./file.js").File;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("./file.js").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[];
-    existsSync(path: string, cred: Cred): boolean;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}) & (abstract new (index: ListingTree) => FileIndexFS<unknown>);
-export declare abstract class SyncFileIndexFS<TIndex> extends SyncFileIndexFS_base {
-    _index: FileIndex<TIndex>;
+export declare abstract class SyncFileIndexFS<TIndex> extends FileIndexFS<TIndex> {
     protected statFileInode(inode: IndexFileInode<TIndex>, path: string): Promise<Stats>;
     protected openFileInode(inode: IndexFileInode<TIndex>, path: string, flag: string): Promise<NoSyncFile<this>>;
 }
 declare const AsyncFileIndexFS_base: (abstract new (...args: any[]) => {
+    _sync: FileSystem;
     metadata(): import("./filesystem.js").FileSystemMetadata;
+    ready(): Promise<any>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: string, mode: number, cred: Cred): import("./file.js").File;
@@ -227,6 +211,18 @@ declare const AsyncFileIndexFS_base: (abstract new (...args: any[]) => {
     readdirSync(path: string, cred: Cred): string[];
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    openFile(path: string, flag: string, cred: Cred): Promise<import("./file.js").File>;
+    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("./file.js").File>;
+    unlink(path: string, cred: Cred): Promise<void>;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    exists(path: string, cred: Cred): Promise<boolean>;
+    existsSync(path: string, cred: Cred): boolean;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
 }) & (abstract new (index: ListingTree) => FileIndexFS<unknown>);
 export declare abstract class AsyncFileIndexFS<TIndex> extends AsyncFileIndexFS_base {
     _index: FileIndex<TIndex>;

package/dist/FileIndex.js

@@ -1,7 +1,7 @@
 import { ApiError, ErrorCode } from './ApiError.js';
 import { basename, dirname, join } from './emulation/path.js';
 import { NoSyncFile, flagToMode, isWriteable } from './file.js';
-import { FileSystem, Sync, Async, Readonly } from './filesystem.js';
+import { FileSystem, Async, Readonly } from './filesystem.js';
 import { FileType, Stats } from './stats.js';
 /**
  * A simple class for storing a filesystem index. Assumes that all paths passed
@@ -390,7 +390,7 @@ export class FileIndexFS extends Readonly(FileSystem) {
         throw ApiError.With('ENOTDIR', path, 'readdirSync');
     }
 }
-export class SyncFileIndexFS extends Sync((FileIndexFS)) {
+export class SyncFileIndexFS extends FileIndexFS {
     async statFileInode(inode, path) {
         return this.statFileInodeSync(inode, path);
     }

package/dist/backends/AsyncStore.d.ts

@@ -1,5 +1,5 @@
 import type { Cred } from '../cred.js';
-import { PreloadFile, File } from '../file.js';
+import { PreloadFile } from '../file.js';
 import { FileSystem, type FileSystemMetadata } from '../filesystem.js';
 import { type Ino } from '../inode.js';
 import { type Stats } from '../stats.js';
@@ -52,17 +52,6 @@ export interface AsyncTransaction {
      */
     abort(): Promise<void>;
 }
-/**
- * Async preload file for usage with AsyncStore
- * @internal
- */
-export declare class AsyncFile extends PreloadFile<AsyncStoreFS> {
-    constructor(_fs: AsyncStoreFS, _path: string, _flag: string, _stat: Stats, contents?: Uint8Array);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-}
 export interface AsyncStoreOptions {
     /**
      * Promise that resolves to the store
@@ -71,20 +60,38 @@ export interface AsyncStoreOptions {
     /**
      * The size of the cache. If not provided, no cache will be used
      */
-    cacheSize?: number;
+    lruCacheSize?: number;
+    /**
+     * The file system to use for synchronous methods. Defaults to InMemory
+     */
+    sync?: FileSystem;
 }
 declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
+    _sync: FileSystem;
     metadata(): FileSystemMetadata;
+    ready(): Promise<any>;
     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;
+    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("../file.js").File;
+    openFileSync(path: string, flag: string, cred: Cred): import("../file.js").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;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    openFile(path: string, flag: string, cred: Cred): Promise<import("../file.js").File>;
+    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("../file.js").File>;
+    unlink(path: string, cred: Cred): Promise<void>;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    exists(path: string, cred: Cred): Promise<boolean>;
+    existsSync(path: string, cred: Cred): boolean;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
 }) & typeof FileSystem;
 /**
  * An asynchronous file system which uses an async store to store its data.
@@ -94,15 +101,16 @@ declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
 export declare class AsyncStoreFS extends AsyncStoreFS_base {
     protected store: AsyncStore;
     private _cache?;
-    protected _ready: Promise<this>;
+    _sync: FileSystem;
+    protected _ready: Promise<void>;
     ready(): Promise<this>;
     metadata(): FileSystemMetadata;
-    constructor({ store, cacheSize }: AsyncStoreOptions);
+    constructor(options: AsyncStoreOptions);
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    protected _initialize(store: Promise<AsyncStore> | AsyncStore): Promise<this>;
+    protected _initialize({ store, lruCacheSize, sync }: AsyncStoreOptions): Promise<void>;
     /**
      * Delete all contents stored in the file system.
      */
@@ -112,8 +120,8 @@ export declare class AsyncStoreFS extends AsyncStoreFS_base {
      */
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(p: string, cred: Cred): Promise<Stats>;
-    createFile(p: string, flag: string, mode: number, cred: Cred): Promise<File>;
-    openFile(p: string, flag: string, cred: Cred): Promise<File>;
+    createFile(p: string, flag: string, mode: number, cred: Cred): Promise<PreloadFile<this>>;
+    openFile(p: string, flag: string, cred: Cred): Promise<PreloadFile<this>>;
     unlink(p: string, cred: Cred): Promise<void>;
     rmdir(p: string, cred: Cred): Promise<void>;
     mkdir(p: string, mode: number, cred: Cred): Promise<void>;

package/dist/backends/AsyncStore.js

@@ -7,6 +7,7 @@ import { randomIno, Inode } from '../inode.js';
 import { FileType } from '../stats.js';
 import { encode, decodeDirListing, encodeDirListing } from '../utils.js';
 import { rootIno } from '../inode.js';
+import { InMemory } from './InMemory.js';
 /**
  * Last Recently Used cache
  */
@@ -44,39 +45,16 @@ class LRUCache {
         this.cache = [];
     }
 }
-/**
- * Async preload file for usage with AsyncStore
- * @internal
- */
-export class AsyncFile extends PreloadFile {
-    constructor(_fs, _path, _flag, _stat, contents) {
-        super(_fs, _path, _flag, _stat, contents);
-    }
-    async sync() {
-        if (!this.isDirty()) {
-            return;
-        }
-        await this.fs.sync(this.path, this._buffer, this.stats);
-        this.resetDirty();
-    }
-    syncSync() {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    async close() {
-        this.sync();
-    }
-    closeSync() {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-}
 /**
  * An asynchronous file system which uses an async store to store its data.
  * @see AsyncStore
  * @internal
  */
 export class AsyncStoreFS extends Async(FileSystem) {
-    ready() {
-        return this._ready;
+    async ready() {
+        await super.ready();
+        await this._ready;
+        return this;
     }
     metadata() {
         return {
@@ -84,22 +62,21 @@ export class AsyncStoreFS extends Async(FileSystem) {
             name: this.store.name,
         };
     }
-    constructor({ store, cacheSize }) {
+    constructor(options) {
         super();
-        if (cacheSize > 0) {
-            this._cache = new LRUCache(cacheSize);
-        }
-        this._ready = this._initialize(store);
+        this._ready = this._initialize(options);
     }
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    async _initialize(store) {
+    async _initialize({ store, lruCacheSize, sync }) {
+        if (lruCacheSize > 0) {
+            this._cache = new LRUCache(lruCacheSize);
+        }
         this.store = await store;
-        // INVARIANT: Ensure that the root exists.
         await this.makeRootDirectory();
-        return this;
+        this._sync = sync || InMemory.create({ name: 'test' });
     }
     /**
      * Delete all contents stored in the file system.
@@ -204,7 +181,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
     async createFile(p, flag, mode, cred) {
         const tx = this.store.beginTransaction(), data = new Uint8Array(0), newFile = await this.commitNewFile(tx, p, FileType.FILE, mode, cred, data);
         // Open the file.
-        return new AsyncFile(this, p, flag, newFile.toStats(), data);
+        return new PreloadFile(this, p, flag, newFile.toStats(), data);
     }
     async openFile(p, flag, cred) {
         const tx = this.store.beginTransaction(), node = await this.findINode(tx, p), data = await tx.get(node.ino);
@@ -214,7 +191,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
         if (!data) {
             throw ApiError.With('ENOENT', p, 'openFile');
         }
-        return new AsyncFile(this, p, flag, node.toStats(), data);
+        return new PreloadFile(this, p, flag, node.toStats(), data);
     }
     async unlink(p, cred) {
         return this.removeEntry(p, false, cred);

package/dist/backends/InMemory.d.ts

@@ -1,5 +1,4 @@
 import type { Ino } from '../inode.js';
-import type { Backend } from './backend.js';
 import { SyncStore, SimpleSyncStore, SyncTransaction, SyncStoreFS } from './SyncStore.js';
 /**
  * A simple in-memory store
@@ -18,4 +17,17 @@ export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export declare const InMemory: Backend<SyncStoreFS>;
+export declare const InMemory: {
+    readonly name: "InMemory";
+    readonly isAvailable: () => boolean;
+    readonly options: {
+        readonly name: {
+            readonly type: "string";
+            readonly required: false;
+            readonly description: "The name of the store";
+        };
+    };
+    readonly create: ({ name }: {
+        name?: string;
+    }) => SyncStoreFS;
+};

package/dist/backends/Overlay.d.ts

@@ -1,20 +1,8 @@
 import { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import { File, PreloadFile } from '../file.js';
+import { File } from '../file.js';
 import { Stats } from '../stats.js';
 import { LockedFS } from './Locked.js';
 import { Cred } from '../cred.js';
-import type { Backend } from './backend.js';
-/**
- * Overlays a RO file to make it writable.
- * @internal
- */
-export declare class OverlayFile extends PreloadFile<UnlockedOverlayFS> implements File {
-    constructor(fs: UnlockedOverlayFS, path: string, flag: string, stats: Stats, data: Uint8Array);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-}
 /**
  * Configuration options for OverlayFS instances.
  */
@@ -119,4 +107,20 @@ export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
     resDeletionLog(): string;
     unwrap(): UnlockedOverlayFS;
 }
-export declare const Overlay: Backend<OverlayFS>;
+export declare const Overlay: {
+    readonly name: "Overlay";
+    readonly options: {
+        readonly writable: {
+            readonly type: "object";
+            readonly required: true;
+            readonly description: "The file system to write modified files to.";
+        };
+        readonly readable: {
+            readonly type: "object";
+            readonly required: true;
+            readonly description: "The file system that initially populates this file system.";
+        };
+    };
+    readonly isAvailable: () => boolean;
+    readonly create: (options: OverlayOptions) => OverlayFS;
+};

package/dist/backends/Overlay.js

@@ -10,34 +10,6 @@ import { decode, encode } from '../utils.js';
  * @internal
  */
 const deletionLogPath = '/.deleted';
-/**
- * Overlays a RO file to make it writable.
- * @internal
- */
-export class OverlayFile extends PreloadFile {
-    constructor(fs, path, flag, stats, data) {
-        super(fs, path, flag, stats, data);
-    }
-    async sync() {
-        if (!this.isDirty()) {
-            return;
-        }
-        await this.fs.sync(this.path, this.buffer, this.stats);
-        this.resetDirty();
-    }
-    syncSync() {
-        if (this.isDirty()) {
-            this.fs.syncSync(this.path, this.buffer, this.stats);
-            this.resetDirty();
-        }
-    }
-    async close() {
-        await this.sync();
-    }
-    closeSync() {
-        this.syncSync();
-    }
-}
 /**
  * OverlayFS makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
@@ -74,7 +46,6 @@ export class UnlockedOverlayFS extends FileSystem {
         return {
             ...super.metadata(),
             name: OverlayFS.name,
-            synchronous: this._readable.metadata().synchronous && this._writable.metadata().synchronous,
             supportsProperties: this._readable.metadata().supportsProperties && this._writable.metadata().supportsProperties,
         };
     }
@@ -189,7 +160,7 @@ export class UnlockedOverlayFS extends FileSystem {
         const file = await this._readable.openFile(path, parseFlag('r'), cred);
         const stats = new Stats(await file.stat());
         const { buffer } = await file.read(new Uint8Array(stats.size));
-        return new OverlayFile(this, path, flag, stats, buffer);
+        return new PreloadFile(this, path, flag, stats, buffer);
     }
     openFileSync(path, flag, cred) {
         if (this._writable.existsSync(path, cred)) {
@@ -200,7 +171,7 @@ export class UnlockedOverlayFS extends FileSystem {
         const stats = Stats.clone(file.statSync());
         const data = new Uint8Array(stats.size);
         file.readSync(data);
-        return new OverlayFile(this, path, flag, stats, data);
+        return new PreloadFile(this, path, flag, stats, data);
     }
     async createFile(path, flag, mode, cred) {
         this.checkInitialized();

package/dist/backends/SyncStore.d.ts

@@ -102,17 +102,6 @@ export interface SyncStoreOptions {
      */
     store: SyncStore;
 }
-/**
- * File backend by a SyncStoreFS
- * @internal
- */
-export declare class SyncStoreFile extends PreloadFile<SyncStoreFS> {
-    constructor(_fs: SyncStoreFS, _path: string, _flag: string, _stat: Stats, contents?: Uint8Array);
-    sync(): Promise<void>;
-    syncSync(): void;
-    close(): Promise<void>;
-    closeSync(): void;
-}
 declare const SyncStoreFS_base: (abstract new (...args: any[]) => {
     metadata(): FileSystemMetadata;
     ready(): Promise<any>;
@@ -157,8 +146,8 @@ export declare class SyncStoreFS extends SyncStoreFS_base {
     empty(): void;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(p: string, cred: Cred): Stats;
-    createFileSync(p: string, flag: string, mode: number, cred: Cred): SyncStoreFile;
-    openFileSync(p: string, flag: string, cred: Cred): SyncStoreFile;
+    createFileSync(p: string, flag: string, mode: number, cred: Cred): PreloadFile<this>;
+    openFileSync(p: string, flag: string, cred: Cred): PreloadFile<this>;
     unlinkSync(p: string, cred: Cred): void;
     rmdirSync(p: string, cred: Cred): void;
     mkdirSync(p: string, mode: number, cred: Cred): void;

package/dist/backends/SyncStore.js

@@ -76,30 +76,6 @@ export class SimpleSyncTransaction {
         }
     }
 }
-/**
- * File backend by a SyncStoreFS
- * @internal
- */
-export class SyncStoreFile extends PreloadFile {
-    constructor(_fs, _path, _flag, _stat, contents) {
-        super(_fs, _path, _flag, _stat, contents);
-    }
-    async sync() {
-        this.syncSync();
-    }
-    syncSync() {
-        if (this.isDirty()) {
-            this.fs.syncSync(this.path, this._buffer, this.stats);
-            this.resetDirty();
-        }
-    }
-    async close() {
-        this.closeSync();
-    }
-    closeSync() {
-        this.syncSync();
-    }
-}
 /**
  * A synchronous key-value file system. Uses a SyncStore to store the data.
  *
@@ -210,7 +186,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
         if (data === null) {
             throw ApiError.With('ENOENT', p, 'openFileSync');
         }
-        return new SyncStoreFile(this, p, flag, node.toStats(), data);
+        return new PreloadFile(this, p, flag, node.toStats(), data);
     }
     unlinkSync(p, cred) {
         this.removeEntry(p, false, cred);

package/dist/backends/backend.d.ts

@@ -1,4 +1,5 @@
 import { FileSystem } from '../filesystem.js';
+import { type RequiredKeys } from '../utils.js';
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
 /**
  * Describes a file system option.
@@ -23,18 +24,22 @@ export interface OptionConfig<T> {
      */
     validator?(opt: T): void | Promise<void>;
 }
-/**
- * Describes all of the options available in a file system.
- */
-type BackendOptionsConfig = Record<string, OptionConfig<unknown>>;
+type InferOptionsConfig<T> = {
+    [K in keyof T]: {
+        type: OptionType | OptionType[];
+        description: string;
+        required: K extends RequiredKeys<T> ? true : false;
+        validator?(opt: T[K]): void | Promise<void>;
+    };
+};
 /**
  * A backend
  */
-export interface Backend<FS extends FileSystem = FileSystem, OC extends BackendOptionsConfig = BackendOptionsConfig> {
+export interface Backend<FS extends FileSystem = FileSystem, TOptions extends object = object> {
     /**
      * Create a new instance of the backend
      */
-    create(options: object): FS;
+    create(options: TOptions): FS;
     /**
      * A name to identify the backend.
      */
@@ -42,7 +47,7 @@ export interface Backend<FS extends FileSystem = FileSystem, OC extends BackendO
     /**
      * Describes all of the options available for this backend.
      */
-    options: OC;
+    options: InferOptionsConfig<TOptions>;
     /**
      * Whether the backend is available in the current environment.
      * It supports checking synchronously and asynchronously
@@ -63,7 +68,7 @@ export declare function isBackend(arg: unknown): arg is Backend;
  * Checks that the given options object is valid for the file system options.
  * @internal
  */
-export declare function checkOptions(backend: Backend, opts: object): Promise<void>;
+export declare function checkOptions<T extends Backend>(backend: T, opts: object): Promise<void>;
 export declare function createBackend<B extends Backend>(backend: B, options?: object): Promise<ReturnType<B['create']>>;
 /**
  * Specifies a file system backend type and its options.
@@ -73,17 +78,11 @@ export declare function createBackend<B extends Backend>(backend: B, options?: o
  *
  * The option object for each file system corresponds to that file system's option object passed to its `Create()` method.
  */
-export interface BackendConfig<FS extends FileSystem = FileSystem, OC extends BackendOptionsConfig = BackendOptionsConfig> {
-    backend: Backend<FS, OC>;
-    [key: string]: unknown;
-}
+export type BackendConfiguration<FS extends FileSystem = FileSystem, TOptions extends object = object> = TOptions & {
+    backend: Backend<FS, TOptions>;
+};
 /**
  * @internal
  */
-export declare function isBackendConfig(arg: unknown): arg is BackendConfig;
-/**
- * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
- */
-export declare function resolveBackend<FS extends FileSystem>(options: BackendConfig<FS>, _depth?: number): Promise<FS>;
+export declare function isBackendConfig(arg: unknown): arg is BackendConfiguration;
 export {};

package/dist/backends/backend.js

@@ -53,38 +53,5 @@ export function createBackend(backend, options) {
  * @internal
  */
 export function isBackendConfig(arg) {
-    return arg != null && typeof arg == 'object' && 'backend' in arg;
-}
-/**
- * Retrieve a file system with the given configuration.
- * @param config A BackendConfig object.
- */
-export async function resolveBackend(options, _depth = 0) {
-    if (typeof options !== 'object' || options == null) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid options on configuration object.');
-    }
-    const { backend } = options;
-    if (!isBackend(backend)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Missing or invalid backend');
-    }
-    const props = Object.keys(options).filter(k => k != 'backend');
-    for (const prop of props) {
-        let option = options[prop];
-        if (isBackend(option)) {
-            option = { backend: option };
-        }
-        if (isBackendConfig(option)) {
-            if (_depth > 10) {
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid configuration, too deep and possibly infinite');
-            }
-            options[prop] = await resolveBackend(option, ++_depth);
-        }
-    }
-    if (!(await backend.isAvailable())) {
-        throw new ApiError(ErrorCode.EPERM, 'Backend not available: ' + backend);
-    }
-    checkOptions(backend, options);
-    const fs = backend.create(options);
-    await fs.ready();
-    return fs;
+    return arg != null && typeof arg == 'object' && 'backend' in arg && isBackend(arg.backend);
 }