@zenfs/dom 1.1.4 → 1.1.6

package/dist/IndexedDB.d.ts

@@ -52,7 +52,7 @@ declare const _IndexedDB: {
             readonly required: false;
         };
     };
-    readonly isAvailable: (idbFactory?: IDBFactory) => Promise<boolean>;
+    readonly isAvailable: ({ idbFactory }: IndexedDBOptions) => Promise<boolean>;
     readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<StoreFS<IndexedDBStore>>;
 };
 type _IndexedDB = typeof _IndexedDB;

package/dist/IndexedDB.js

@@ -89,11 +89,10 @@ const _IndexedDB = {
         storeName: { type: 'string', required: false },
         idbFactory: { type: 'object', required: false },
     },
-    async isAvailable(idbFactory = globalThis.indexedDB) {
+    async isAvailable({ idbFactory = globalThis.indexedDB }) {
         try {
-            if (!(idbFactory instanceof IDBFactory)) {
+            if (!(idbFactory instanceof IDBFactory))
                 return false;
-            }
             const req = idbFactory.open('__zenfs_test');
             await wrap(req);
             return true;
@@ -102,7 +101,7 @@ const _IndexedDB = {
             return false;
         }
         finally {
-            idbFactory.deleteDatabase('__zenfs_test');
+            idbFactory?.deleteDatabase('__zenfs_test');
         }
     },
     async create(options) {

package/dist/access.d.ts

@@ -1,18 +1,12 @@
-import type { CreationOptions, File, InodeLike, Stats } from '@zenfs/core';
-import { FileSystem, Index } from '@zenfs/core';
+import type { CreationOptions, FileSystem, InodeLike } from '@zenfs/core';
+import { IndexFS } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
     metadata?: string;
 }
 type HKindToType<T extends FileSystemHandleKind> = T extends 'directory' ? FileSystemDirectoryHandle : T extends 'file' ? FileSystemFileHandle : FileSystemHandle;
-declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof FileSystem, import("@zenfs/core").AsyncMixin>;
+declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof IndexFS, import("@zenfs/core").AsyncMixin>;
 export declare class WebAccessFS extends WebAccessFS_base {
-    /**
-     * Disables index optimizations,
-     * like using the index for `readdir`
-     */
-    private readonly disableIndexOptimizations;
-    protected index: Index;
     protected _handles: Map<string, FileSystemHandle>;
     /**
      * Loads all of the handles.
@@ -28,14 +22,9 @@ export declare class WebAccessFS extends WebAccessFS_base {
      * @hidden
      */
     _sync: FileSystem;
-    constructor(handle: FileSystemDirectoryHandle, 
-    /**
-     * Disables index optimizations,
-     * like using the index for `readdir`
-     */
-    disableIndexOptimizations?: boolean);
-    rename(oldPath: string, newPath: string): Promise<void>;
-    unlink(path: string): Promise<void>;
+    constructor(handle: FileSystemDirectoryHandle);
+    remove(path: string): Promise<void>;
+    protected removeSync(path: string): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
     /**
@@ -43,17 +32,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
      * @deprecated @internal @hidden
      */
     writeFile(path: string, data: Uint8Array): Promise<void>;
-    stat(path: string): Promise<Stats>;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    openFile(path: string, flag: string): Promise<File>;
-    /**
-     * @todo Implement
-     */
-    link(srcpath: string): Promise<void>;
-    sync(path: string, data?: Uint8Array, stats?: Readonly<Partial<InodeLike>>): Promise<void>;
-    rmdir(path: string): Promise<void>;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    readdir(path: string): Promise<string[]>;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
     protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string, syscall?: string): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
 }
 declare const _WebAccess: {

package/dist/access.js

@@ -1,6 +1,6 @@
-import { Async, constants, Errno, ErrnoError, FileSystem, Index, InMemory, Inode, LazyFile } from '@zenfs/core';
-import { S_IFDIR, S_IFREG } from '@zenfs/core/vfs/constants.js';
-import { basename, dirname, join } from '@zenfs/core/vfs/path.js';
+import { Async, constants, Errno, ErrnoError, IndexFS, InMemory, Inode, log } from '@zenfs/core';
+import { basename, dirname, join } from '@zenfs/core/path.js';
+import { S_IFDIR, S_IFMT } from '@zenfs/core/vfs/constants.js';
 import { _throw } from 'utilium';
 import { convertException } from './utils.js';
 function isResizable(buffer) {
@@ -16,7 +16,7 @@ function isResizable(buffer) {
 function isKind(handle, kind) {
     return handle.kind == kind;
 }
-export class WebAccessFS extends Async(FileSystem) {
+export class WebAccessFS extends Async(IndexFS) {
     /**
      * Loads all of the handles.
      * @internal @hidden
@@ -53,59 +53,22 @@ export class WebAccessFS extends Async(FileSystem) {
             this.index.set(path, new Inode({ mode: 0o777 | constants.S_IFDIR, size: 0 }));
         }
     }
-    constructor(handle, 
-    /**
-     * Disables index optimizations,
-     * like using the index for `readdir`
-     */
-    disableIndexOptimizations = false) {
+    constructor(handle) {
         super(0x77656261, 'webaccessfs');
-        this.disableIndexOptimizations = disableIndexOptimizations;
-        this.index = new Index();
         this._handles = new Map();
         /**
          * @hidden
          */
-        this._sync = InMemory.create({ name: 'accessfs-cache' });
+        this._sync = InMemory.create({ label: 'accessfs-cache' });
         this.attributes.set('no_buffer_resize');
-        this.attributes.set('setid');
         this._handles.set('/', handle);
     }
-    async rename(oldPath, newPath) {
-        if (oldPath == newPath)
-            return;
-        if (newPath.startsWith(oldPath + '/'))
-            throw ErrnoError.With('EBUSY', oldPath, 'rename');
-        const handle = this.get(null, oldPath, 'rename');
-        if (isKind(handle, 'directory')) {
-            const files = await this.readdir(oldPath);
-            const stats = await this.stat(oldPath);
-            await this.mkdir(newPath, stats.mode, stats);
-            for (const file of files)
-                await this.rename(join(oldPath, file), join(newPath, file));
-            await this.rmdir(oldPath);
-            return;
-        }
-        if (!isKind(handle, 'file')) {
-            throw new ErrnoError(Errno.ENOTSUP, 'Not a file or directory handle', oldPath, 'rename');
-        }
-        const oldFile = await handle.getFile().catch(ex => _throw(convertException(ex, oldPath, 'rename')));
-        const destFolder = this.get('directory', dirname(newPath), 'rename');
-        const newFile = await destFolder
-            .getFileHandle(basename(newPath), { create: true })
-            .catch((ex) => _throw(ex.name == 'TypeMismatchError' ? ErrnoError.With('EISDIR', newPath, 'rename') : convertException(ex, newPath, 'rename')));
-        const writable = await newFile.createWritable();
-        await writable.write(await oldFile.arrayBuffer());
-        await writable.close();
-        await this.unlink(oldPath);
-        this._handles.set(newPath, newFile);
+    async remove(path) {
+        const handle = this.get('directory', dirname(path));
+        await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path)));
     }
-    async unlink(path) {
-        if (path == '/')
-            throw ErrnoError.With('EBUSY', '/', 'unlink');
-        const handle = this.get('directory', dirname(path), 'unlink');
-        await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path, 'unlink')));
-        this.index.delete(path);
+    removeSync(path) {
+        throw log.crit(ErrnoError.With('ENOSYS', path));
     }
     async read(path, buffer, offset, end) {
         if (end <= offset)
@@ -126,7 +89,22 @@ export class WebAccessFS extends Async(FileSystem) {
         const inode = this.index.get(path);
         if (!inode)
             throw ErrnoError.With('ENOENT', path, 'write');
-        const handle = this.get('file', path, 'write');
+        const isDir = (inode.mode & S_IFMT) == S_IFDIR;
+        let handle;
+        try {
+            handle = this.get(isDir ? 'directory' : 'file', path, 'write');
+        }
+        catch {
+            const parent = this.get('directory', dirname(path), 'write');
+            handle = await parent[isDir ? 'getDirectoryHandle' : 'getFileHandle'](basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
+            this._handles.set(path, handle);
+        }
+        if (isDir)
+            return;
+        if (isKind(handle, 'directory')) {
+            log.crit(new ErrnoError(Errno.EIO, 'Mismatch in entry kind on write', path, 'write'));
+            return;
+        }
         const writable = await handle.createWritable();
         try {
             await writable.seek(offset);
@@ -147,85 +125,12 @@ export class WebAccessFS extends Async(FileSystem) {
     async writeFile(path, data) {
         return this.write(path, data, 0);
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async stat(path) {
-        const inode = this.index.get(path);
-        if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        return inode.toStats();
-    }
-    async createFile(path, flag, mode, options) {
-        const handle = this.get('directory', dirname(path), 'createFile');
-        if (this.index.has(path))
-            throw ErrnoError.With('EEXIST', path, 'createFile');
-        const file = await handle.getFileHandle(basename(path), { create: true });
-        // Race condition bypass
-        const inode = this.index.get(path) ?? new Inode({ ...options, mode: mode | S_IFREG });
-        this.index.set(path, inode);
-        this._handles.set(path, file);
-        return new LazyFile(this, path, flag, inode);
-    }
-    async openFile(path, flag) {
-        const inode = this.index.get(path);
-        if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        return new LazyFile(this, path, flag, inode.toStats());
-    }
-    /**
-     * @todo Implement
-     */
-    async link(srcpath) {
-        return;
-    }
-    async sync(path, data, stats) {
-        const inode = this.index.get(path) ?? new Inode();
-        inode.update(stats);
-        this.index.set(path, inode);
-        if (!data)
-            return;
-        const handle = this.get('file', path, 'write');
-        const writable = await handle.createWritable();
-        try {
-            await writable.seek(0);
-        }
-        catch {
-            await writable.write({ type: 'seek', position: 0 });
-        }
-        await writable.write(data);
-        await writable.close();
-    }
-    async rmdir(path) {
-        if ((await this.readdir(path)).length)
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        if (path == '/')
-            throw ErrnoError.With('EBUSY', '/', 'rmdir');
-        const handle = this.get('directory', dirname(path), 'rmdir');
-        await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path, 'rmdir')));
-        this.index.delete(path);
-    }
-    async mkdir(path, mode, options) {
-        if (this.index.has(path))
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
+    async mkdir(path, options) {
+        const inode = await super.mkdir(path, options);
         const handle = this.get('directory', dirname(path), 'mkdir');
-        const dir = await handle.getDirectoryHandle(basename(path), { create: true });
+        const dir = await handle.getDirectoryHandle(basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
         this._handles.set(path, dir);
-        this.index.set(path, new Inode({ ...options, mode: mode | S_IFDIR }));
-    }
-    async readdir(path) {
-        if (!this.disableIndexOptimizations) {
-            if (!this.index.has(path))
-                throw ErrnoError.With('ENOENT', path, 'readdir');
-            const entries = this.index.directoryEntries(path);
-            if (!entries)
-                throw ErrnoError.With('ENOTDIR', path, 'readdir');
-            return Object.keys(entries);
-        }
-        const handle = this.get('directory', path, 'readdir');
-        const entries = [];
-        for await (const k of handle.keys()) {
-            entries.push(k);
-        }
-        return entries;
+        return inode;
     }
     get(kind = null, path, syscall) {
         const handle = this._handles.get(path);

package/dist/devices/dsp.js

@@ -44,10 +44,10 @@ export async function dsp(options = {}) {
         init(ino, options) {
             return { data: dsp, major: 14, minor: 3 };
         },
-        readD() {
+        read() {
             return;
         },
-        writeD(device, buffer, offset) {
+        write(device, buffer, offset) {
             device.data.port.postMessage(buffer.buffer);
         },
     };

package/dist/devices/framebuffer.js

@@ -27,8 +27,8 @@ export const framebuffer = {
             name: 'fb',
         };
     },
-    readD() { },
-    writeD({ data: { image, context } }, buffer, offset) {
+    read() { },
+    write({ data: { image, context } }, buffer, offset) {
         image.data.set(buffer, offset);
         context.putImageData(image, 0, 0);
         return buffer.byteLength;

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import type { SyncMapStore, Store } from '@zenfs/core';
+import type { Store, SyncMapStore } from '@zenfs/core';
 import { StoreFS, SyncMapTransaction } from '@zenfs/core';
 /**
  * A synchronous key-value store backed by Storage.
@@ -39,7 +39,7 @@ declare const _WebStorage: {
     /**
      * @todo Consider replacing `instanceof` with a duck-typing check?
      */
-    readonly isAvailable: (storage?: Storage) => boolean;
+    readonly isAvailable: (config?: WebStorageOptions) => boolean;
     readonly create: ({ storage }: WebStorageOptions) => StoreFS<WebStorageStore>;
 };
 type _WebStorage = typeof _WebStorage;

package/dist/storage.js

@@ -1,4 +1,5 @@
-import { ErrnoError, Errno, StoreFS, decodeRaw, encodeRaw, SyncMapTransaction } from '@zenfs/core';
+import { Errno, ErrnoError, StoreFS, SyncMapTransaction } from '@zenfs/core';
+import { decodeASCII, encodeASCII } from 'utilium';
 /**
  * A synchronous key-value store backed by Storage.
  */
@@ -28,11 +29,11 @@ export class WebStorageStore {
         if (typeof data != 'string') {
             return;
         }
-        return encodeRaw(data);
+        return encodeASCII(data);
     }
     set(key, data) {
         try {
-            this.storage.setItem(key.toString(), decodeRaw(data));
+            this.storage.setItem(key.toString(), decodeASCII(data));
         }
         catch {
             throw new ErrnoError(Errno.ENOSPC, 'Storage is full.');
@@ -58,8 +59,8 @@ const _WebStorage = {
     /**
      * @todo Consider replacing `instanceof` with a duck-typing check?
      */
-    isAvailable(storage = globalThis.localStorage) {
-        return storage instanceof globalThis.Storage;
+    isAvailable(config) {
+        return (config?.storage ?? globalThis.localStorage) instanceof globalThis.Storage;
     },
     create({ storage = globalThis.localStorage }) {
         return new StoreFS(new WebStorageStore(storage));

package/dist/utils.js

@@ -5,13 +5,14 @@ import { ErrnoError, Errno } from '@zenfs/core';
  */
 function errnoForDOMException(ex) {
     switch (ex.name) {
+        case 'TypeMismatchError':
+            return 'EPERM';
         case 'IndexSizeError':
         case 'HierarchyRequestError':
         case 'InvalidCharacterError':
         case 'InvalidStateError':
         case 'SyntaxError':
         case 'NamespaceError':
-        case 'TypeMismatchError':
         case 'ConstraintError':
         case 'VersionError':
         case 'URLMismatchError':

package/dist/xml.d.ts

@@ -1,5 +1,5 @@
-import type { CreationOptions, File, InodeLike, StatsLike } from '@zenfs/core';
-import { FileSystem, Stats } from '@zenfs/core';
+import type { CreationOptions, InodeLike, StatsLike } from '@zenfs/core';
+import { FileSystem, Inode } from '@zenfs/core';
 export interface XMLOptions {
     /**
      * The root `fs` element
@@ -18,15 +18,15 @@ export declare class XMLFS extends XMLFS_base {
      */
     root?: Element);
     renameSync(oldPath: string, newPath: string): void;
-    statSync(path: string): Stats;
-    openFileSync(path: string, flag: string): File;
-    createFileSync(path: string, flag: string, mode: number, { uid, gid }: CreationOptions): File;
+    statSync(path: string): Inode;
+    createFileSync(path: string, options: CreationOptions): Inode;
     unlinkSync(path: string): void;
     rmdirSync(path: string): void;
-    mkdirSync(path: string, mode: number, { uid, gid }: CreationOptions): void;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     readdirSync(path: string): string[];
     linkSync(target: string, link: string): void;
-    syncSync(path: string, data?: Uint8Array, stats?: Readonly<Partial<InodeLike>>): void;
+    touchSync(path: string, metadata: Partial<InodeLike>): void;
+    syncSync(): void;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     toString(): string;
@@ -39,7 +39,7 @@ declare const _XML: {
     name: string;
     options: {
         root: {
-            type: "object";
+            type: string;
             required: false;
         };
     };

package/dist/xml.js

@@ -1,5 +1,6 @@
-import { _inode_fields, constants, decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, LazyFile, Stats, Sync } from '@zenfs/core';
-import { basename, dirname } from '@zenfs/core/vfs/path.js';
+import { _inode_fields, constants, Errno, ErrnoError, FileSystem, Inode, Sync } from '@zenfs/core';
+import { basename, dirname } from '@zenfs/core/path.js';
+import { decodeASCII, encodeASCII } from 'utilium';
 function get_stats(node) {
     const stats = {};
     for (const key of _inode_fields) {
@@ -7,7 +8,7 @@ function get_stats(node) {
         if (value !== null && value !== undefined)
             stats[key] = parseInt(value, 16);
     }
-    return new Stats(stats);
+    return new Inode(stats);
 }
 function set_stats(node, stats) {
     for (const key of Object.keys(stats)) {
@@ -35,9 +36,8 @@ export class XMLFS extends Sync(FileSystem) {
     root = new DOMParser().parseFromString('<fs></fs>', 'application/xml').documentElement) {
         super(0x20786d6c, 'xmltmpfs');
         this.root = root;
-        this.attributes.set('setid');
         try {
-            this.mkdirSync('/', 0o777, { uid: 0, gid: 0 });
+            this.mkdirSync('/', { uid: 0, gid: 0, mode: 0o777 });
         }
         catch (e) {
             const error = e;
@@ -53,23 +53,19 @@ export class XMLFS extends Sync(FileSystem) {
     statSync(path) {
         return get_stats(this.get('stat', path));
     }
-    openFileSync(path, flag) {
-        const node = this.get('openFile', path);
-        return new LazyFile(this, path, flag, get_stats(node));
-    }
-    createFileSync(path, flag, mode, { uid, gid }) {
+    createFileSync(path, options) {
         const parent = this.statSync(dirname(path));
-        const stats = new Stats({
-            mode: mode | constants.S_IFREG,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        const inode = new Inode({
+            mode: options.mode | constants.S_IFREG,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : options.uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : options.gid,
         });
-        this.create('createFile', path, stats);
-        return new LazyFile(this, path, flag, stats);
+        this.create('createFile', path, inode);
+        return inode;
     }
     unlinkSync(path) {
         const node = this.get('unlink', path);
-        if (get_stats(node).isDirectory())
+        if (get_stats(node).mode & constants.S_IFDIR)
             throw ErrnoError.With('EISDIR', path, 'unlink');
         this.remove('unlink', node, path);
     }
@@ -77,22 +73,23 @@ export class XMLFS extends Sync(FileSystem) {
         const node = this.get('rmdir', path);
         if (node.textContent?.length)
             throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        if (!get_stats(node).isDirectory())
+        if (!(get_stats(node).mode & constants.S_IFDIR))
             throw ErrnoError.With('ENOTDIR', path, 'rmdir');
         this.remove('rmdir', node, path);
     }
-    mkdirSync(path, mode, { uid, gid }) {
+    mkdirSync(path, options) {
         const parent = this.statSync(dirname(path));
-        const node = this.create('mkdir', path, {
-            mode: mode | constants.S_IFDIR,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        const inode = new Inode({
+            mode: options.mode | constants.S_IFDIR,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : options.uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : options.gid,
         });
-        node.textContent = '[]';
+        this.create('mkdir', path, inode).textContent = '[]';
+        return inode;
     }
     readdirSync(path) {
         const node = this.get('readdir', path);
-        if (!get_stats(node).isDirectory())
+        if (!(get_stats(node).mode & constants.S_IFDIR))
             throw ErrnoError.With('ENOTDIR', path, 'rmdir');
         try {
             return JSON.parse(node.textContent);
@@ -105,20 +102,19 @@ export class XMLFS extends Sync(FileSystem) {
         const node = this.get('link', target);
         this.add('link', node, link);
     }
-    syncSync(path, data, stats = {}) {
-        const node = this.get('sync', path);
-        if (data)
-            node.textContent = decodeRaw(data);
-        set_stats(node, stats);
+    touchSync(path, metadata) {
+        const node = this.get('touch', path);
+        set_stats(node, metadata);
     }
+    syncSync() { }
     readSync(path, buffer, offset, end) {
         const node = this.get('read', path);
-        const raw = encodeRaw(node.textContent.slice(offset, end));
+        const raw = encodeASCII(node.textContent.slice(offset, end));
         buffer.set(raw);
     }
     writeSync(path, buffer, offset) {
         const node = this.get('write', path);
-        const data = decodeRaw(buffer);
+        const data = decodeASCII(buffer);
         const after = node.textContent.slice(offset + data.length);
         node.textContent = node.textContent.slice(0, offset) + data + after;
     }
@@ -140,7 +136,7 @@ export class XMLFS extends Sync(FileSystem) {
             throw ErrnoError.With('EEXIST', path, syscall);
         const node = document.createElement('file');
         this.add(syscall, node, path);
-        set_stats(node, new Stats({
+        set_stats(node, new Inode({
             ...stats,
             uid: stats.mode,
         }));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.1.4",
+	"version": "1.1.6",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",
@@ -61,8 +61,8 @@
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.9.0",
-		"utilium": "^1.2.10"
+		"@zenfs/core": "^2.0.0",
+		"utilium": "^1.9.0"
 	},
 	"keywords": [
 		"filesystem",