sliftutils 1.2.17 → 1.2.19

package/index.d.ts

@@ -1336,7 +1336,7 @@ declare module "sliftutils/storage/fileSystemPointer" {
     export declare function getFileSystemPointer(config: {
         pointer: FileSystemPointer;
     }): Promise<{
-        onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
+        onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle | undefined>;
     } | undefined>;
 
 }

package/package.json

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

package/storage/DiskCollection.ts

@@ -8,7 +8,7 @@ import { TransactionStorage } from "./TransactionStorage";
 import { PendingStorage } from "./PendingStorage";
 import { isDefined } from "../misc/types";
 import { PrivateFileSystemStorage } from "./PrivateFileSystemStorage";
-import { isInChromeExtension } from "../misc/environment";
+import { isInChromeExtension, isInChromeExtensionBackground } from "../misc/environment";
 import { CBORStorage } from "./CBORStorage";
 
 export class DiskCollection<T> implements IStorageSync<T> {
@@ -27,7 +27,7 @@ export class DiskCollection<T> implements IStorageSync<T> {
     public transactionStorage: TransactionStorage | undefined;
     async initStorage(): Promise<IStorage<T>> {
         // If a Chrome extension, just return null. 
-        if (isInChromeExtension()) return null as any;
+        if (isInChromeExtensionBackground()) return null as any;
         let curCollection: IStorageRaw;
         if (this.config?.noPrompt && !isNode()) {
             curCollection = await new PrivateFileSystemStorage(`collections/${this.collectionName}`);

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("/")) {

package/storage/fileSystemPointer.d.ts

@@ -7,5 +7,5 @@ export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Pro
 export declare function getFileSystemPointer(config: {
     pointer: FileSystemPointer;
 }): Promise<{
-    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle | undefined>;
 } | undefined>;

package/storage/fileSystemPointer.ts

@@ -63,7 +63,7 @@ export async function getFileSystemPointer(config: {
     // IMPORTANT! In some circumstances user activation is not required (with multiple tabs,
     //      and potentially with https://developer.chrome.com/blog/persistent-permissions-for-the-file-system-access-api),
     //      so... trying to call onUserActivation immmediately is a good idea (although it might throw).
-    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle | undefined>
 } | undefined
 > {
     const handle = await read(config.pointer);
@@ -71,10 +71,14 @@ export async function getFileSystemPointer(config: {
     let mode = config.pointer.split("_").at(-1);
     return {
         async onUserActivation(modeOverride) {
-            let testMode = await (handle as any).queryPermission({ mode: mode });
-            if (testMode !== mode) {
-                await (handle as any).requestPermission({ mode: modeOverride ?? mode });
+            let requestedMode = modeOverride ?? mode;
+            let permission = await (handle as any).queryPermission({ mode: requestedMode });
+            if (permission !== "granted") {
+                permission = await (handle as any).requestPermission({ mode: requestedMode });
             }
+            // If the user denied (or otherwise didn't grant) the request, treat the
+            //  stored pointer as unusable so callers can fall back to showDirectoryPicker.
+            if (permission !== "granted") return undefined;
             return handle;
         }
     };