@zenfs/core 0.11.1 → 0.11.2

package/dist/backends/fetch.d.ts

@@ -71,7 +71,7 @@ export declare const Fetch: {
         readonly index: {
             readonly type: readonly ["string", "object"];
             readonly required: false;
-            readonly description: "URL to a file index as a JSON file or the file index object itself, generated with the make_http_index script. Defaults to `index.json`.";
+            readonly description: "URL to a file index as a JSON file or the file index object itself, generated with the make-index script. Defaults to `index.json`.";
         };
         readonly baseUrl: {
             readonly type: "string";

package/dist/backends/fetch.js

@@ -2,23 +2,23 @@ import { ErrnoError, Errno } from '../error.js';
 import { NoSyncFile } from '../file.js';
 import { Stats } from '../stats.js';
 import { FileIndex, AsyncIndexFS } from './Index.js';
-/**
- * @hidden
- */
-function convertError(e) {
-    throw new ErrnoError(Errno.EIO, e.message);
-}
 async function fetchFile(path, type) {
-    const response = await fetch(path).catch(convertError);
+    const response = await fetch(path).catch(e => {
+        throw new ErrnoError(Errno.EIO, e.message);
+    });
     if (!response.ok) {
         throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status);
     }
     switch (type) {
         case 'buffer':
-            const arrayBuffer = await response.arrayBuffer().catch(convertError);
+            const arrayBuffer = await response.arrayBuffer().catch(e => {
+                throw new ErrnoError(Errno.EIO, e.message);
+            });
             return new Uint8Array(arrayBuffer);
         case 'json':
-            return response.json().catch(convertError);
+            return response.json().catch(e => {
+                throw new ErrnoError(Errno.EIO, e.message);
+            });
         default:
             throw new ErrnoError(Errno.EINVAL, 'Invalid download type: ' + type);
     }
@@ -28,7 +28,9 @@ async function fetchFile(path, type) {
  * @hidden
  */
 async function fetchSize(path) {
-    const response = await fetch(path, { method: 'HEAD' }).catch(convertError);
+    const response = await fetch(path, { method: 'HEAD' }).catch(e => {
+        throw new ErrnoError(Errno.EIO, e.message);
+    });
     if (!response.ok) {
         throw new ErrnoError(Errno.EIO, 'fetch failed: HEAD response returned code ' + response.status);
     }
@@ -153,7 +155,7 @@ export const Fetch = {
         index: {
             type: ['string', 'object'],
             required: false,
-            description: 'URL to a file index as a JSON file or the file index object itself, generated with the make_http_index script. Defaults to `index.json`.',
+            description: 'URL to a file index as a JSON file or the file index object itself, generated with the make-index script. Defaults to `index.json`.',
         },
         baseUrl: {
             type: 'string',

package/dist/backends/locked.d.ts

@@ -14,7 +14,7 @@ import type { Stats } from '../stats.js';
  */
 export declare class LockedFS<FS extends FileSystem> implements FileSystem {
     readonly fs: FS;
-    private _mu;
+    private mutex;
     constructor(fs: FS);
     ready(): Promise<void>;
     metadata(): FileSystemMetadata;

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.