@zenfs/dom 1.0.2 → 1.0.4

package/dist/IndexedDB.d.ts

@@ -1,5 +1,5 @@
-import type { Ino, SharedConfig, Store } from '@zenfs/core';
-import { AsyncTransaction, StoreFS } from '@zenfs/core';
+import type { SharedConfig, Store } from '@zenfs/core';
+import { Async, AsyncTransaction, StoreFS } from '@zenfs/core';
 /**
  * @hidden
  */
@@ -8,9 +8,10 @@ export declare class IndexedDBTransaction extends AsyncTransaction<IndexedDBStor
     store: IndexedDBStore;
     private _idb;
     constructor(tx: IDBTransaction, store: IndexedDBStore);
-    get(key: Ino): Promise<Uint8Array>;
-    set(key: Ino, data: Uint8Array): Promise<void>;
-    remove(key: Ino): Promise<void>;
+    keys(): Promise<Iterable<bigint>>;
+    get(key: bigint): Promise<Uint8Array>;
+    set(key: bigint, data: Uint8Array): Promise<void>;
+    remove(key: bigint): Promise<void>;
     commit(): Promise<void>;
     abort(): Promise<void>;
 }
@@ -45,30 +46,14 @@ declare const _IndexedDB: {
         readonly storeName: {
             readonly type: "string";
             readonly required: false;
-            readonly description: "The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.";
         };
         readonly idbFactory: {
             readonly type: "object";
             readonly required: false;
-            readonly description: "The IDBFactory to use. Defaults to globalThis.indexedDB.";
         };
     };
     readonly isAvailable: (idbFactory?: IDBFactory) => Promise<boolean>;
-    readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<{
-        _sync?: import("@zenfs/core").FileSystem;
-        queueDone(): Promise<void>;
-        ready(): Promise<void>;
-        renameSync(oldPath: string, newPath: string): void;
-        statSync(path: string): import("@zenfs/core").Stats;
-        createFileSync(path: string, flag: string, mode: number): import("@zenfs/core").File;
-        openFileSync(path: string, flag: string): import("@zenfs/core").File;
-        unlinkSync(path: string): void;
-        rmdirSync(path: string): void;
-        mkdirSync(path: string, mode: number): void;
-        readdirSync(path: string): string[];
-        linkSync(srcpath: string, dstpath: string): void;
-        syncSync(path: string, data: Uint8Array, stats: Readonly<import("@zenfs/core").Stats>): void;
-    } & StoreFS<IndexedDBStore>>;
+    readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<Async & StoreFS<IndexedDBStore>>;
 };
 type _IndexedDB = typeof _IndexedDB;
 interface IndexedDB extends _IndexedDB {

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()));
     }
@@ -94,12 +97,10 @@ const _IndexedDB = {
         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 = globalThis.indexedDB) {
@@ -109,13 +110,14 @@ const _IndexedDB = {
             }
             const req = idbFactory.open('__zenfs_test');
             await wrap(req);
-            idbFactory.deleteDatabase('__zenfs_test');
             return true;
         }
-        catch (e) {
-            idbFactory.deleteDatabase('__zenfs_test');
+        catch {
             return false;
         }
+        finally {
+            idbFactory.deleteDatabase('__zenfs_test');
+        }
     },
     async create(options) {
         const db = await createDB(options.storeName || 'zenfs', options.idbFactory);

package/dist/Storage.d.ts

@@ -1,4 +1,4 @@
-import type { Ino, SimpleSyncStore, Store } from '@zenfs/core';
+import type { SimpleSyncStore, Store } from '@zenfs/core';
 import { SimpleTransaction, StoreFS } from '@zenfs/core';
 /**
  * A synchronous key-value store backed by Storage.
@@ -11,9 +11,10 @@ export declare class WebStorageStore implements Store, SimpleSyncStore {
     clearSync(): void;
     sync(): Promise<void>;
     transaction(): SimpleTransaction;
-    get(key: Ino): Uint8Array | undefined;
-    set(key: Ino, data: Uint8Array): void;
-    delete(key: Ino): void;
+    keys(): Iterable<bigint>;
+    get(key: bigint): Uint8Array | undefined;
+    set(key: bigint, data: Uint8Array): void;
+    delete(key: bigint): void;
 }
 /**
  * Options to pass to the StorageFileSystem

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') {
@@ -31,7 +34,7 @@ export class WebStorageStore {
         try {
             this.storage.setItem(key.toString(), decodeRaw(data));
         }
-        catch (e) {
+        catch {
             throw new ErrnoError(Errno.ENOSPC, 'Storage is full.');
         }
     }

package/dist/access.d.ts

@@ -1,23 +1,9 @@
 import type { FileSystemMetadata } from '@zenfs/core';
-import { FileSystem, PreloadFile, Stats } from '@zenfs/core';
+import { Async, FileSystem, PreloadFile, Stats } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
 }
-declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof FileSystem, {
-    _sync?: FileSystem;
-    queueDone(): Promise<void>;
-    ready(): Promise<void>;
-    renameSync(oldPath: string, newPath: string): void;
-    statSync(path: string): Stats;
-    createFileSync(path: string, flag: string, mode: number): import("@zenfs/core").File;
-    openFileSync(path: string, flag: string): import("@zenfs/core").File;
-    unlinkSync(path: string): void;
-    rmdirSync(path: string): void;
-    mkdirSync(path: string, mode: number): void;
-    readdirSync(path: string): string[];
-    linkSync(srcpath: string, dstpath: string): void;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof FileSystem, Async>;
 export declare class WebAccessFS extends WebAccessFS_base {
     private _handles;
     /**
@@ -26,7 +12,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
     _sync: FileSystem;
     constructor(handle: FileSystemDirectoryHandle);
     metadata(): FileSystemMetadata;
-    sync(path: string, data: Uint8Array, stats: Stats): Promise<void>;
+    sync(path: string, data: Uint8Array): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
     writeFile(path: string, data: Uint8Array): Promise<void>;
     createFile(path: string, flag: string): Promise<PreloadFile<this>>;
@@ -37,7 +23,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
     rmdir(path: string): Promise<void>;
     mkdir(path: string): Promise<void>;
     readdir(path: string): Promise<string[]>;
-    protected getHandle(path: string): Promise<FileSystemHandle>;
+    protected getHandle(path: string): Promise<FileSystemHandle | undefined>;
 }
 declare const _WebAccess: {
     readonly name: "WebAccess";

package/dist/access.js

@@ -19,44 +19,40 @@ export class WebAccessFS extends Async(FileSystem) {
             noResizableBuffers: true,
         };
     }
-    async sync(path, data, stats) {
-        const currentStats = await this.stat(path);
-        if (stats.mtime !== currentStats.mtime) {
-            await this.writeFile(path, data);
-        }
+    async sync(path, data) {
+        await this.writeFile(path, data);
     }
     async rename(oldPath, newPath) {
-        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)) {
+        const handle = await this.getHandle(oldPath);
+        if (handle instanceof FileSystemDirectoryHandle) {
+            const files = await this.readdir(oldPath);
+            await this.mkdir(newPath);
+            if (!files.length) {
+                await this.unlink(oldPath);
                 return;
             }
-            const oldFile = await handle.getFile(), destFolder = await this.getHandle(dirname(newPath));
-            if (!(destFolder instanceof FileSystemDirectoryHandle)) {
-                return;
+            for (const file of files) {
+                await this.rename(join(oldPath, file), join(newPath, file));
+                await this.unlink(oldPath);
             }
-            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);
+            return;
+        }
+        if (!(handle instanceof FileSystemFileHandle)) {
+            throw new ErrnoError(Errno.ENOTSUP, 'Not a file or directory handle', oldPath, 'rename');
         }
-        catch (ex) {
+        const oldFile = await handle.getFile().catch((ex) => {
             throw convertException(ex, oldPath, 'rename');
+        }), destFolder = await this.getHandle(dirname(newPath));
+        if (!(destFolder instanceof FileSystemDirectoryHandle)) {
+            return;
         }
+        const newFile = await destFolder.getFileHandle(basename(newPath), { create: true }).catch((ex) => {
+            throw convertException(ex, newPath, 'rename');
+        });
+        const writable = await newFile.createWritable();
+        await writable.write(await oldFile.arrayBuffer());
+        await writable.close();
+        await this.unlink(oldPath);
     }
     async writeFile(path, data) {
         if (data.buffer.resizable) {
@@ -94,35 +90,35 @@ export class WebAccessFS extends Async(FileSystem) {
         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) {
+        const file = await handle.getFile().catch((ex) => {
             throw convertException(ex, path, 'openFile');
-        }
+        });
+        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);
     }
     async unlink(path) {
         const handle = await this.getHandle(dirname(path));
-        if (handle instanceof FileSystemDirectoryHandle) {
-            try {
-                await handle.removeEntry(basename(path), { recursive: true });
-            }
-            catch (ex) {
-                throw convertException(ex, path, 'unlink');
-            }
+        if (!(handle instanceof FileSystemDirectoryHandle)) {
+            throw ErrnoError.With('ENOTDIR', dirname(path), 'unlink');
         }
+        await handle.removeEntry(basename(path), { recursive: true }).catch((ex) => {
+            throw convertException(ex, path, 'unlink');
+        });
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async link(srcpath) {
-        throw ErrnoError.With('ENOSYS', srcpath, 'WebAccessFS.link');
+        return;
     }
     async rmdir(path) {
         return this.unlink(path);
     }
     async mkdir(path) {
-        const existingHandle = await this.getHandle(path);
+        const existingHandle = await this.getHandle(path).catch((ex) => {
+            if (ex.code != 'ENOENT') {
+                throw ex;
+            }
+        });
         if (existingHandle) {
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         }
@@ -154,26 +150,20 @@ export class WebAccessFS extends Async(FileSystem) {
                 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;
-                if (ex.name == 'TypeMismatchError') {
-                    try {
-                        const fileHandle = await handle.getFileHandle(part);
-                        this._handles.set(walked, fileHandle);
-                    }
-                    catch (ex) {
-                        convertException(ex, walked, 'getHandle');
-                    }
+            const child = await handle.getDirectoryHandle(part).catch((ex) => {
+                switch (ex.name) {
+                    case 'TypeMismatchError':
+                        return handle.getFileHandle(part).catch((ex) => {
+                            //throw convertException(ex, walked, 'getHandle');
+                        });
+                    case 'TypeError':
+                        throw new ErrnoError(Errno.ENOENT, ex.message, walked, 'getHandle');
+                    default:
+                        throw convertException(ex, walked, 'getHandle');
                 }
-                if (ex.name === 'TypeError') {
-                    throw new ErrnoError(Errno.ENOENT, ex.message, walked, 'getHandle');
-                }
-                convertException(ex, walked, 'getHandle');
-            }
+            });
+            if (child)
+                this._handles.set(walked, child);
         }
         return this._handles.get(path);
     }

package/dist/devices/dsp.d.ts

@@ -0,0 +1,6 @@
+import type { DeviceDriver } from '@zenfs/core';
+import './audioworklet.d.ts';
+export interface DspOptions {
+    audioContext?: AudioContext;
+}
+export declare function dsp(options?: DspOptions): Promise<DeviceDriver<AudioWorkletNode>>;

package/dist/devices/dsp.js

@@ -0,0 +1,55 @@
+import './audioworklet.d.ts';
+if ('AudioWorkletProcessor' in globalThis) {
+    class Dsp extends AudioWorkletProcessor {
+        constructor() {
+            super();
+            this.port.onmessage = ({ data }) => {
+                this.buffer = new Float32Array(data);
+            };
+        }
+        process(inputs, outputs) {
+            if (this.buffer && this.buffer.byteLength >= 128) {
+                outputs[0][0].set(this.buffer.slice(0, 128));
+                this.buffer = this.buffer.slice(128);
+            }
+            return true;
+        }
+        static get parameterDescriptors() {
+            return [
+                {
+                    name: 'gain',
+                    defaultValue: 1,
+                    minValue: 0,
+                    maxValue: 1,
+                    automationRate: 'a-rate',
+                },
+            ];
+        }
+    }
+    registerProcessor('zenfs:dsp', Dsp);
+}
+export async function dsp(options = {}) {
+    const context = options.audioContext || new AudioContext();
+    await context.audioWorklet.addModule(import.meta.url);
+    const dsp = new AudioWorkletNode(context, 'zenfs:dsp');
+    dsp.connect(context.destination);
+    // add a click-handler to resume (due to web security) https://goo.gl/7K7WLu
+    document.addEventListener('click', () => {
+        if (context.state != 'running') {
+            void context.resume().catch(() => { });
+        }
+    });
+    return {
+        name: 'dsp',
+        init() {
+            return { data: dsp, major: 14, minor: 3 };
+        },
+        read() {
+            return 0;
+        },
+        write(file, data) {
+            dsp.port.postMessage(data.buffer);
+            return data.byteLength;
+        },
+    };
+}

package/dist/devices/framebuffer.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceDriver } from '@zenfs/core';
+export interface FramebufferOptions {
+    canvas?: HTMLCanvasElement | null;
+}
+export declare function framebuffer({ canvas }?: FramebufferOptions): DeviceDriver<CanvasRenderingContext2D>;

package/dist/devices/framebuffer.js

@@ -0,0 +1,30 @@
+/* Credit: David Konsumer */
+import { Errno, ErrnoError } from '@zenfs/core';
+let framebufferN = 0;
+export function framebuffer({ canvas } = {}) {
+    if (!canvas) {
+        canvas = document.createElement('canvas');
+        document.body.appendChild(canvas);
+    }
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new ErrnoError(Errno.EIO, 'Could not get context from canvas whilst initializing frame buffer.');
+    }
+    return {
+        name: 'framebuffer',
+        init() {
+            return { data: ctx, major: 29, minor: framebufferN++ };
+        },
+        read() {
+            return 0;
+        },
+        write(file, data) {
+            if (data.byteLength < 4 * canvas.width * canvas.height) {
+                return 0;
+            }
+            const imageData = new ImageData(new Uint8ClampedArray(data), canvas.width, canvas.height);
+            ctx.putImageData(imageData, 0, 0);
+            return data.byteLength;
+        },
+    };
+}

package/dist/devices/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dsp.js';
+export * from './framebuffer.js';

package/dist/devices/index.js

@@ -0,0 +1,2 @@
+export * from './dsp.js';
+export * from './framebuffer.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.0.2",
+	"version": "1.0.4",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",
@@ -11,6 +11,9 @@
 	"type": "module",
 	"homepage": "https://github.com/zen-fs/dom",
 	"author": "James Prevett <jp@jamespre.dev> (https://jamespre.dev)",
+	"contributors": [
+		"David Konsumer <konsumer@jetboystudio.com>"
+	],
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -29,7 +32,8 @@
 	},
 	"exports": {
 		".": "./dist/index.js",
-		"./*": "./dist/*"
+		"./*": "./dist/*",
+		"./devices": "./dist/devices.js"
 	},
 	"scripts": {
 		"format": "prettier --write .",
@@ -51,7 +55,7 @@
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.2.0"
+		"@zenfs/core": "^1.3.0"
 	},
 	"optionalDependencies": {
 		"fake-indexeddb": "^6.0.0",