@zenfs/dom 1.0.1 → 1.0.3

package/dist/IndexedDB.d.ts

@@ -8,6 +8,7 @@ export declare class IndexedDBTransaction extends AsyncTransaction<IndexedDBStor
     store: IndexedDBStore;
     private _idb;
     constructor(tx: IDBTransaction, store: IndexedDBStore);
+    keys(): Promise<Iterable<Ino>>;
     get(key: Ino): Promise<Uint8Array>;
     set(key: Ino, data: Uint8Array): Promise<void>;
     remove(key: Ino): Promise<void>;

package/dist/IndexedDB.js

@@ -19,6 +19,9 @@ export class IndexedDBTransaction extends AsyncTransaction {
         this.store = store;
         this._idb = tx.objectStore(store.name);
     }
+    async keys() {
+        return (await wrap(this._idb.getAllKeys())).filter(k => typeof k == 'string').map(k => BigInt(k));
+    }
     get(key) {
         return wrap(this._idb.get(key.toString()));
     }
@@ -69,7 +72,7 @@ export class IndexedDBStore {
         this.db = db;
     }
     sync() {
-        throw new Error('Method not implemented.');
+        throw ErrnoError.With('ENOSYS', undefined, 'IndexedDBStore.sync');
     }
     get name() {
         return this.db.name;

package/dist/Storage.d.ts

@@ -11,6 +11,7 @@ export declare class WebStorageStore implements Store, SimpleSyncStore {
     clearSync(): void;
     sync(): Promise<void>;
     transaction(): SimpleTransaction;
+    keys(): Iterable<Ino>;
     get(key: Ino): Uint8Array | undefined;
     set(key: Ino, data: Uint8Array): void;
     delete(key: Ino): void;
@@ -36,6 +37,9 @@ declare const _WebStorage: {
             readonly description: "The Storage to use. Defaults to globalThis.localStorage.";
         };
     };
+    /**
+     * @todo Consider replacing `instanceof` with a duck-typing check?
+     */
     readonly isAvailable: (storage?: Storage) => boolean;
     readonly create: ({ storage }: WebStorageOptions) => StoreFS<WebStorageStore>;
 };

package/dist/Storage.js

@@ -20,6 +20,9 @@ export class WebStorageStore {
         // No need to differentiate.
         return new SimpleTransaction(this);
     }
+    keys() {
+        return Object.keys(this.storage).map(k => BigInt(k));
+    }
     get(key) {
         const data = this.storage.getItem(key.toString());
         if (typeof data != 'string') {
@@ -56,6 +59,9 @@ const _WebStorage = {
             description: 'The Storage to use. Defaults to globalThis.localStorage.',
         },
     },
+    /**
+     * @todo Consider replacing `instanceof` with a duck-typing check?
+     */
     isAvailable(storage = globalThis.localStorage) {
         return storage instanceof globalThis.Storage;
     },

package/dist/access.d.ts

@@ -1,13 +1,5 @@
 import type { FileSystemMetadata } from '@zenfs/core';
 import { FileSystem, PreloadFile, Stats } from '@zenfs/core';
-declare global {
-    interface FileSystemDirectoryHandle {
-        [Symbol.iterator](): IterableIterator<[string, FileSystemHandle]>;
-        entries(): IterableIterator<[string, FileSystemHandle]>;
-        keys(): IterableIterator<string>;
-        values(): IterableIterator<FileSystemHandle>;
-    }
-}
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
 }

package/dist/access.js

@@ -137,7 +137,11 @@ export class WebAccessFS extends Async(FileSystem) {
         if (!(handle instanceof FileSystemDirectoryHandle)) {
             throw ErrnoError.With('ENOTDIR', path, 'readdir');
         }
-        return Array.from(handle.keys());
+        const entries = [];
+        for await (const k of handle.keys()) {
+            entries.push(k);
+        }
+        return entries;
     }
     async getHandle(path) {
         if (this._handles.has(path)) {

package/package.json

@@ -1,7 +1,11 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.0.1",
+	"version": "1.0.3",
 	"description": "DOM backends for ZenFS",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"type": "module",
@@ -17,7 +21,6 @@
 	},
 	"files": [
 		"dist",
-		"src",
 		"license.md",
 		"tsconfig.json"
 	],
@@ -42,12 +45,17 @@
 		"eslint": "^9.12.0",
 		"globals": "^15.10.0",
 		"prettier": "^3.2.5",
+		"tsx": "^4.19.2",
 		"typedoc": "^0.26.10",
 		"typescript": "^5.5.0",
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.1.0"
+		"@zenfs/core": "^1.2.0"
+	},
+	"optionalDependencies": {
+		"fake-indexeddb": "^6.0.0",
+		"file-system-access": "^1.0.4"
 	},
 	"keywords": [
 		"filesystem",

package/src/IndexedDB.ts

@@ -1,170 +0,0 @@
-import type { Backend, Ino, SharedConfig, Store } from '@zenfs/core';
-import { Async, AsyncTransaction, ErrnoError, InMemory, StoreFS } from '@zenfs/core';
-import { convertException } from './utils.js';
-
-function wrap<T>(request: IDBRequest<T>): Promise<T> {
-	return new Promise((resolve, reject) => {
-		request.onsuccess = () => resolve(request.result);
-		request.onerror = e => {
-			e.preventDefault();
-			reject(convertException(request.error!));
-		};
-	});
-}
-
-/**
- * @hidden
- */
-export class IndexedDBTransaction extends AsyncTransaction<IndexedDBStore> {
-	private _idb: IDBObjectStore;
-
-	public constructor(
-		public tx: IDBTransaction,
-		public store: IndexedDBStore
-	) {
-		super(store);
-		this._idb = tx.objectStore(store.name);
-	}
-
-	public get(key: Ino): Promise<Uint8Array> {
-		return wrap(this._idb.get(key.toString()));
-	}
-
-	public async set(key: Ino, data: Uint8Array): Promise<void> {
-		await wrap(this._idb.put(data, key.toString()));
-	}
-
-	public remove(key: Ino): Promise<void> {
-		return wrap(this._idb.delete(key.toString()));
-	}
-
-	public async commit(): Promise<void> {
-		if (this.done) {
-			return;
-		}
-		const { promise, resolve, reject } = Promise.withResolvers<void>();
-		this.done = true;
-		this.tx.oncomplete = () => resolve();
-		this.tx.onerror = () => reject(convertException(this.tx.error!));
-		this.tx.commit();
-		return promise;
-	}
-
-	public async abort(): Promise<void> {
-		if (this.done) {
-			return;
-		}
-		this.done = true;
-		const { promise, resolve, reject } = Promise.withResolvers<void>();
-		this.tx.onabort = () => resolve();
-		this.tx.onerror = () => reject(convertException(this.tx.error!));
-		this.tx.abort();
-		return promise;
-	}
-}
-
-async function createDB(name: string, indexedDB: IDBFactory = globalThis.indexedDB): Promise<IDBDatabase> {
-	const req: IDBOpenDBRequest = indexedDB.open(name);
-
-	req.onupgradeneeded = () => {
-		const db: IDBDatabase = req.result;
-		// This should never happen; we're at version 1. Why does another database exist?
-		if (db.objectStoreNames.contains(name)) {
-			db.deleteObjectStore(name);
-		}
-		db.createObjectStore(name);
-	};
-
-	const result = await wrap(req);
-	return result;
-}
-
-export class IndexedDBStore implements Store {
-	public constructor(protected db: IDBDatabase) {}
-
-	public sync(): Promise<void> {
-		throw new Error('Method not implemented.');
-	}
-
-	public get name(): string {
-		return this.db.name;
-	}
-
-	public clear(): Promise<void> {
-		return wrap(this.db.transaction(this.name, 'readwrite').objectStore(this.name).clear());
-	}
-
-	public clearSync(): void {
-		throw ErrnoError.With('ENOSYS', undefined, 'IndexedDBStore.clearSync');
-	}
-
-	public transaction(): IndexedDBTransaction {
-		const tx = this.db.transaction(this.name, 'readwrite');
-		return new IndexedDBTransaction(tx, this);
-	}
-}
-
-/**
- * Configuration options for the IndexedDB file system.
- */
-export interface IndexedDBOptions {
-	/**
-	 * The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.
-	 */
-	storeName?: string;
-
-	/**
-	 * The IDBFactory to use. Defaults to `globalThis.indexedDB`.
-	 */
-	idbFactory?: IDBFactory;
-}
-
-/**
- * A file system that uses the IndexedDB key value file system.
- */
-
-const _IndexedDB = {
-	name: 'IndexedDB',
-
-	options: {
-		storeName: {
-			type: 'string',
-			required: false,
-			description: 'The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.',
-		},
-		idbFactory: {
-			type: 'object',
-			required: false,
-			description: 'The IDBFactory to use. Defaults to globalThis.indexedDB.',
-		},
-	},
-
-	async isAvailable(idbFactory: IDBFactory = globalThis.indexedDB): Promise<boolean> {
-		try {
-			if (!(idbFactory instanceof IDBFactory)) {
-				return false;
-			}
-			const req = idbFactory.open('__zenfs_test');
-			await wrap(req);
-			idbFactory.deleteDatabase('__zenfs_test');
-			return true;
-		} catch (e) {
-			idbFactory.deleteDatabase('__zenfs_test');
-			return false;
-		}
-	},
-
-	async create(options: IndexedDBOptions & Partial<SharedConfig>) {
-		const db = await createDB(options.storeName || 'zenfs', options.idbFactory);
-		const store = new IndexedDBStore(db);
-		const fs = new (Async(StoreFS))(store);
-		if (!options?.disableAsyncCache) {
-			fs._sync = InMemory.create({ name: 'idb-cache' });
-		}
-		return fs;
-	},
-} as const satisfies Backend<StoreFS, IndexedDBOptions>;
-type _IndexedDB = typeof _IndexedDB;
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface IndexedDB extends _IndexedDB {}
-export const IndexedDB: IndexedDB = _IndexedDB;

package/src/Storage.ts

@@ -1,90 +0,0 @@
-import type { Backend, Ino, SimpleSyncStore, Store } from '@zenfs/core';
-import { ErrnoError, Errno, SimpleTransaction, StoreFS, decodeRaw, encodeRaw } from '@zenfs/core';
-
-/**
- * A synchronous key-value store backed by Storage.
- */
-export class WebStorageStore implements Store, SimpleSyncStore {
-	public get name(): string {
-		return WebStorage.name;
-	}
-
-	public constructor(protected storage: Storage) {}
-
-	public clear(): void {
-		this.storage.clear();
-	}
-
-	public clearSync(): void {
-		this.storage.clear();
-	}
-
-	public async sync(): Promise<void> {}
-
-	public transaction(): SimpleTransaction {
-		// No need to differentiate.
-		return new SimpleTransaction(this);
-	}
-
-	public get(key: Ino): Uint8Array | undefined {
-		const data = this.storage.getItem(key.toString());
-		if (typeof data != 'string') {
-			return;
-		}
-
-		return encodeRaw(data);
-	}
-
-	public set(key: Ino, data: Uint8Array): void {
-		try {
-			this.storage.setItem(key.toString(), decodeRaw(data));
-		} catch (e) {
-			throw new ErrnoError(Errno.ENOSPC, 'Storage is full.');
-		}
-	}
-
-	public delete(key: Ino): void {
-		try {
-			this.storage.removeItem(key.toString());
-		} catch (e) {
-			throw new ErrnoError(Errno.EIO, 'Unable to delete key ' + key + ': ' + e);
-		}
-	}
-}
-
-/**
- * Options to pass to the StorageFileSystem
- */
-export interface WebStorageOptions {
-	/**
-	 * The Storage to use. Defaults to globalThis.localStorage.
-	 */
-	storage?: Storage;
-}
-
-/**
- * A synchronous file system backed by a `Storage` (e.g. localStorage).
- */
-const _WebStorage = {
-	name: 'WebStorage',
-
-	options: {
-		storage: {
-			type: 'object',
-			required: false,
-			description: 'The Storage to use. Defaults to globalThis.localStorage.',
-		},
-	},
-
-	isAvailable(storage: Storage = globalThis.localStorage): boolean {
-		return storage instanceof globalThis.Storage;
-	},
-
-	create({ storage = globalThis.localStorage }: WebStorageOptions) {
-		return new StoreFS(new WebStorageStore(storage));
-	},
-} as const satisfies Backend<StoreFS, WebStorageOptions>;
-type _WebStorage = typeof _WebStorage;
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface WebStorage extends _WebStorage {}
-export const WebStorage: WebStorage = _WebStorage;

package/src/access.ts

@@ -1,237 +0,0 @@
-import type { Backend, FileSystemMetadata } from '@zenfs/core';
-import { Async, Errno, ErrnoError, FileSystem, InMemory, PreloadFile, Stats } from '@zenfs/core';
-import { S_IFDIR, S_IFREG } from '@zenfs/core/emulation/constants.js';
-import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
-import { convertException, type ConvertException } from './utils.js';
-
-declare global {
-	interface FileSystemDirectoryHandle {
-		[Symbol.iterator](): IterableIterator<[string, FileSystemHandle]>;
-		entries(): IterableIterator<[string, FileSystemHandle]>;
-		keys(): IterableIterator<string>;
-		values(): IterableIterator<FileSystemHandle>;
-	}
-}
-
-export interface WebAccessOptions {
-	handle: FileSystemDirectoryHandle;
-}
-
-export class WebAccessFS extends Async(FileSystem) {
-	private _handles: Map<string, FileSystemHandle> = new Map();
-
-	/**
-	 * @hidden
-	 */
-	_sync: FileSystem = InMemory.create({ name: 'accessfs-cache' });
-
-	public constructor(handle: FileSystemDirectoryHandle) {
-		super();
-		this._handles.set('/', handle);
-	}
-
-	public metadata(): FileSystemMetadata {
-		return {
-			...super.metadata(),
-			name: 'WebAccess',
-			noResizableBuffers: true,
-		};
-	}
-
-	public async sync(path: string, data: Uint8Array, stats: Stats): Promise<void> {
-		const currentStats = await this.stat(path);
-		if (stats.mtime !== currentStats.mtime) {
-			await this.writeFile(path, data);
-		}
-	}
-
-	public async rename(oldPath: string, newPath: string): Promise<void> {
-		try {
-			const handle = await this.getHandle(oldPath);
-			if (handle instanceof FileSystemDirectoryHandle) {
-				const files = await this.readdir(oldPath);
-
-				await this.mkdir(newPath);
-				if (files.length == 0) {
-					await this.unlink(oldPath);
-				} else {
-					for (const file of files) {
-						await this.rename(join(oldPath, file), join(newPath, file));
-						await this.unlink(oldPath);
-					}
-				}
-			}
-			if (!(handle instanceof FileSystemFileHandle)) {
-				return;
-			}
-			const oldFile = await handle.getFile(),
-				destFolder = await this.getHandle(dirname(newPath));
-			if (!(destFolder instanceof FileSystemDirectoryHandle)) {
-				return;
-			}
-			const newFile = await destFolder.getFileHandle(basename(newPath), { create: true });
-			const writable = await newFile.createWritable();
-			await writable.write(await oldFile.arrayBuffer());
-
-			await writable.close();
-			await this.unlink(oldPath);
-		} catch (ex) {
-			throw convertException(ex as ConvertException, oldPath, 'rename');
-		}
-	}
-
-	public async writeFile(path: string, data: Uint8Array): Promise<void> {
-		if (data.buffer.resizable) {
-			throw new ErrnoError(Errno.EINVAL, 'Resizable buffers can not be written', path, 'write');
-		}
-
-		const handle = await this.getHandle(dirname(path));
-		if (!(handle instanceof FileSystemDirectoryHandle)) {
-			return;
-		}
-
-		const file = await handle.getFileHandle(basename(path), { create: true });
-		const writable = await file.createWritable();
-		await writable.write(data);
-		await writable.close();
-	}
-
-	public async createFile(path: string, flag: string): Promise<PreloadFile<this>> {
-		await this.writeFile(path, new Uint8Array());
-		return this.openFile(path, flag);
-	}
-
-	public async stat(path: string): Promise<Stats> {
-		const handle = await this.getHandle(path);
-		if (!handle) {
-			throw ErrnoError.With('ENOENT', path, 'stat');
-		}
-		if (handle instanceof FileSystemDirectoryHandle) {
-			return new Stats({ mode: 0o777 | S_IFDIR, size: 4096 });
-		}
-		if (handle instanceof FileSystemFileHandle) {
-			const { lastModified, size } = await handle.getFile();
-			return new Stats({ mode: 0o777 | S_IFREG, size, mtimeMs: lastModified });
-		}
-		throw new ErrnoError(Errno.EBADE, 'Handle is not a directory or file', path, 'stat');
-	}
-
-	public async openFile(path: string, flag: string): Promise<PreloadFile<this>> {
-		const handle = await this.getHandle(path);
-		if (!(handle instanceof FileSystemFileHandle)) {
-			throw ErrnoError.With('EISDIR', path, 'openFile');
-		}
-		try {
-			const file = await handle.getFile();
-			const data = new Uint8Array(await file.arrayBuffer());
-			const stats = new Stats({ mode: 0o777 | S_IFREG, size: file.size, mtimeMs: file.lastModified });
-			return new PreloadFile(this, path, flag, stats, data);
-		} catch (ex) {
-			throw convertException(ex as ConvertException, path, 'openFile');
-		}
-	}
-
-	public async unlink(path: string): Promise<void> {
-		const handle = await this.getHandle(dirname(path));
-		if (handle instanceof FileSystemDirectoryHandle) {
-			try {
-				await handle.removeEntry(basename(path), { recursive: true });
-			} catch (ex) {
-				throw convertException(ex as ConvertException, path, 'unlink');
-			}
-		}
-	}
-
-	public async link(srcpath: string): Promise<void> {
-		throw ErrnoError.With('ENOSYS', srcpath, 'WebAccessFS.link');
-	}
-
-	public async rmdir(path: string): Promise<void> {
-		return this.unlink(path);
-	}
-
-	public async mkdir(path: string): Promise<void> {
-		const existingHandle = await this.getHandle(path);
-		if (existingHandle) {
-			throw ErrnoError.With('EEXIST', path, 'mkdir');
-		}
-
-		const handle = await this.getHandle(dirname(path));
-		if (!(handle instanceof FileSystemDirectoryHandle)) {
-			throw ErrnoError.With('ENOTDIR', path, 'mkdir');
-		}
-		await handle.getDirectoryHandle(basename(path), { create: true });
-	}
-
-	public async readdir(path: string): Promise<string[]> {
-		const handle = await this.getHandle(path);
-		if (!(handle instanceof FileSystemDirectoryHandle)) {
-			throw ErrnoError.With('ENOTDIR', path, 'readdir');
-		}
-
-		return Array.from(handle.keys());
-	}
-
-	protected async getHandle(path: string): Promise<FileSystemHandle> {
-		if (this._handles.has(path)) {
-			return this._handles.get(path)!;
-		}
-
-		let walked = '/';
-
-		for (const part of path.split('/').slice(1)) {
-			const handle = this._handles.get(walked);
-			if (!(handle instanceof FileSystemDirectoryHandle)) {
-				throw ErrnoError.With('ENOTDIR', walked, 'getHandle');
-			}
-			walked = join(walked, part);
-
-			try {
-				const dirHandle = await handle.getDirectoryHandle(part);
-				this._handles.set(walked, dirHandle);
-			} catch (_ex) {
-				const ex = _ex as DOMException;
-				if (ex.name == 'TypeMismatchError') {
-					try {
-						const fileHandle = await handle.getFileHandle(part);
-						this._handles.set(walked, fileHandle);
-					} catch (ex) {
-						convertException(ex as ConvertException, walked, 'getHandle');
-					}
-				}
-
-				if (ex.name === 'TypeError') {
-					throw new ErrnoError(Errno.ENOENT, ex.message, walked, 'getHandle');
-				}
-
-				convertException(ex, walked, 'getHandle');
-			}
-		}
-
-		return this._handles.get(path)!;
-	}
-}
-
-const _WebAccess = {
-	name: 'WebAccess',
-
-	options: {
-		handle: {
-			type: 'object',
-			required: true,
-			description: 'The directory handle to use for the root',
-		},
-	},
-
-	isAvailable(): boolean {
-		return typeof FileSystemHandle == 'function';
-	},
-
-	create(options: WebAccessOptions) {
-		return new WebAccessFS(options.handle);
-	},
-} as const satisfies Backend<WebAccessFS, WebAccessOptions>;
-type _WebAccess = typeof _WebAccess;
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface WebAccess extends _WebAccess {}
-export const WebAccess: WebAccess = _WebAccess;

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './access.js';
-export * from './IndexedDB.js';
-export * from './Storage.js';

package/src/utils.ts

@@ -1,74 +0,0 @@
-import { ErrnoError, Errno } from '@zenfs/core';
-
-/**
- * Converts a DOMException into an Errno
- * @see https://developer.mozilla.org/Web/API/DOMException
- */
-function errnoForDOMException(ex: DOMException): keyof typeof Errno {
-	switch (ex.name) {
-		case 'IndexSizeError':
-		case 'HierarchyRequestError':
-		case 'InvalidCharacterError':
-		case 'InvalidStateError':
-		case 'SyntaxError':
-		case 'NamespaceError':
-		case 'TypeMismatchError':
-		case 'ConstraintError':
-		case 'VersionError':
-		case 'URLMismatchError':
-		case 'InvalidNodeTypeError':
-			return 'EINVAL';
-		case 'WrongDocumentError':
-			return 'EXDEV';
-		case 'NoModificationAllowedError':
-		case 'InvalidModificationError':
-		case 'InvalidAccessError':
-		case 'SecurityError':
-		case 'NotAllowedError':
-			return 'EACCES';
-		case 'NotFoundError':
-			return 'ENOENT';
-		case 'NotSupportedError':
-			return 'ENOTSUP';
-		case 'InUseAttributeError':
-			return 'EBUSY';
-		case 'NetworkError':
-			return 'ENETDOWN';
-		case 'AbortError':
-			return 'EINTR';
-		case 'QuotaExceededError':
-			return 'ENOSPC';
-		case 'TimeoutError':
-			return 'ETIMEDOUT';
-		case 'ReadOnlyError':
-			return 'EROFS';
-		case 'DataCloneError':
-		case 'EncodingError':
-		case 'NotReadableError':
-		case 'DataError':
-		case 'TransactionInactiveError':
-		case 'OperationError':
-		case 'UnknownError':
-		default:
-			return 'EIO';
-	}
-}
-
-/** @internal */
-export type ConvertException = ErrnoError | DOMException | Error;
-
-/**
- * Handles converting errors, then rethrowing them
- * @internal
- */
-export function convertException(ex: ConvertException, path?: string, syscall?: string): ErrnoError {
-	if (ex instanceof ErrnoError) {
-		return ex;
-	}
-
-	const code = ex instanceof DOMException ? Errno[errnoForDOMException(ex)] : Errno.EIO;
-	const error = new ErrnoError(code, ex.message, path, syscall);
-	error.stack = ex.stack!;
-	error.cause = ex.cause;
-	return error;
-}