sliftutils 1.2.18 → 1.2.19

package/package.json

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

package/storage/FileFolderAPI.tsx

@@ -221,8 +221,146 @@ class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {
 }
 
 
+function isNotAllowedError(e: unknown): boolean {
+    return !!e && typeof e === "object" && (e as any).name === "NotAllowedError";
+}
+
+// Deduplicates concurrent retry-prompts so only one button is shown to the user,
+//  and all in-flight callers wait on the same grant.
+let pendingPermissionPrompt: Promise<void> | undefined;
+async function requestPermissionInteractive(handle: any, mode: "read" | "readwrite" = "readwrite"): Promise<void> {
+    if (pendingPermissionPrompt) return pendingPermissionPrompt;
+    pendingPermissionPrompt = (async () => {
+        // Some browsers grant without user activation (persistent permissions, multi-tab).
+        //  Try once cheaply before showing UI.
+        try {
+            if (typeof handle?.requestPermission === "function") {
+                const result = await handle.requestPermission({ mode });
+                if (result === "granted") return;
+            }
+        } catch { /* user activation required — fall through to button */ }
+
+        let root = document.createElement("div");
+        document.body.appendChild(root);
+        preact.render(<DirectoryPrompter />, root);
+        try {
+            await new Promise<void>(resolve => {
+                displayData.ui = (
+                    <button
+                        className={css.fontSize(40).pad2(80, 40)}
+                        onClick={async () => {
+                            try {
+                                const result = await handle.requestPermission({ mode });
+                                if (result === "granted") {
+                                    resolve();
+                                    return;
+                                }
+                            } catch (err) {
+                                console.error("requestPermission failed:", (err as Error).stack ?? err);
+                            }
+                            // Permission still not granted — fall back to a fresh directory pick.
+                            try {
+                                const pickedHandle = await window.showDirectoryPicker();
+                                const grantResult = await (pickedHandle as any).requestPermission({ mode: "readwrite" });
+                                if (grantResult !== "granted") return;
+                                let newStoredId = await storeFileSystemPointer({ mode: "readwrite", handle: pickedHandle });
+                                localStorage.setItem(getFileAPIKey(), newStoredId);
+                                // Reload so all storage layers re-bind to the new root.
+                                window.location.reload();
+                            } catch (err) {
+                                console.error("showDirectoryPicker failed:", (err as Error).stack ?? err);
+                            }
+                        }}
+                    >
+                        Click to allow file system access
+                    </button>
+                );
+            });
+        } finally {
+            displayData.ui = undefined;
+            preact.render(null, root);
+            root.remove();
+        }
+    })();
+    try {
+        await pendingPermissionPrompt;
+    } finally {
+        pendingPermissionPrompt = undefined;
+    }
+}
+
+async function withPermissionRetry<T>(permissionHandle: any, op: () => Promise<T>): Promise<T> {
+    try {
+        return await op();
+    } catch (e) {
+        if (!isNotAllowedError(e)) throw e;
+        await requestPermissionInteractive(permissionHandle);
+        return await op();
+    }
+}
+
+function wrapFileWithRetry(file: FileWrapper, permissionHandle: any): FileWrapper {
+    return {
+        getFile: () => withPermissionRetry(permissionHandle, () => file.getFile()),
+        createWritable: async (config) => {
+            const writable = await withPermissionRetry(permissionHandle, () => file.createWritable(config));
+            return {
+                seek: (offset) => withPermissionRetry(permissionHandle, () => writable.seek(offset)),
+                write: (value) => withPermissionRetry(permissionHandle, () => writable.write(value)),
+                close: () => withPermissionRetry(permissionHandle, () => writable.close()),
+            };
+        },
+    };
+}
+
+function wrapDirectoryWithRetry(handle: DirectoryWrapper): DirectoryWrapper {
+    const permissionHandle = handle;
+    return {
+        removeEntry: (key, options) => withPermissionRetry(permissionHandle, () => handle.removeEntry(key, options)),
+        getFileHandle: (async (key: string, options?: { create?: boolean }) =>
+            wrapFileWithRetry(
+                await withPermissionRetry(permissionHandle, () => handle.getFileHandle(key, options)),
+                permissionHandle,
+            )) as DirectoryWrapper["getFileHandle"],
+        getDirectoryHandle: async (key, options) =>
+            wrapDirectoryWithRetry(await withPermissionRetry(permissionHandle, () => handle.getDirectoryHandle(key, options))),
+        async *[Symbol.asyncIterator]() {
+            let iter: AsyncIterator<any> | undefined;
+            while (true) {
+                let result: IteratorResult<any>;
+                try {
+                    if (!iter) iter = handle[Symbol.asyncIterator]();
+                    result = await iter.next();
+                } catch (e) {
+                    if (!isNotAllowedError(e)) throw e;
+                    await requestPermissionInteractive(permissionHandle);
+                    // Restart iteration after re-grant. Callers of getKeys/reset
+                    //  collect into arrays, so a fresh full iteration is correct.
+                    iter = undefined;
+                    continue;
+                }
+                if (result.done) return;
+                const [name, entry] = result.value;
+                if (entry.kind === "directory") {
+                    yield [name, {
+                        ...entry,
+                        getDirectoryHandle: async (k: string, o?: { create?: boolean }) =>
+                            wrapDirectoryWithRetry(await withPermissionRetry(permissionHandle, () => entry.getDirectoryHandle(k, o))),
+                    }];
+                } else {
+                    yield [name, {
+                        ...entry,
+                        getFile: async () =>
+                            wrapFileWithRetry(await withPermissionRetry(permissionHandle, () => entry.getFile()), permissionHandle),
+                    }];
+                }
+            }
+        },
+    };
+}
+
 // NOTE: Blocks until the user provides a directory
-export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
+const getDirectoryHandleRaw = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
     if (isNode()) {
         return new NodeJSDirectoryHandleWrapper(path.resolve("./data/"));
     }
@@ -329,6 +467,12 @@ export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Prom
     }
 });
 
+export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
+    const handle = await getDirectoryHandleRaw();
+    if (isNode()) return handle;
+    return wrapDirectoryWithRetry(handle);
+});
+
 export const getFileStorageNested = cache(async function getFileStorage(path: string): Promise<FileStorage> {
     let base = await getDirectoryHandle();
     for (let part of path.split("/")) {