@zenfs/core 0.11.0 → 0.11.2

package/dist/config.js

@@ -40,7 +40,7 @@ export async function resolveMountConfig(config, _depth = 0) {
         throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
     }
     checkOptions(backend, config);
-    const mount = backend.create(config);
+    const mount = await backend.create(config);
     await mount.ready();
     return mount;
 }

package/dist/emulation/promises.js

@@ -106,8 +106,7 @@ export class FileHandle {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading.');
         }
         const { size } = await this.stat();
-        const data = new Uint8Array(size);
-        await this.file.read(data, 0, size, 0);
+        const { buffer: data } = await this.file.read(new Uint8Array(size), 0, size, 0);
         const buffer = Buffer.from(data);
         return options.encoding ? buffer.toString(options.encoding) : buffer;
     }

package/dist/emulation/sync.js

@@ -7,7 +7,7 @@ import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFM
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
-function doOp(...[name, resolveSymlinks, path, ...args]) {
+function wrap(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
     try {
@@ -60,12 +60,12 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = doOp('statSync', true, path.toString(), cred);
+    const stats = wrap('statSync', true, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = doOp('statSync', false, path.toString(), cred);
+    const stats = wrap('statSync', false, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 lstatSync;
@@ -89,7 +89,7 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return doOp('unlinkSync', false, path.toString(), cred);
+    return wrap('unlinkSync', false, path.toString(), cred);
 }
 unlinkSync;
 function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
@@ -97,18 +97,18 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
     // Check if the path exists, and is a file.
     let stats;
     try {
-        stats = doOp('statSync', resolveSymlinks, path, cred);
+        stats = wrap('statSync', resolveSymlinks, path, cred);
     }
     catch (e) {
         // File does not exist.
         switch (pathNotExistsAction(flag)) {
             case ActionType.CREATE:
                 // Ensure parent exists.
-                const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
+                const parentStats = wrap('statSync', resolveSymlinks, dirname(path), cred);
                 if (!parentStats.isDirectory()) {
                     throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
                 }
-                return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
+                return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
                 throw ErrnoError.With('ENOENT', path, '_open');
             default:
@@ -124,16 +124,16 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
             throw ErrnoError.With('EEXIST', path, '_open');
         case ActionType.TRUNCATE:
             // Delete file.
-            doOp('unlinkSync', resolveSymlinks, path, cred);
+            wrap('unlinkSync', resolveSymlinks, path, cred);
             /*
                 Create file. Use the same mode as the old file.
                 Node itself modifies the ctime when this occurs, so this action
                 will preserve that behavior if the underlying file system
                 supports those properties.
             */
-            return doOp('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+            return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
         case ActionType.NOP:
-            return doOp('openFileSync', resolveSymlinks, path, flag, cred);
+            return wrap('openFileSync', resolveSymlinks, path, flag, cred);
         default:
             throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
     }
@@ -185,21 +185,6 @@ export function readFileSync(path, _options = {}) {
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
-/**
- * Synchronously writes data to a file, replacing the file
- * if it already exists.
- *
- * The encoding option is ignored if data is a buffer.
- */
-function _writeFileSync(fname, data, flag, mode, resolveSymlinks) {
-    const file = _openSync(fname, flag, mode, resolveSymlinks);
-    try {
-        file.writeSync(data, 0, data.byteLength, 0);
-    }
-    finally {
-        file.closeSync();
-    }
-}
 export function writeFileSync(path, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
     const flag = parseFlag(options.flag);
@@ -213,22 +198,15 @@ export function writeFileSync(path, data, _options = {}) {
     if (!encodedData) {
         throw new ErrnoError(Errno.EINVAL, 'Data not specified');
     }
-    _writeFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), encodedData, options.flag, options.mode, true);
-}
-writeFileSync;
-/**
- * Synchronously append data to a file, creating the file if
- * it not yet exists.
- */
-function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
-    const file = _openSync(fname, flag, mode, resolveSymlinks);
+    const file = _openSync(typeof path == 'number' ? fd2file(path).path : path.toString(), flag, options.mode, true);
     try {
-        file.writeSync(data, 0, data.byteLength, null);
+        file.writeSync(encodedData, 0, encodedData.byteLength, 0);
     }
     finally {
         file.closeSync();
     }
 }
+writeFileSync;
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
@@ -250,7 +228,13 @@ export function appendFileSync(filename, data, _options = {}) {
         throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
     }
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    _appendFileSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), encodedData, options.flag, options.mode, true);
+    const file = _openSync(typeof filename == 'number' ? fd2file(filename).path : filename.toString(), flag, options.mode, true);
+    try {
+        file.writeSync(encodedData, 0, encodedData.byteLength, null);
+    }
+    finally {
+        file.closeSync();
+    }
 }
 appendFileSync;
 export function fstatSync(fd, options) {
@@ -371,18 +355,18 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return doOp('rmdirSync', true, path.toString(), cred);
+    return wrap('rmdirSync', true, path.toString(), cred);
 }
 rmdirSync;
 export function mkdirSync(path, options) {
     const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
     const recursive = typeof options == 'object' && options?.recursive;
-    doOp('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+    wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
 }
 mkdirSync;
 export function readdirSync(path, options) {
     path = normalizePath(path);
-    const entries = doOp('readdirSync', true, path, cred);
+    const entries = wrap('readdirSync', true, path, cred);
     for (const mount of mounts.keys()) {
         if (!mount.startsWith(path)) {
             continue;
@@ -413,7 +397,7 @@ readdirSync;
  */
 export function linkSync(existing, newpath) {
     newpath = normalizePath(newpath);
-    return doOp('linkSync', false, existing.toString(), newpath.toString(), cred);
+    return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
 }
 linkSync;
 /**

package/dist/filesystem.d.ts

@@ -147,7 +147,7 @@ export declare abstract class FileSystem {
 /**
  * @internal
  */
-declare abstract class SyncFileSystem extends FileSystem {
+declare abstract class SyncFS extends FileSystem {
     metadata(): FileSystemMetadata;
     ready(): Promise<void>;
     exists(path: string, cred: Cred): Promise<boolean>;
@@ -165,11 +165,11 @@ declare abstract class SyncFileSystem extends FileSystem {
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */
-export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFileSystem) & T;
+export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFS) & T;
 /**
  * @internal
  */
-declare abstract class AsyncFileSystem extends FileSystem {
+declare abstract class AsyncFS extends FileSystem {
     /**
      * @hidden
      */
@@ -200,11 +200,11 @@ declare abstract class AsyncFileSystem extends FileSystem {
  *   the synchronous store, if desired.
  *
  */
-export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFileSystem) & T;
+export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFS) & T;
 /**
  * @internal
  */
-declare abstract class ReadonlyFileSystem extends FileSystem {
+declare abstract class ReadonlyFS extends FileSystem {
     metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
@@ -224,5 +224,5 @@ declare abstract class ReadonlyFileSystem extends FileSystem {
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
-export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFileSystem) & T;
+export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFS) & T;
 export {};

package/dist/filesystem.js

@@ -58,7 +58,7 @@ export class FileSystem {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function Sync(FS) {
-    class _SyncFileSystem extends FS {
+    class _SyncFS extends FS {
         async exists(path, cred) {
             return this.existsSync(path, cred);
         }
@@ -93,7 +93,7 @@ export function Sync(FS) {
             return this.syncSync(path, data, stats);
         }
     }
-    return _SyncFileSystem;
+    return _SyncFS;
 }
 /**
  * Async() implements synchronous methods on an asynchronous file system
@@ -109,7 +109,7 @@ export function Sync(FS) {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function Async(FS) {
-    class _AsyncFileSystem extends FS {
+    class _AsyncFS extends FS {
         constructor() {
             super(...arguments);
             /**
@@ -150,16 +150,17 @@ export function Async(FS) {
             return this._sync.statSync(path, cred);
         }
         createFileSync(path, flag, mode, cred) {
-            const file = this._sync.createFileSync(path, flag, mode, cred);
+            this._sync.createFileSync(path, flag, mode, cred);
             this.queue('createFile', path, flag, mode, cred);
+            return this.openFileSync(path, flag, cred);
+        }
+        openFileSync(path, flag, cred) {
+            const file = this._sync.openFileSync(path, flag, cred);
             const stats = file.statSync();
             const buffer = new Uint8Array(stats.size);
             file.readSync(buffer);
             return new PreloadFile(this, path, flag, stats, buffer);
         }
-        openFileSync(path, flag, cred) {
-            return this._sync.openFileSync(path, flag, cred);
-        }
         unlinkSync(path, cred) {
             this._sync.unlinkSync(path, cred);
             this.queue('unlink', path, cred);
@@ -235,14 +236,14 @@ export function Async(FS) {
             this._next();
         }
     }
-    return _AsyncFileSystem;
+    return _AsyncFS;
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function Readonly(FS) {
-    class _ReadonlyFileSystem extends FS {
+    class _ReadonlyFS extends FS {
         metadata() {
             return { ...super.metadata(), readonly: true };
         }
@@ -290,5 +291,5 @@ export function Readonly(FS) {
             throw new ErrnoError(Errno.EROFS);
         }
     }
-    return _ReadonlyFileSystem;
+    return _ReadonlyFS;
 }

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export * from './backends/Index.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';
+export * from './backends/store/simple.js';
+export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
 export * from './cred.js';

package/dist/index.js

@@ -6,6 +6,8 @@ export * from './backends/Index.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';
+export * from './backends/store/simple.js';
+export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
 export * from './cred.js';

package/dist/mutex.d.ts

@@ -3,7 +3,7 @@
  * @internal
  */
 export declare class Mutex {
-    private _locks;
+    protected locks: Map<string, (() => void)[]>;
     lock(path: string): Promise<void>;
     unlock(path: string): void;
     tryLock(path: string): boolean;

package/dist/mutex.js

@@ -5,23 +5,23 @@ import { ErrnoError, Errno } from './error.js';
  */
 export class Mutex {
     constructor() {
-        this._locks = new Map();
+        this.locks = new Map();
     }
     lock(path) {
         return new Promise(resolve => {
-            if (this._locks.has(path)) {
-                this._locks.get(path).push(resolve);
+            if (this.locks.has(path)) {
+                this.locks.get(path).push(resolve);
             }
             else {
-                this._locks.set(path, [resolve]);
+                this.locks.set(path, [resolve]);
             }
         });
     }
     unlock(path) {
-        if (!this._locks.has(path)) {
+        if (!this.locks.has(path)) {
             throw new ErrnoError(Errno.EPERM, 'Can not unlock an already unlocked path', path);
         }
-        const next = this._locks.get(path)?.shift();
+        const next = this.locks.get(path)?.shift();
         /*
             don't unlock - we want to queue up next for the
             end of the current task execution, but we don't
@@ -31,19 +31,19 @@ export class Mutex {
             lock won't cause starvation.
         */
         if (next) {
-            setTimeout(next, 0);
+            setTimeout(next);
             return;
         }
-        this._locks.delete(path);
+        this.locks.delete(path);
     }
     tryLock(path) {
-        if (this._locks.has(path)) {
+        if (this.locks.has(path)) {
             return false;
         }
-        this._locks.set(path, []);
+        this.locks.set(path, []);
         return true;
     }
     isLocked(path) {
-        return this._locks.has(path);
+        return this.locks.has(path);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.11.0",
+	"version": "0.11.2",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",

package/scripts/make-index.js

@@ -16,19 +16,19 @@ const { values: options, positionals } = parseArgs({
 	allowPositionals: true,
 });
 
-const root = positionals.at(-1) == 'make-index' ? '.' : positionals.at(-1);
+const root = positionals.at(-1) || '.';
 
 if (options.help) {
 	console.log(`make-index <path> [...options]
-	path: The path to create a listing for
 
-	options:
-		--help, -h				Outputs this help message
-		--quiet, -q 			Do not output messages about individual files
-		--verbose				Output verbose messages
+path: The path to create a listing for
 
-		--output, -o <path>		Path to the output file. Defaults to listing.
-		--ignore, -i <pattern>	Ignores files which match the glob <pattern>. Can be passed multiple times.
+options:
+	--help, -h		Outputs this help message
+	--quiet, -q		The command will not generate any output, including error messages.
+	--verbose		Output verbose messages
+	--output, -o <path>	Path to the output file. Defaults to listing.
+	--ignore, -i <pattern>	Ignores files which match the glob <pattern>. Can be passed multiple times.
 	`);
 	process.exit();
 }
@@ -66,11 +66,13 @@ function color(color, text) {
 	return `\x1b[${colors[color]}m${text}\x1b[0m`;
 }
 
-function makeListing(path, seen = new Set()) {
+function listing(path, seen = new Set()) {
 	try {
+		if (options.verbose) console.log(`${color('blue', 'list')} ${path}`);
 		const stats = statSync(path);
 
 		if (stats.isFile()) {
+			if (options.verbose) console.log(`${color('green', 'file')} ${path}`);
 			return null;
 		}
 
@@ -82,8 +84,9 @@ function makeListing(path, seen = new Set()) {
 				continue;
 			}
 
-			entries[file] = makeListing(full, seen);
+			entries[file] = listing(full, seen);
 		}
+		if (options.verbose) console.log(`${color('bright_green', ' dir')} ${path}`);
 		return entries;
 	} catch (e) {
 		if (!options.quiet) {
@@ -92,7 +95,7 @@ function makeListing(path, seen = new Set()) {
 	}
 }
 
-const listing = makeListing(pathToPosix(root));
+const rootListing = listing(pathToPosix(root));
 if (!options.quiet) console.log('Generated listing for ' + pathToPosix(resolve(root)));
 
-writeFileSync(options.output, JSON.stringify(listing));
+writeFileSync(options.output, JSON.stringify(rootListing));

package/src/backends/backend.ts

@@ -41,7 +41,7 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
 	/**
 	 * Create a new instance of the backend
 	 */
-	create(options: TOptions): FS;
+	create(options: TOptions): FS | Promise<FS>;
 
 	/**
 	 * A name to identify the backend.
@@ -68,6 +68,8 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
 
 type OptionsOf<T extends Backend> = T extends Backend<FileSystem, infer TOptions> ? TOptions : never;
 
+type FilesystemOf<T extends Backend> = T extends Backend<infer FS> ? FS : never;
+
 /**
  * @internal
  */
@@ -128,13 +130,6 @@ export async function checkOptions<T extends Backend>(backend: T, opts: Partial<
 	}
 }
 
-export async function createBackend<B extends Backend>(backend: B, options: Partial<OptionsOf<B>> = {}): Promise<ReturnType<B['create']>> {
-	await checkOptions(backend, options);
-	const fs = <ReturnType<B['create']>>backend.create(options);
-	await fs.ready();
-	return fs;
-}
-
 /**
  * Specifies a file system backend type and its options.
  *

package/src/backends/fetch.ts

@@ -5,13 +5,6 @@ import { Stats } from '../stats.js';
 import { type ListingTree, FileIndex, type IndexFileInode, AsyncIndexFS } from './Index.js';
 import type { Backend } from './backend.js';
 
-/**
- * @hidden
- */
-function convertError(e: Error): never {
-	throw new ErrnoError(Errno.EIO, e.message);
-}
-
 /**
  * Asynchronously download a file as a buffer or a JSON object.
  * Note that the third function signature with a non-specialized type is
@@ -23,16 +16,22 @@ async function fetchFile(path: string, type: 'buffer'): Promise<Uint8Array>;
 async function fetchFile<T extends object>(path: string, type: 'json'): Promise<T>;
 async function fetchFile<T extends object>(path: string, type: 'buffer' | 'json'): Promise<T | Uint8Array>;
 async function fetchFile<T extends object>(path: string, type: 'buffer' | 'json'): Promise<T | Uint8Array> {
-	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) as Promise<T>;
+			return response.json().catch(e => {
+				throw new ErrnoError(Errno.EIO, e.message);
+			}) as Promise<T>;
 		default:
 			throw new ErrnoError(Errno.EINVAL, 'Invalid download type: ' + type);
 	}
@@ -43,7 +42,9 @@ async function fetchFile<T extends object>(path: string, type: 'buffer' | 'json'
  * @hidden
  */
 async function fetchSize(path: string): Promise<number> {
-	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);
 	}
@@ -210,7 +211,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',