@zenfs/core 0.2.1 → 0.2.2

package/dist/backends/AsyncStore.d.ts

@@ -1,6 +1,6 @@
 import { Cred } from '../cred.js';
 import { PreloadFile, File, FileFlag } from '../file.js';
-import { AsyncFileSystem } from '../filesystem.js';
+import { AsyncFileSystem, type FileSystemMetadata } from '../filesystem.js';
 import { type Ino } from '../inode.js';
 import { Stats } from '../stats.js';
 /**
@@ -73,7 +73,7 @@ export interface AsyncStoreFileSystemOptions {
     /**
      * Promise that resolves to the store
      */
-    store: Promise<AsyncStore>;
+    store: Promise<AsyncStore> | AsyncStore;
     /**
      * The size of the cache. If not provided, no cache will be used
      */
@@ -88,12 +88,13 @@ export declare class AsyncStoreFileSystem extends AsyncFileSystem {
     private _cache?;
     protected _ready: Promise<this>;
     ready(): Promise<this>;
+    get metadata(): FileSystemMetadata;
     constructor({ store, cacheSize }: AsyncStoreFileSystemOptions);
     /**
      * Initializes the file system. Typically called by subclasses' async
      * constructors.
      */
-    protected _initialize(store: Promise<AsyncStore>): Promise<this>;
+    protected _initialize(store: Promise<AsyncStore> | AsyncStore): Promise<this>;
     /**
      * Delete all contents stored in the file system.
      */

package/dist/backends/AsyncStore.js

@@ -73,6 +73,12 @@ export class AsyncStoreFileSystem extends AsyncFileSystem {
     ready() {
         return this._ready;
     }
+    get metadata() {
+        return {
+            ...super.metadata,
+            name: this.store.name,
+        };
+    }
     constructor({ store, cacheSize }) {
         super();
         if (cacheSize > 0) {

package/dist/backends/InMemory.d.ts

@@ -1,6 +1,6 @@
 import type { Ino } from '../inode.js';
-import { SyncStore, SimpleSyncStore, SyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
-import { type Backend } from './backend.js';
+import type { Backend } from './backend.js';
+import { SyncStore, SimpleSyncStore, SyncRWTransaction } from './SyncStore.js';
 /**
  * A simple in-memory store
  */
@@ -14,14 +14,8 @@ export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
     put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
     remove(key: Ino): void;
 }
-export declare const InMemory: Backend;
 /**
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export declare class _InMemory extends SyncStoreFileSystem {
-    static isAvailable(): boolean;
-    static create: any;
-    static readonly options: {};
-    constructor();
-}
+export declare const InMemory: Backend;

package/dist/backends/InMemory.js

@@ -1,6 +1,4 @@
-var _a;
 import { SimpleSyncRWTransaction, SyncStoreFileSystem } from './SyncStore.js';
-import { createBackend } from './backend.js';
 /**
  * A simple in-memory store
  */
@@ -29,6 +27,10 @@ export class InMemoryStore {
         this.store.delete(key);
     }
 }
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
 export const InMemory = {
     name: 'InMemory',
     isAvailable() {
@@ -44,18 +46,3 @@ export const InMemory = {
         return new SyncStoreFileSystem({ store: new InMemoryStore(name) });
     },
 };
-/**
- * A simple in-memory file system backed by an InMemoryStore.
- * Files are not persisted across page loads.
- */
-export class _InMemory extends SyncStoreFileSystem {
-    static isAvailable() {
-        return true;
-    }
-    constructor() {
-        super({ store: new InMemoryStore() });
-    }
-}
-_a = _InMemory;
-_InMemory.create = createBackend.bind(_a);
-_InMemory.options = {};

package/dist/backends/Overlay.d.ts

@@ -0,0 +1,110 @@
+import { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import { File, FileFlag } from '../file.js';
+import { Stats } from '../stats.js';
+import LockedFS from './Locked.js';
+import { Cred } from '../cred.js';
+import type { Backend } from './backend.js';
+/**
+ * Configuration options for OverlayFS instances.
+ */
+export interface OverlayOptions {
+    /**
+     * The file system to write modified files to.
+     */
+    writable: FileSystem;
+    /**
+     * The file system that initially populates this file system.
+     */
+    readable: FileSystem;
+}
+/**
+ * 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.
+ *
+ * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
+ *
+ * @internal
+ */
+export declare class UnlockedOverlayFS extends FileSystem {
+    ready(): Promise<this>;
+    private _writable;
+    private _readable;
+    private _isInitialized;
+    private _deletedFiles;
+    private _deleteLog;
+    private _deleteLogUpdatePending;
+    private _deleteLogUpdateNeeded;
+    private _deleteLogError?;
+    private _ready;
+    constructor({ writable, readable }: OverlayOptions);
+    get metadata(): FileSystemMetadata;
+    getOverlayedFileSystems(): OverlayOptions;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    /**
+     * Called once to load up metadata stored on the writable file system.
+     * @internal
+     */
+    _initialize(): Promise<void>;
+    getDeletionLog(): string;
+    restoreDeletionLog(log: string, cred: Cred): void;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    stat(p: string, cred: Cred): Promise<Stats>;
+    statSync(p: string, cred: Cred): Stats;
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    unlink(p: string, cred: Cred): Promise<void>;
+    unlinkSync(p: string, cred: Cred): void;
+    rmdir(p: string, cred: Cred): Promise<void>;
+    rmdirSync(p: string, cred: Cred): void;
+    mkdir(p: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(p: string, mode: number, cred: Cred): void;
+    readdir(p: string, cred: Cred): Promise<string[]>;
+    readdirSync(p: string, cred: Cred): string[];
+    private deletePath;
+    private updateLog;
+    private _reparseDeletionLog;
+    private checkInitialized;
+    private checkPath;
+    /**
+     * With the given path, create the needed parent directories on the writable storage
+     * should they not exist. Use modes from the read-only storage.
+     */
+    private createParentDirectoriesSync;
+    private createParentDirectories;
+    /**
+     * Helper function:
+     * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
+     * - Calls f to perform operation on writable.
+     */
+    private operateOnWritable;
+    private operateOnWritableAsync;
+    /**
+     * Copy from readable to writable storage.
+     * PRECONDITION: File does not exist on writable storage.
+     */
+    private copyToWritableSync;
+    private copyToWritable;
+}
+/**
+ * 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.
+ */
+export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
+    ready(): Promise<this>;
+    /**
+     * @param options The options to initialize the OverlayFS with
+     */
+    constructor(options: OverlayOptions);
+    getOverlayedFileSystems(): OverlayOptions;
+    getDeletionLog(): string;
+    resDeletionLog(): string;
+    unwrap(): UnlockedOverlayFS;
+}
+export declare const Overlay: Backend;