@zenfs/core 0.11.1 → 0.12.0

package/dist/backends/locked.js

@@ -13,7 +13,7 @@ import { Mutex } from '../mutex.js';
 export class LockedFS {
     constructor(fs) {
         this.fs = fs;
-        this._mu = new Mutex();
+        this.mutex = new Mutex();
     }
     async ready() {
         await this.fs.ready();
@@ -25,127 +25,127 @@ export class LockedFS {
         };
     }
     async rename(oldPath, newPath, cred) {
-        await this._mu.lock(oldPath);
+        await this.mutex.lock(oldPath);
         await this.fs.rename(oldPath, newPath, cred);
-        this._mu.unlock(oldPath);
+        this.mutex.unlock(oldPath);
     }
     renameSync(oldPath, newPath, cred) {
-        if (this._mu.isLocked(oldPath)) {
+        if (this.mutex.isLocked(oldPath)) {
             throw ErrnoError.With('EBUSY', oldPath, 'rename');
         }
         return this.fs.renameSync(oldPath, newPath, cred);
     }
     async stat(path, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         const stats = await this.fs.stat(path, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
         return stats;
     }
     statSync(path, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'stat');
         }
         return this.fs.statSync(path, cred);
     }
     async openFile(path, flag, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         const fd = await this.fs.openFile(path, flag, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
         return fd;
     }
     openFileSync(path, flag, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'openFile');
         }
         return this.fs.openFileSync(path, flag, cred);
     }
     async createFile(path, flag, mode, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         const fd = await this.fs.createFile(path, flag, mode, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
         return fd;
     }
     createFileSync(path, flag, mode, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'createFile');
         }
         return this.fs.createFileSync(path, flag, mode, cred);
     }
     async unlink(path, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         await this.fs.unlink(path, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
     }
     unlinkSync(path, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'unlink');
         }
         return this.fs.unlinkSync(path, cred);
     }
     async rmdir(path, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         await this.fs.rmdir(path, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
     }
     rmdirSync(path, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'rmdir');
         }
         return this.fs.rmdirSync(path, cred);
     }
     async mkdir(path, mode, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         await this.fs.mkdir(path, mode, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
     }
     mkdirSync(path, mode, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'mkdir');
         }
         return this.fs.mkdirSync(path, mode, cred);
     }
     async readdir(path, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         const files = await this.fs.readdir(path, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
         return files;
     }
     readdirSync(path, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'readdir');
         }
         return this.fs.readdirSync(path, cred);
     }
     async exists(path, cred) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         const exists = await this.fs.exists(path, cred);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
         return exists;
     }
     existsSync(path, cred) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'exists');
         }
         return this.fs.existsSync(path, cred);
     }
     async link(srcpath, dstpath, cred) {
-        await this._mu.lock(srcpath);
+        await this.mutex.lock(srcpath);
         await this.fs.link(srcpath, dstpath, cred);
-        this._mu.unlock(srcpath);
+        this.mutex.unlock(srcpath);
     }
     linkSync(srcpath, dstpath, cred) {
-        if (this._mu.isLocked(srcpath)) {
+        if (this.mutex.isLocked(srcpath)) {
             throw ErrnoError.With('EBUSY', srcpath, 'link');
         }
         return this.fs.linkSync(srcpath, dstpath, cred);
     }
     async sync(path, data, stats) {
-        await this._mu.lock(path);
+        await this.mutex.lock(path);
         await this.fs.sync(path, data, stats);
-        this._mu.unlock(path);
+        this.mutex.unlock(path);
     }
     syncSync(path, data, stats) {
-        if (this._mu.isLocked(path)) {
+        if (this.mutex.isLocked(path)) {
             throw ErrnoError.With('EBUSY', path, 'sync');
         }
         return this.fs.syncSync(path, data, stats);

package/dist/backends/memory.d.ts

@@ -27,5 +27,5 @@ export declare const InMemory: {
     };
     readonly create: ({ name }: {
         name?: string;
-    }) => StoreFS;
+    }) => StoreFS<InMemoryStore>;
 };

package/dist/backends/port/fs.d.ts

@@ -79,7 +79,7 @@ export declare class PortFS extends PortFS_base {
     /**
      * @hidden
      */
-    _sync: import("../store/fs.js").StoreFS;
+    _sync: import("../store/fs.js").StoreFS<import("../memory.js").InMemoryStore>;
     /**
      * Constructs a new PortFS instance that connects with ZenFS running on
      * the specified port.

package/dist/backends/port/fs.js

@@ -39,7 +39,8 @@ export class PortFile extends File {
         throw ErrnoError.With('ENOSYS', this.path, 'PortFile.write');
     }
     async read(buffer, offset, length, position) {
-        return (await this.rpc('read', buffer, offset, length, position));
+        const result = await this.rpc('read', buffer, offset, length, position);
+        return result;
     }
     readSync() {
         throw ErrnoError.With('ENOSYS', this.path, 'PortFile.read');

package/dist/backends/port/rpc.js

@@ -17,10 +17,12 @@ export function request(request, { port, timeout = 1000, fs } = {}) {
         const id = Math.random().toString(16).slice(10);
         executors.set(id, { resolve, reject, fs });
         port.postMessage({ ...request, _zenfs: true, id, stack });
-        setTimeout(() => {
+        const _ = setTimeout(() => {
             const error = new ErrnoError(Errno.EIO, 'RPC Failed');
             error.stack += stack;
             reject(error);
+            if (typeof _ == 'object')
+                _.unref();
         }, timeout);
     });
 }

package/dist/backends/store/fs.d.ts

@@ -5,20 +5,20 @@ import { type Ino, Inode } from '../../inode.js';
 import { type Stats, FileType } from '../../stats.js';
 import type { Store, Transaction } from './store.js';
 /**
- * A synchronous key-value file system. Uses a SyncStore to store the data.
+ * A file system which uses a key-value store.
  *
  * We use a unique ID for each node in the file system. The root node has a fixed ID.
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  * @internal
  */
-export declare class StoreFS extends FileSystem {
+export declare class StoreFS<T extends Store = Store> extends FileSystem {
     private $store;
-    protected get store(): Store;
-    protected _store?: Store;
+    protected get store(): T;
+    protected _store?: T;
     private _initialized;
     ready(): Promise<void>;
-    constructor($store: Store | Promise<Store>);
+    constructor($store: T | Promise<T>);
     metadata(): FileSystemMetadata;
     /**
      * Delete all contents stored in the file system.

package/dist/backends/store/fs.js

@@ -8,7 +8,7 @@ import { FileType } from '../../stats.js';
 import { encodeDirListing, encode, decodeDirListing } from '../../utils.js';
 const maxInodeAllocTries = 5;
 /**
- * A synchronous key-value file system. Uses a SyncStore to store the data.
+ * A file system which uses a key-value store.
  *
  * We use a unique ID for each node in the file system. The root node has a fixed ID.
  * @todo Introduce Node ID caching.