@zenfs/dom 1.1.4 → 1.1.5

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 } 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[]>;
     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,5 +1,5 @@
-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 { Async, constants, Errno, ErrnoError, IndexFS, InMemory, Inode, log } from '@zenfs/core';
+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';
@@ -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,15 +53,8 @@ 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
@@ -71,41 +64,12 @@ export class WebAccessFS extends Async(FileSystem) {
         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 +90,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 +126,11 @@ 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');
+        await super.mkdir(path, mode, 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;
     }
     get(kind = null, path, syscall) {
         const handle = this._handles.get(path);

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/package.json

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