sliftutils 1.4.11 → 1.4.12

package/index.d.ts

@@ -1343,6 +1343,8 @@ declare module "sliftutils/storage/FileFolderAPI" {
         }
     }
     export type FileWrapper = {
+        readonly kind: "file";
+        readonly name: string;
         getFile(): Promise<{
             size: number;
             lastModified: number;
@@ -1360,6 +1362,8 @@ declare module "sliftutils/storage/FileFolderAPI" {
         }>;
     };
     export type DirectoryWrapper = {
+        readonly kind: "directory";
+        readonly name: string;
         removeEntry(key: string, options?: {
             recursive?: boolean;
         }): Promise<void>;
@@ -1369,25 +1373,15 @@ declare module "sliftutils/storage/FileFolderAPI" {
         getDirectoryHandle(key: string, options?: {
             create?: boolean;
         }): Promise<DirectoryWrapper>;
-        [Symbol.asyncIterator](): AsyncIterableIterator<[
-            string,
-            {
-                kind: "file";
-                name: string;
-                getFile(): Promise<FileWrapper>;
-            } | {
-                kind: "directory";
-                name: string;
-                getDirectoryHandle(key: string, options?: {
-                    create?: boolean;
-                }): Promise<DirectoryWrapper>;
-            }
-        ]>;
+        entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
+        [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
     };
     export declare function setFileAPIKey(key: string): void;
     export declare class NodeJSFileHandleWrapper implements FileWrapper {
         private filePath;
         constructor(filePath: string);
+        readonly kind: "file";
+        get name(): string;
         getFile(): Promise<{
             size: number;
             lastModified: number;
@@ -1407,6 +1401,9 @@ declare module "sliftutils/storage/FileFolderAPI" {
     export declare class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
         private rootPath;
         constructor(rootPath: string);
+        readonly kind: "directory";
+        get name(): string;
+        entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
         removeEntry(key: string, options?: {
             recursive?: boolean;
         }): Promise<void>;
@@ -1416,20 +1413,7 @@ declare module "sliftutils/storage/FileFolderAPI" {
         getDirectoryHandle(key: string, options?: {
             create?: boolean;
         }): Promise<DirectoryWrapper>;
-        [Symbol.asyncIterator](): AsyncIterableIterator<[
-            string,
-            {
-                kind: "file";
-                name: string;
-                getFile(): Promise<FileWrapper>;
-            } | {
-                kind: "directory";
-                name: string;
-                getDirectoryHandle(key: string, options?: {
-                    create?: boolean;
-                }): Promise<DirectoryWrapper>;
-            }
-        ]>;
+        [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
     }
     export declare const getDirectoryHandle: {
         (): Promise<DirectoryWrapper>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.4.11",
+    "version": "1.4.12",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/FileFolderAPI.d.ts

@@ -29,6 +29,8 @@ declare global {
     }
 }
 export type FileWrapper = {
+    readonly kind: "file";
+    readonly name: string;
     getFile(): Promise<{
         size: number;
         lastModified: number;
@@ -46,6 +48,8 @@ export type FileWrapper = {
     }>;
 };
 export type DirectoryWrapper = {
+    readonly kind: "directory";
+    readonly name: string;
     removeEntry(key: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
@@ -55,25 +59,15 @@ export type DirectoryWrapper = {
     getDirectoryHandle(key: string, options?: {
         create?: boolean;
     }): Promise<DirectoryWrapper>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<[
-        string,
-        {
-            kind: "file";
-            name: string;
-            getFile(): Promise<FileWrapper>;
-        } | {
-            kind: "directory";
-            name: string;
-            getDirectoryHandle(key: string, options?: {
-                create?: boolean;
-            }): Promise<DirectoryWrapper>;
-        }
-    ]>;
+    entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
 };
 export declare function setFileAPIKey(key: string): void;
 export declare class NodeJSFileHandleWrapper implements FileWrapper {
     private filePath;
     constructor(filePath: string);
+    readonly kind: "file";
+    get name(): string;
     getFile(): Promise<{
         size: number;
         lastModified: number;
@@ -93,6 +87,9 @@ export declare class NodeJSFileHandleWrapper implements FileWrapper {
 export declare class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
     private rootPath;
     constructor(rootPath: string);
+    readonly kind: "directory";
+    get name(): string;
+    entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
     removeEntry(key: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
@@ -102,20 +99,7 @@ export declare class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
     getDirectoryHandle(key: string, options?: {
         create?: boolean;
     }): Promise<DirectoryWrapper>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<[
-        string,
-        {
-            kind: "file";
-            name: string;
-            getFile(): Promise<FileWrapper>;
-        } | {
-            kind: "directory";
-            name: string;
-            getDirectoryHandle(key: string, options?: {
-                create?: boolean;
-            }): Promise<DirectoryWrapper>;
-        }
-    ]>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
 }
 export declare const getDirectoryHandle: {
     (): Promise<DirectoryWrapper>;

package/storage/FileFolderAPI.tsx

@@ -36,7 +36,13 @@ declare global {
 // DO NOT enable this is isNode
 const USE_INDEXED_DB = false;
 
+// These mirror the subset of the native FileSystemFileHandle / FileSystemDirectoryHandle API we use, so
+// the native browser handles, the Node handles, and the remote handles are all interchangeable — and
+// code written against the native handle (e.g. a recursive walk over `handle.entries()`) works on any of
+// them. kind/name and entries() are part of that contract.
 export type FileWrapper = {
+    readonly kind: "file";
+    readonly name: string;
     getFile(): Promise<{
         size: number;
         lastModified: number;
@@ -52,18 +58,14 @@ export type FileWrapper = {
     }>;
 };
 export type DirectoryWrapper = {
+    readonly kind: "directory";
+    readonly name: string;
     removeEntry(key: string, options?: { recursive?: boolean }): Promise<void>;
     getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper>;
     getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<[string, {
-        kind: "file";
-        name: string;
-        getFile(): Promise<FileWrapper>;
-    } | {
-        kind: "directory";
-        name: string;
-        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;
-    }]>;
+    // Each entry IS a handle (file or directory), so a recursive walk keeps working at every level.
+    entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
 };
 
 let displayData = observable({
@@ -222,6 +224,8 @@ class ServerConnectForm extends preact.Component<{ onConnected: (config: RemoteC
 export class NodeJSFileHandleWrapper implements FileWrapper {
     constructor(private filePath: string) {
     }
+    readonly kind = "file" as const;
+    get name() { return path.basename(this.filePath); }
 
     async getFile() {
         const stats = await fs.promises.stat(this.filePath);
@@ -285,6 +289,9 @@ export class NodeJSFileHandleWrapper implements FileWrapper {
 export class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
     constructor(private rootPath: string) {
     }
+    readonly kind = "directory" as const;
+    get name() { return path.basename(this.rootPath); }
+    entries() { return this[Symbol.asyncIterator](); }
 
     async removeEntry(key: string, options?: { recursive?: boolean }) {
         const entryPath = path.join(this.rootPath, key);
@@ -332,36 +339,18 @@ export class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
         return new NodeJSDirectoryHandleWrapper(dirPath);
     }
 
-    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, {
-        kind: "file";
-        name: string;
-        getFile(): Promise<FileWrapper>;
-    } | {
-        kind: "directory";
-        name: string;
-        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;
-    }]> {
+    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]> {
         // Ensure directory exists
         await fs.promises.mkdir(this.rootPath, { recursive: true });
 
         const entries = await fs.promises.readdir(this.rootPath, { withFileTypes: true });
 
         for (const entry of entries) {
+            const childPath = path.join(this.rootPath, entry.name);
             if (entry.isFile()) {
-                yield [entry.name, {
-                    kind: "file",
-                    name: entry.name,
-                    getFile: async () => new NodeJSFileHandleWrapper(path.join(this.rootPath, entry.name))
-                }];
+                yield [entry.name, new NodeJSFileHandleWrapper(childPath)];
             } else if (entry.isDirectory()) {
-                const dirPath = path.join(this.rootPath, entry.name);
-                yield [entry.name, {
-                    kind: "directory",
-                    name: entry.name,
-                    getDirectoryHandle: async (key: string, options?: { create?: boolean }) => {
-                        return new NodeJSDirectoryHandleWrapper(dirPath).getDirectoryHandle(key, options);
-                    }
-                }];
+                yield [entry.name, new NodeJSDirectoryHandleWrapper(childPath)];
             }
         }
     }

package/storage/remoteFileStorage.ts

@@ -184,11 +184,15 @@ class RangeCache {
 }
 
 const joinPath = (base: string, key: string) => (base ? base + "/" + key : key);
+const baseName = (p: string) => p.split("/").filter(Boolean).pop() || "";
 
 class RemoteFileWrapper implements FileWrapper {
     // `stat` is supplied when the parent already statted us (avoids a second /info). `createIntent` means
     // this was opened with create:true, so a missing file reads as empty (it'll be created on write).
     constructor(private conn: Connection, private filePath: string, private stat?: Stat, private createIntent = false) { }
+    // Mirror the native FileSystemFileHandle shape so code written against it works unchanged.
+    readonly kind = "file" as const;
+    get name() { return baseName(this.filePath); }
     async getFile() {
         let stat = this.stat ?? await this.conn.stat(this.filePath);
         if (!stat) {
@@ -220,17 +224,21 @@ class RemoteFileWrapper implements FileWrapper {
 
 class RemoteDirectoryWrapper implements DirectoryWrapper {
     constructor(private conn: Connection, private dirPath: string) { }
+    // Mirror the native FileSystemDirectoryHandle shape (name/kind/entries) so code written against the
+    // native API — e.g. recursive walks using `handle.entries()` — works the same over the network.
+    readonly kind = "directory" as const;
+    get name() { return baseName(this.dirPath); }
     async removeEntry(key: string): Promise<void> {
         await this.conn.remove(joinPath(this.dirPath, key));
     }
-    async getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper> {
+    async getFileHandle(key: string, options?: { create?: boolean }): Promise<RemoteFileWrapper> {
         const p = joinPath(this.dirPath, key);
         if (options?.create) return new RemoteFileWrapper(this.conn, p, undefined, true);
         const stat = await this.conn.stat(p);                 // matches the File API: throw if missing
         if (!stat || stat.dir) throw enoent(p);
         return new RemoteFileWrapper(this.conn, p, stat, false);
     }
-    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper> {
+    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<RemoteDirectoryWrapper> {
         const p = joinPath(this.dirPath, key);
         if (!options?.create) {
             const stat = await this.conn.stat(p);
@@ -238,17 +246,22 @@ class RemoteDirectoryWrapper implements DirectoryWrapper {
         }
         return new RemoteDirectoryWrapper(this.conn, p);       // dirs are created lazily on first write
     }
-    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, { kind: "file"; name: string; getFile(): Promise<FileWrapper> } | { kind: "directory"; name: string; getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper> }]> {
+    // Each entry is itself a real handle (a sub-wrapper), so a recursive walk over .entries() keeps
+    // working at every level — exactly like the native API.
+    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, RemoteFileWrapper | RemoteDirectoryWrapper]> {
         const entries = await this.conn.list(this.dirPath);
         for (const e of entries) {
             const childPath = joinPath(this.dirPath, e.name);
-            if (e.dir) {
-                yield [e.name, { kind: "directory", name: e.name, getDirectoryHandle: (k, o) => new RemoteDirectoryWrapper(this.conn, childPath).getDirectoryHandle(k, o) }];
-            } else {
-                yield [e.name, { kind: "file", name: e.name, getFile: async () => new RemoteFileWrapper(this.conn, childPath) }];
-            }
+            yield [e.name, e.dir ? new RemoteDirectoryWrapper(this.conn, childPath) : new RemoteFileWrapper(this.conn, childPath)];
         }
     }
+    entries() { return this[Symbol.asyncIterator](); }
+    keys() { return mapAsync(this[Symbol.asyncIterator](), ([name]) => name); }
+    values() { return mapAsync(this[Symbol.asyncIterator](), ([, handle]) => handle); }
+}
+
+async function* mapAsync<T, U>(it: AsyncIterableIterator<T>, fn: (v: T) => U): AsyncIterableIterator<U> {
+    for await (const v of it) yield fn(v);
 }
 
 // A DirectoryWrapper rooted at a remote server. Drop-in for the Node / File-API handles.