@zenfs/dom 1.2.0 → 1.2.2

package/dist/access.d.ts

@@ -1,5 +1,5 @@
 import type { CreationOptions, FileSystem, InodeLike } from '@zenfs/core';
-import { IndexFS } from '@zenfs/core';
+import { IndexFS, Inode } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
     metadata?: string;
@@ -9,7 +9,7 @@ export interface WebAccessOptions {
      */
     disableHandleCache?: boolean;
 }
-type HKindToType<T extends FileSystemHandleKind> = T extends 'directory' ? FileSystemDirectoryHandle : T extends 'file' ? FileSystemFileHandle : FileSystemHandle;
+type HKindToType<T extends FileSystemHandleKind | null> = T extends 'directory' ? FileSystemDirectoryHandle : T extends 'file' ? FileSystemFileHandle : FileSystemHandle;
 declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof IndexFS, import("@zenfs/core").AsyncMixin>;
 /**
  * @todo Consider supporting synchronous stuff with `FileSystemFileHandle.createSyncAccessHandle()`\
@@ -39,6 +39,8 @@ export declare class WebAccessFS extends WebAccessFS_base {
      */
     _sync: FileSystem;
     constructor(root: FileSystemDirectoryHandle, disableHandleCache?: boolean);
+    stat(path: string): Promise<Inode>;
+    readdir(path: string): Promise<string[]>;
     protected remove(path: string): Promise<void>;
     protected removeSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
@@ -49,7 +51,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
      */
     writeFile(path: string, data: Uint8Array): Promise<void>;
     mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string): Promise<T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle>;
+    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string): Promise<HKindToType<T>>;
 }
 declare const _WebAccess: {
     readonly name: "WebAccess";

package/dist/access.js

@@ -1,6 +1,5 @@
 import { Async, constants, IndexFS, InMemory, Inode } from '@zenfs/core';
 import { basename, dirname, join } from '@zenfs/core/path.js';
-import { S_IFDIR, S_IFMT } from '@zenfs/core/vfs/constants.js';
 import { log, withErrno } from 'kerium';
 import { alert } from 'kerium/log';
 import { _throw } from 'utilium';
@@ -79,6 +78,39 @@ export class WebAccessFS extends Async(IndexFS) {
         if (disableHandleCache)
             this.attributes.set('no_handle_cache', true);
     }
+    async stat(path) {
+        try {
+            return await super.stat(path);
+        }
+        catch (ex) {
+            if (ex.code != 'ENOENT')
+                throw ex;
+            // This handle must have been created after initialization
+            // Try to add a new inode for the handle to the index
+            const handle = await this.get(null, path);
+            const inode = new Inode();
+            if (isKind(handle, 'file')) {
+                const file = await handle.getFile();
+                inode.update({
+                    mode: 0o644 | constants.S_IFREG,
+                    size: file.size,
+                    mtimeMs: file.lastModified,
+                });
+            }
+            else {
+                inode.update({
+                    mode: constants.S_IFDIR | 0o777,
+                    size: 0,
+                });
+            }
+            this.index.set(path, inode);
+            return inode;
+        }
+    }
+    async readdir(path) {
+        const dirHandle = await this.get('directory', path);
+        return await Array.fromAsync(dirHandle.keys());
+    }
     async remove(path) {
         const handle = await this.get('directory', dirname(path));
         await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path)));
@@ -93,7 +125,11 @@ export class WebAccessFS extends Async(IndexFS) {
         const file = await handle.getFile();
         const data = await file.arrayBuffer();
         if (data.byteLength < end - offset)
-            throw alert(withErrno('EIO', `Unexpected mismatch in file data size. This should not happen.\n\t\tTried to read ${end - offset} bytes but the file is ${data.byteLength} bytes.`));
+            throw alert(withErrno('EIO', [
+                'Unexpected mismatch in file data size. This should not happen.',
+                `tried to read ${end - offset} bytes but the file is ${data.byteLength} bytes.`,
+                `path: ${path}`,
+            ].join('\n' + ' '.repeat(24))));
         buffer.set(new Uint8Array(data, offset, end - offset));
     }
     async write(path, buffer, offset) {
@@ -105,7 +141,7 @@ export class WebAccessFS extends Async(IndexFS) {
         const inode = this.index.get(path);
         if (!inode)
             throw withErrno('ENOENT');
-        const isDir = (inode.mode & S_IFMT) == S_IFDIR;
+        const isDir = (inode.mode & constants.S_IFMT) == constants.S_IFDIR;
         let handle;
         try {
             handle = await this.get(isDir ? 'directory' : 'file', path);
@@ -151,13 +187,12 @@ export class WebAccessFS extends Async(IndexFS) {
         return inode;
     }
     async get(kind = null, path) {
-        if (!this.disableHandleCache) {
-            const handle = this._handles.get(path);
-            if (!handle)
-                throw withErrno('ENOENT');
-            if (kind && !isKind(handle, kind))
+        const maybeHandle = this._handles.get(path);
+        if (!this.disableHandleCache && maybeHandle) {
+            if (kind && !isKind(maybeHandle, kind))
                 throw withErrno(kind == 'directory' ? 'ENOTDIR' : 'EISDIR');
-            return handle;
+            return maybeHandle;
+            // Otherwise, fall through to the slow path
         }
         if (path == '/')
             return this.root;
@@ -168,13 +203,21 @@ export class WebAccessFS extends Async(IndexFS) {
         }
         try {
             const handle = await dir[kind == 'file' ? 'getFileHandle' : 'getDirectoryHandle'](parts.at(-1));
+            if (!this.disableHandleCache)
+                this._handles.set(path, handle);
             return handle;
         }
         catch (ex) {
-            if (ex.name == 'TypeMismatchError')
-                throw withErrno(kind == 'file' ? 'EISDIR' : 'ENOTDIR');
-            else
+            if (ex.name != 'TypeMismatchError')
                 throw convertException(ex, path);
+            else if (kind === null) {
+                const handle = await dir.getFileHandle(parts.at(-1)).catch(ex => _throw(convertException(ex, path)));
+                if (!this.disableHandleCache)
+                    this._handles.set(path, handle);
+                return handle;
+            }
+            else
+                throw withErrno(kind == 'file' ? 'EISDIR' : 'ENOTDIR');
         }
     }
 }
@@ -186,7 +229,7 @@ const _WebAccess = {
         disableHandleCache: { type: 'boolean', required: false },
     },
     async create(options) {
-        const fs = new WebAccessFS(options.handle);
+        const fs = new WebAccessFS(options.handle, options.disableHandleCache);
         await fs._loadMetadata(options.metadata);
         return fs;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.2.0",
+	"version": "1.2.2",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",