@zenfs/core 0.9.7 → 0.11.0

package/dist/backends/{Locked.js → locked.js}

@@ -1,3 +1,4 @@
+import { ErrnoError } from '../error.js';
 import { Mutex } from '../mutex.js';
 /**
  * This class serializes access to an underlying async filesystem.
@@ -16,7 +17,6 @@ export class LockedFS {
     }
     async ready() {
         await this.fs.ready();
-        return this;
     }
     metadata() {
         return {
@@ -31,21 +31,21 @@ export class LockedFS {
     }
     renameSync(oldPath, newPath, cred) {
         if (this._mu.isLocked(oldPath)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', oldPath, 'rename');
         }
         return this.fs.renameSync(oldPath, newPath, cred);
     }
-    async stat(p, cred) {
-        await this._mu.lock(p);
-        const stats = await this.fs.stat(p, cred);
-        this._mu.unlock(p);
+    async stat(path, cred) {
+        await this._mu.lock(path);
+        const stats = await this.fs.stat(path, cred);
+        this._mu.unlock(path);
         return stats;
     }
-    statSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    statSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'stat');
         }
-        return this.fs.statSync(p, cred);
+        return this.fs.statSync(path, cred);
     }
     async openFile(path, flag, cred) {
         await this._mu.lock(path);
@@ -55,7 +55,7 @@ export class LockedFS {
     }
     openFileSync(path, flag, cred) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'openFile');
         }
         return this.fs.openFileSync(path, flag, cred);
     }
@@ -67,66 +67,66 @@ export class LockedFS {
     }
     createFileSync(path, flag, mode, cred) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'createFile');
         }
         return this.fs.createFileSync(path, flag, mode, cred);
     }
-    async unlink(p, cred) {
-        await this._mu.lock(p);
-        await this.fs.unlink(p, cred);
-        this._mu.unlock(p);
+    async unlink(path, cred) {
+        await this._mu.lock(path);
+        await this.fs.unlink(path, cred);
+        this._mu.unlock(path);
     }
-    unlinkSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    unlinkSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'unlink');
         }
-        return this.fs.unlinkSync(p, cred);
+        return this.fs.unlinkSync(path, cred);
     }
-    async rmdir(p, cred) {
-        await this._mu.lock(p);
-        await this.fs.rmdir(p, cred);
-        this._mu.unlock(p);
+    async rmdir(path, cred) {
+        await this._mu.lock(path);
+        await this.fs.rmdir(path, cred);
+        this._mu.unlock(path);
     }
-    rmdirSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    rmdirSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'rmdir');
         }
-        return this.fs.rmdirSync(p, cred);
+        return this.fs.rmdirSync(path, cred);
     }
-    async mkdir(p, mode, cred) {
-        await this._mu.lock(p);
-        await this.fs.mkdir(p, mode, cred);
-        this._mu.unlock(p);
+    async mkdir(path, mode, cred) {
+        await this._mu.lock(path);
+        await this.fs.mkdir(path, mode, cred);
+        this._mu.unlock(path);
     }
-    mkdirSync(p, mode, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    mkdirSync(path, mode, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'mkdir');
         }
-        return this.fs.mkdirSync(p, mode, cred);
+        return this.fs.mkdirSync(path, mode, cred);
     }
-    async readdir(p, cred) {
-        await this._mu.lock(p);
-        const files = await this.fs.readdir(p, cred);
-        this._mu.unlock(p);
+    async readdir(path, cred) {
+        await this._mu.lock(path);
+        const files = await this.fs.readdir(path, cred);
+        this._mu.unlock(path);
         return files;
     }
-    readdirSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    readdirSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'readdir');
         }
-        return this.fs.readdirSync(p, cred);
+        return this.fs.readdirSync(path, cred);
     }
-    async exists(p, cred) {
-        await this._mu.lock(p);
-        const exists = await this.fs.exists(p, cred);
-        this._mu.unlock(p);
+    async exists(path, cred) {
+        await this._mu.lock(path);
+        const exists = await this.fs.exists(path, cred);
+        this._mu.unlock(path);
         return exists;
     }
-    existsSync(p, cred) {
-        if (this._mu.isLocked(p)) {
-            throw new Error('invalid sync call');
+    existsSync(path, cred) {
+        if (this._mu.isLocked(path)) {
+            throw ErrnoError.With('EBUSY', path, 'exists');
         }
-        return this.fs.existsSync(p, cred);
+        return this.fs.existsSync(path, cred);
     }
     async link(srcpath, dstpath, cred) {
         await this._mu.lock(srcpath);
@@ -135,7 +135,7 @@ export class LockedFS {
     }
     linkSync(srcpath, dstpath, cred) {
         if (this._mu.isLocked(srcpath)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', srcpath, 'link');
         }
         return this.fs.linkSync(srcpath, dstpath, cred);
     }
@@ -146,7 +146,7 @@ export class LockedFS {
     }
     syncSync(path, data, stats) {
         if (this._mu.isLocked(path)) {
-            throw new Error('invalid sync call');
+            throw ErrnoError.With('EBUSY', path, 'sync');
         }
         return this.fs.syncSync(path, data, stats);
     }

package/dist/backends/{InMemory.d.ts → memory.d.ts}

@@ -1,17 +1,15 @@
 import type { Ino } from '../inode.js';
-import { SimpleSyncStore, SyncStore, SyncStoreFS, SyncTransaction } from './SyncStore.js';
+import { StoreFS } from './store/fs.js';
+import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
 /**
  * A simple in-memory store
  */
-export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
+export declare class InMemoryStore extends Map<Ino, Uint8Array> implements SimpleSyncStore {
     name: string;
-    private store;
     constructor(name?: string);
-    clear(): void;
-    beginTransaction(): SyncTransaction;
-    get(key: Ino): Uint8Array | undefined;
-    put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
-    remove(key: Ino): void;
+    sync(): Promise<void>;
+    clearSync(): void;
+    transaction(): SimpleTransaction;
 }
 /**
  * A simple in-memory file system backed by an InMemoryStore.
@@ -29,5 +27,5 @@ export declare const InMemory: {
     };
     readonly create: ({ name }: {
         name?: string;
-    }) => SyncStoreFS;
+    }) => StoreFS;
 };

package/dist/backends/memory.js

@@ -0,0 +1,38 @@
+import { StoreFS } from './store/fs.js';
+import { SimpleTransaction } from './store/simple.js';
+/**
+ * A simple in-memory store
+ */
+export class InMemoryStore extends Map {
+    constructor(name = 'tmp') {
+        super();
+        this.name = name;
+    }
+    async sync() { }
+    clearSync() {
+        this.clear();
+    }
+    transaction() {
+        return new SimpleTransaction(this);
+    }
+}
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
+export const InMemory = {
+    name: 'InMemory',
+    isAvailable() {
+        return true;
+    },
+    options: {
+        name: {
+            type: 'string',
+            required: false,
+            description: 'The name of the store',
+        },
+    },
+    create({ name }) {
+        return new StoreFS(new InMemoryStore(name));
+    },
+};

package/dist/backends/{Overlay.d.ts → overlay.d.ts}

@@ -1,7 +1,7 @@
 import { FileSystem, FileSystemMetadata } from '../filesystem.js';
 import { File } from '../file.js';
 import { Stats } from '../stats.js';
-import { LockedFS } from './Locked.js';
+import { LockedFS } from './locked.js';
 import { Cred } from '../cred.js';
 /**
  * Configuration options for OverlayFS instances.
@@ -25,7 +25,7 @@ export interface OverlayOptions {
  * @internal
  */
 export declare class UnlockedOverlayFS extends FileSystem {
-    ready(): Promise<this>;
+    ready(): Promise<void>;
     private _writable;
     private _readable;
     private _isInitialized;
@@ -49,22 +49,22 @@ export declare class UnlockedOverlayFS extends FileSystem {
     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;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    statSync(path: string, cred: Cred): Stats;
     openFile(path: string, flag: string, cred: Cred): Promise<File>;
     openFileSync(path: string, flag: string, cred: Cred): File;
     createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     createFileSync(path: string, flag: string, 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[];
+    unlink(path: string, cred: Cred): Promise<void>;
+    unlinkSync(path: string, cred: Cred): void;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    rmdirSync(path: string, cred: Cred): void;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    readdirSync(path: string, cred: Cred): string[];
     private deletePath;
     private updateLog;
     private _reparseDeletionLog;
@@ -97,7 +97,6 @@ export declare class UnlockedOverlayFS extends FileSystem {
  * @internal
  */
 export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
-    ready(): Promise<this>;
     /**
      * @param options The options to initialize the OverlayFS with
      */