@zenfs/dom 1.1.9 → 1.2.0

package/dist/access.d.ts

@@ -3,16 +3,32 @@ import { IndexFS } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
     metadata?: string;
+    /**
+     * If set, disables caching of file system handles.
+     * This could significantly degrade lookup performance.
+     */
+    disableHandleCache?: boolean;
 }
 type HKindToType<T extends FileSystemHandleKind> = 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()`\
+ * @internal
+ */
 export declare class WebAccessFS extends WebAccessFS_base {
+    protected readonly root: FileSystemDirectoryHandle;
+    protected readonly disableHandleCache: boolean;
+    /**
+     * Used to speed up handle lookups.
+     * Without this, every lookup would be O(n) on the path length.
+     * With the cache, these become O(1) operations.
+     */
     protected _handles: Map<string, FileSystemHandle>;
     /**
      * Loads all of the handles.
      * @internal @hidden
      */
-    _loadHandles(path: string, handle: FileSystemDirectoryHandle): Promise<void>;
+    protected _loadHandles(path: string, handle: FileSystemDirectoryHandle): Promise<void>;
     /**
      * Loads metadata
      * @internal @hidden
@@ -22,7 +38,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
      * @hidden
      */
     _sync: FileSystem;
-    constructor(handle: FileSystemDirectoryHandle);
+    constructor(root: FileSystemDirectoryHandle, disableHandleCache?: boolean);
     protected remove(path: string): Promise<void>;
     protected removeSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
@@ -33,7 +49,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): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
+    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string): Promise<T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle>;
 }
 declare const _WebAccess: {
     readonly name: "WebAccess";
@@ -46,6 +62,10 @@ declare const _WebAccess: {
             readonly type: "string";
             readonly required: false;
         };
+        readonly disableHandleCache: {
+            readonly type: "boolean";
+            readonly required: false;
+        };
     };
     readonly create: (options: WebAccessOptions) => Promise<WebAccessFS>;
 };

package/dist/access.js

@@ -18,6 +18,10 @@ function isResizable(buffer) {
 function isKind(handle, kind) {
     return handle.kind == kind;
 }
+/**
+ * @todo Consider supporting synchronous stuff with `FileSystemFileHandle.createSyncAccessHandle()`\
+ * @internal
+ */
 export class WebAccessFS extends Async(IndexFS) {
     /**
      * Loads all of the handles.
@@ -36,8 +40,10 @@ export class WebAccessFS extends Async(IndexFS) {
      * @internal @hidden
      */
     async _loadMetadata(metadataPath) {
+        this._handles.set('/', this.root);
+        await this._loadHandles('/', this.root);
         if (metadataPath) {
-            const handle = this.get('file', metadataPath);
+            const handle = await this.get('file', metadataPath);
             const file = await handle.getFile();
             const raw = await file.text();
             const data = JSON.parse(raw);
@@ -55,18 +61,26 @@ export class WebAccessFS extends Async(IndexFS) {
             this.index.set(path, new Inode({ mode: 0o777 | constants.S_IFDIR, size: 0 }));
         }
     }
-    constructor(handle) {
+    constructor(root, disableHandleCache = false) {
         super(0x77656261, 'webaccessfs');
+        this.root = root;
+        this.disableHandleCache = disableHandleCache;
+        /**
+         * Used to speed up handle lookups.
+         * Without this, every lookup would be O(n) on the path length.
+         * With the cache, these become O(1) operations.
+         */
         this._handles = new Map();
         /**
          * @hidden
          */
         this._sync = InMemory.create({ label: 'accessfs-cache' });
         this.attributes.set('no_buffer_resize', true);
-        this._handles.set('/', handle);
+        if (disableHandleCache)
+            this.attributes.set('no_handle_cache', true);
     }
     async remove(path) {
-        const handle = this.get('directory', dirname(path));
+        const handle = await this.get('directory', dirname(path));
         await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path)));
     }
     removeSync() {
@@ -75,7 +89,7 @@ export class WebAccessFS extends Async(IndexFS) {
     async read(path, buffer, offset, end) {
         if (end <= offset)
             return;
-        const handle = this.get('file', path);
+        const handle = await this.get('file', path);
         const file = await handle.getFile();
         const data = await file.arrayBuffer();
         if (data.byteLength < end - offset)
@@ -94,12 +108,13 @@ export class WebAccessFS extends Async(IndexFS) {
         const isDir = (inode.mode & S_IFMT) == S_IFDIR;
         let handle;
         try {
-            handle = this.get(isDir ? 'directory' : 'file', path);
+            handle = await this.get(isDir ? 'directory' : 'file', path);
         }
         catch {
-            const parent = this.get('directory', dirname(path));
+            const parent = await this.get('directory', dirname(path));
             handle = await parent[isDir ? 'getDirectoryHandle' : 'getFileHandle'](basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
-            this._handles.set(path, handle);
+            if (!this.disableHandleCache)
+                this._handles.set(path, handle);
         }
         if (isDir)
             return;
@@ -129,18 +144,38 @@ export class WebAccessFS extends Async(IndexFS) {
     }
     async mkdir(path, options) {
         const inode = await super.mkdir(path, options);
-        const handle = this.get('directory', dirname(path));
+        const handle = await this.get('directory', dirname(path));
         const dir = await handle.getDirectoryHandle(basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
-        this._handles.set(path, dir);
+        if (!this.disableHandleCache)
+            this._handles.set(path, dir);
         return inode;
     }
-    get(kind = null, path) {
-        const handle = this._handles.get(path);
-        if (!handle)
-            throw withErrno('ENODATA');
-        if (kind && !isKind(handle, kind))
-            throw withErrno(kind == 'directory' ? 'ENOTDIR' : 'EISDIR');
-        return handle;
+    async get(kind = null, path) {
+        if (!this.disableHandleCache) {
+            const handle = this._handles.get(path);
+            if (!handle)
+                throw withErrno('ENOENT');
+            if (kind && !isKind(handle, kind))
+                throw withErrno(kind == 'directory' ? 'ENOTDIR' : 'EISDIR');
+            return handle;
+        }
+        if (path == '/')
+            return this.root;
+        const parts = path.slice(1).split('/');
+        let dir = this.root;
+        for (let i = 0; i < parts.length - 1; ++i) {
+            dir = await dir.getDirectoryHandle(parts[i]).catch(ex => _throw(convertException(ex, path)));
+        }
+        try {
+            const handle = await dir[kind == 'file' ? 'getFileHandle' : 'getDirectoryHandle'](parts.at(-1));
+            return handle;
+        }
+        catch (ex) {
+            if (ex.name == 'TypeMismatchError')
+                throw withErrno(kind == 'file' ? 'EISDIR' : 'ENOTDIR');
+            else
+                throw convertException(ex, path);
+        }
     }
 }
 const _WebAccess = {
@@ -148,10 +183,10 @@ const _WebAccess = {
     options: {
         handle: { type: 'object', required: true },
         metadata: { type: 'string', required: false },
+        disableHandleCache: { type: 'boolean', required: false },
     },
     async create(options) {
         const fs = new WebAccessFS(options.handle);
-        await fs._loadHandles('/', options.handle);
         await fs._loadMetadata(options.metadata);
         return fs;
     },

package/package.json

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