@zenfs/dom 1.1.5 → 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,4 +1,4 @@
-import type { CreationOptions, FileSystem } from '@zenfs/core';
+import type { CreationOptions, FileSystem, InodeLike } from '@zenfs/core';
 import { IndexFS } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
@@ -32,7 +32,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
      * @deprecated @internal @hidden
      */
     writeFile(path: string, data: Uint8Array): Promise<void>;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
+    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, 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 { basename, dirname, join } from '@zenfs/core/vfs/path.js';
 import { _throw } from 'utilium';
 import { convertException } from './utils.js';
 function isResizable(buffer) {
@@ -59,9 +59,8 @@ export class WebAccessFS extends Async(IndexFS) {
         /**
          * @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 remove(path) {
@@ -126,11 +125,12 @@ export class WebAccessFS extends Async(IndexFS) {
     async writeFile(path, data) {
         return this.write(path, data, 0);
     }
-    async mkdir(path, mode, options) {
-        await super.mkdir(path, mode, options);
+    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 }).catch((ex) => _throw(convertException(ex, path)));
         this._handles.set(path, dir);
+        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/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.5",
+	"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.1",
-		"utilium": "^1.2.10"
+		"@zenfs/core": "^2.0.0",
+		"utilium": "^1.9.0"
 	},
 	"keywords": [
 		"filesystem",