@zenfs/core 0.10.0 → 0.11.1

package/dist/config.d.ts

@@ -22,4 +22,4 @@ export interface Configuration {
  * Creates filesystems with the given configuration, and initializes ZenFS with it.
  * @see Configuration for more info on the configuration object.
  */
-export declare function configure(config: MountConfiguration | Configuration): Promise<void>;
+export declare function configure<T extends MountConfiguration | Configuration>(config: T | Configuration): Promise<void>;

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/shared.js

@@ -1,6 +1,6 @@
 // Utilities and shared data
 import { ErrnoError, Errno } from '../error.js';
-import { InMemory } from '../backends/InMemory.js';
+import { InMemory } from '../backends/memory.js';
 import { rootCred } from '../cred.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';

package/dist/error.d.ts

@@ -187,7 +187,6 @@ export declare class ErrnoError extends Error implements NodeJS.ErrnoException {
      *
      * Error codes mirror those returned by regular Unix file operations, which is
      * what Node returns.
-     * @constructor ApiError
      * @param type The type of the error.
      * @param message A descriptive error message.
      */

package/dist/error.js

@@ -254,7 +254,6 @@ export class ErrnoError extends Error {
      *
      * Error codes mirror those returned by regular Unix file operations, which is
      * what Node returns.
-     * @constructor ApiError
      * @param type The type of the error.
      * @param message A descriptive error message.
      */

package/dist/file.js

@@ -404,7 +404,7 @@ export class PreloadFile extends File {
             // No copy/read. Return immediatly for better performance
             return bytesRead;
         }
-        new Uint8Array(buffer.buffer, 0, length).set(this._buffer.slice(position, end), offset);
+        new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
         return bytesRead;
     }
     /**

package/dist/filesystem.d.ts

@@ -39,7 +39,7 @@ export declare abstract class FileSystem {
      */
     metadata(): FileSystemMetadata;
     constructor(options?: object);
-    ready(): Promise<this>;
+    ready(): Promise<void>;
     /**
      * Asynchronous rename. No arguments other than a possible exception
      * are given to the completion callback.
@@ -149,7 +149,7 @@ export declare abstract class FileSystem {
  */
 declare abstract class SyncFileSystem extends FileSystem {
     metadata(): FileSystemMetadata;
-    ready(): Promise<this>;
+    ready(): Promise<void>;
     exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
@@ -176,7 +176,7 @@ declare abstract class AsyncFileSystem extends FileSystem {
     abstract _sync: FileSystem;
     queueDone(): Promise<void>;
     metadata(): FileSystemMetadata;
-    ready(): Promise<this>;
+    ready(): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: string, mode: number, cred: Cred): File;

package/dist/filesystem.js

@@ -27,9 +27,7 @@ export class FileSystem {
     constructor(options) {
         // unused
     }
-    async ready() {
-        return this;
-    }
+    async ready() { }
     /**
      * Test whether or not the given path exists by checking with the file system.
      */
@@ -133,7 +131,7 @@ export function Async(FS) {
             await this._sync.ready();
             await super.ready();
             if (this._isInitialized) {
-                return this;
+                return;
             }
             try {
                 await this.crossCopy('/');
@@ -143,14 +141,13 @@ export function Async(FS) {
                 this._isInitialized = false;
                 throw e;
             }
-            return this;
         }
         renameSync(oldPath, newPath, cred) {
             this._sync.renameSync(oldPath, newPath, cred);
             this.queue('rename', oldPath, newPath, cred);
         }
-        statSync(p, cred) {
-            return this._sync.statSync(p, cred);
+        statSync(path, cred) {
+            return this._sync.statSync(path, cred);
         }
         createFileSync(path, flag, mode, cred) {
             const file = this._sync.createFileSync(path, flag, mode, cred);
@@ -163,20 +160,20 @@ export function Async(FS) {
         openFileSync(path, flag, cred) {
             return this._sync.openFileSync(path, flag, cred);
         }
-        unlinkSync(p, cred) {
-            this._sync.unlinkSync(p, cred);
-            this.queue('unlink', p, cred);
+        unlinkSync(path, cred) {
+            this._sync.unlinkSync(path, cred);
+            this.queue('unlink', path, cred);
         }
-        rmdirSync(p, cred) {
-            this._sync.rmdirSync(p, cred);
-            this.queue('rmdir', p, cred);
+        rmdirSync(path, cred) {
+            this._sync.rmdirSync(path, cred);
+            this.queue('rmdir', path, cred);
         }
-        mkdirSync(p, mode, cred) {
-            this._sync.mkdirSync(p, mode, cred);
-            this.queue('mkdir', p, mode, cred);
+        mkdirSync(path, mode, cred) {
+            this._sync.mkdirSync(path, mode, cred);
+            this.queue('mkdir', path, mode, cred);
         }
-        readdirSync(p, cred) {
-            return this._sync.readdirSync(p, cred);
+        readdirSync(path, cred) {
+            return this._sync.readdirSync(path, cred);
         }
         linkSync(srcpath, dstpath, cred) {
             this._sync.linkSync(srcpath, dstpath, cred);
@@ -186,27 +183,27 @@ export function Async(FS) {
             this._sync.syncSync(path, data, stats);
             this.queue('sync', path, data, stats);
         }
-        existsSync(p, cred) {
-            return this._sync.existsSync(p, cred);
+        existsSync(path, cred) {
+            return this._sync.existsSync(path, cred);
         }
         /**
          * @internal
          */
-        async crossCopy(p) {
-            const stats = await this.stat(p, rootCred);
+        async crossCopy(path) {
+            const stats = await this.stat(path, rootCred);
             if (stats.isDirectory()) {
-                if (p !== '/') {
-                    const stats = await this.stat(p, rootCred);
-                    this._sync.mkdirSync(p, stats.mode, stats.cred());
+                if (path !== '/') {
+                    const stats = await this.stat(path, rootCred);
+                    this._sync.mkdirSync(path, stats.mode, stats.cred());
                 }
-                const files = await this.readdir(p, rootCred);
+                const files = await this.readdir(path, rootCred);
                 for (const file of files) {
-                    await this.crossCopy(join(p, file));
+                    await this.crossCopy(join(path, file));
                 }
             }
             else {
-                const asyncFile = await this.openFile(p, parseFlag('r'), rootCred);
-                const syncFile = this._sync.createFileSync(p, parseFlag('w'), stats.mode, stats.cred());
+                const asyncFile = await this.openFile(path, parseFlag('r'), rootCred);
+                const syncFile = this._sync.createFileSync(path, parseFlag('w'), stats.mode, stats.cred());
                 try {
                     const buffer = new Uint8Array(stats.size);
                     await asyncFile.read(buffer);

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 export * from './error.js';
 export * from './backends/port/fs.js';
-export * from './backends/port/store.js';
-export * from './backends/AsyncStore.js';
-export * from './backends/Fetch.js';
-export * from './backends/InMemory.js';
+export * from './backends/fetch.js';
+export * from './backends/memory.js';
 export * from './backends/Index.js';
-export * from './backends/Locked.js';
-export * from './backends/Overlay.js';
-export * from './backends/SyncStore.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

@@ -1,13 +1,13 @@
 export * from './error.js';
 export * from './backends/port/fs.js';
-export * from './backends/port/store.js';
-export * from './backends/AsyncStore.js';
-export * from './backends/Fetch.js';
-export * from './backends/InMemory.js';
+export * from './backends/fetch.js';
+export * from './backends/memory.js';
 export * from './backends/Index.js';
-export * from './backends/Locked.js';
-export * from './backends/Overlay.js';
-export * from './backends/SyncStore.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/inode.d.ts

@@ -13,7 +13,7 @@ export declare const size_max: number;
  * Room inode
  * @hidden
  */
-export declare const rootIno: Ino;
+export declare const rootIno: 0n;
 /**
  * Generate a random ino
  * @internal

package/package.json

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

package/src/backends/Index.ts

@@ -340,16 +340,16 @@ export class IndexDirInode<TData> extends IndexInode<TData> {
 	}
 	/**
 	 * Removes the given item from the directory listing.
-	 * @param p Name of item to remove from the directory listing.
+	 * @param path Name of item to remove from the directory listing.
 	 * @return Returns the item
 	 *   removed, or null if the item did not exist.
 	 */
-	public remove(p: string): IndexInode<TData> | void {
-		const item = this._listing.get(p);
+	public remove(path: string): IndexInode<TData> | void {
+		const item = this._listing.get(path);
 		if (!item) {
 			return;
 		}
-		this._listing.delete(p);
+		this._listing.delete(path);
 		return item;
 	}
 }

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,12 +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);
-	return fs.ready();
-}
-
 /**
  * Specifies a file system backend type and its options.
  *

package/src/backends/{Fetch.ts → fetch.ts}

@@ -19,11 +19,11 @@ function convertError(e: Error): never {
  * constants.
  * @hidden
  */
-async function fetchFile(p: string, type: 'buffer'): Promise<Uint8Array>;
-async function fetchFile<T extends object>(p: string, type: 'json'): Promise<T>;
-async function fetchFile<T extends object>(p: string, type: 'buffer' | 'json'): Promise<T | Uint8Array>;
-async function fetchFile<T extends object>(p: string, type: 'buffer' | 'json'): Promise<T | Uint8Array> {
-	const response = await fetch(p).catch(convertError);
+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);
 	if (!response.ok) {
 		throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status);
 	}
@@ -42,8 +42,8 @@ async function fetchFile<T extends object>(p: string, type: 'buffer' | 'json'):
  * Asynchronously retrieves the size of the given file in bytes.
  * @hidden
  */
-async function fetchSize(p: string): Promise<number> {
-	const response = await fetch(p, { method: 'HEAD' }).catch(convertError);
+async function fetchSize(path: string): Promise<number> {
+	const response = await fetch(path, { method: 'HEAD' }).catch(convertError);
 	if (!response.ok) {
 		throw new ErrnoError(Errno.EIO, 'fetch failed: HEAD response returned code ' + response.status);
 	}
@@ -106,9 +106,8 @@ export class FetchFS extends AsyncIndexFS<Stats> {
 		}
 	}
 
-	public async ready(): Promise<this> {
+	public async ready(): Promise<void> {
 		await this._init;
-		return this;
 	}
 
 	constructor({ index = 'index.json', baseUrl = '' }: FetchOptions) {
@@ -189,11 +188,11 @@ export class FetchFS extends AsyncIndexFS<Stats> {
 	/**
 	 * Asynchronously download the given file.
 	 */
-	protected _fetchFile(p: string, type: 'buffer'): Promise<Uint8Array>;
-	protected _fetchFile(p: string, type: 'json'): Promise<object>;
-	protected _fetchFile(p: string, type: 'buffer' | 'json'): Promise<object>;
-	protected _fetchFile(p: string, type: 'buffer' | 'json'): Promise<object> {
-		return fetchFile(this._getRemotePath(p), type);
+	protected _fetchFile(path: string, type: 'buffer'): Promise<Uint8Array>;
+	protected _fetchFile(path: string, type: 'json'): Promise<object>;
+	protected _fetchFile(path: string, type: 'buffer' | 'json'): Promise<object>;
+	protected _fetchFile(path: string, type: 'buffer' | 'json'): Promise<object> {
+		return fetchFile(this._getRemotePath(path), type);
 	}
 
 	/**

package/src/backends/{Locked.ts → locked.ts}

@@ -20,9 +20,8 @@ export class LockedFS<FS extends FileSystem> implements FileSystem {
 
 	constructor(public readonly fs: FS) {}
 
-	public async ready(): Promise<this> {
+	public async ready(): Promise<void> {
 		await this.fs.ready();
-		return this;
 	}
 
 	public metadata(): FileSystemMetadata {
@@ -87,10 +86,10 @@ export class LockedFS<FS extends FileSystem> implements FileSystem {
 		return this.fs.createFileSync(path, flag, mode, cred);
 	}
 
-	public async unlink(p: string, cred: Cred): Promise<void> {
-		await this._mu.lock(p);
-		await this.fs.unlink(p, cred);
-		this._mu.unlock(p);
+	public async unlink(path: string, cred: Cred): Promise<void> {
+		await this._mu.lock(path);
+		await this.fs.unlink(path, cred);
+		this._mu.unlock(path);
 	}
 
 	public unlinkSync(path: string, cred: Cred): void {

package/src/backends/memory.ts

@@ -0,0 +1,44 @@
+import type { Ino } from '../inode.js';
+import type { Backend } from './backend.js';
+import { StoreFS } from './store/fs.js';
+import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
+
+/**
+ * A simple in-memory store
+ */
+export class InMemoryStore extends Map<Ino, Uint8Array> implements SimpleSyncStore {
+	public constructor(public name: string = 'tmp') {
+		super();
+	}
+
+	public async sync(): Promise<void> {}
+
+	public clearSync(): void {
+		this.clear();
+	}
+
+	public transaction(): SimpleTransaction {
+		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(): boolean {
+		return true;
+	},
+	options: {
+		name: {
+			type: 'string',
+			required: false,
+			description: 'The name of the store',
+		},
+	},
+	create({ name }: { name?: string }) {
+		return new StoreFS(new InMemoryStore(name));
+	},
+} as const satisfies Backend<StoreFS, { name?: string }>;