sliftutils 1.2.19 → 1.2.21

package/index.d.ts

@@ -859,6 +859,21 @@ declare module "sliftutils/storage/DiskCollection" {
         } | undefined>;
         reset(): Promise<void>;
     }
+    export declare class DiskCollectionRawSynced {
+        private collectionName;
+        constructor(collectionName: string);
+        initStorage(): Promise<IStorage<Buffer>>;
+        private synced;
+        get(key: string): Buffer | undefined;
+        getPromise(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): void;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
     export declare class DiskCollectionRawBrowser {
         private collectionName;
         constructor(collectionName: string);
@@ -1336,7 +1351,7 @@ declare module "sliftutils/storage/fileSystemPointer" {
     export declare function getFileSystemPointer(config: {
         pointer: FileSystemPointer;
     }): Promise<{
-        onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle | undefined>;
+        onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
     } | undefined>;
 
 }

package/package.json

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

package/storage/DiskCollection.d.ts

@@ -67,6 +67,21 @@ export declare class DiskCollectionRaw implements IStorage<Buffer> {
     } | undefined>;
     reset(): Promise<void>;
 }
+export declare class DiskCollectionRawSynced {
+    private collectionName;
+    constructor(collectionName: string);
+    initStorage(): Promise<IStorage<Buffer>>;
+    private synced;
+    get(key: string): Buffer | undefined;
+    getPromise(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): void;
+    getKeys(): Promise<string[]>;
+    getInfo(key: string): Promise<{
+        size: number;
+        lastModified: number;
+    } | undefined>;
+    reset(): Promise<void>;
+}
 export declare class DiskCollectionRawBrowser {
     private collectionName;
     constructor(collectionName: string);

package/storage/DiskCollection.ts

@@ -174,6 +174,42 @@ export class DiskCollectionRaw implements IStorage<Buffer> {
     }
 }
 
+export class DiskCollectionRawSynced {
+    constructor(private collectionName: string) { }
+    async initStorage(): Promise<IStorage<Buffer>> {
+        let fileStorage = await getFileStorage();
+        let collections = await fileStorage.folder.getStorage("collections");
+        let baseStorage = await collections.folder.getStorage(this.collectionName);
+        return baseStorage;
+    }
+    private synced = new StorageSync(
+        new PendingStorage(`Collection (${this.collectionName})`,
+            new DelayedStorage(this.initStorage())
+        )
+    );
+
+    public get(key: string): Buffer | undefined {
+        return this.synced.get(key);
+    }
+
+    public async getPromise(key: string): Promise<Buffer | undefined> {
+        return await this.synced.get(key);
+    }
+    public set(key: string, value: Buffer) {
+        this.synced.set(key, value);
+    }
+    public async getKeys(): Promise<string[]> {
+        return await this.synced.getKeys();
+    }
+    public async getInfo(key: string) {
+        return await this.synced.getInfo(key);
+    }
+
+    public async reset() {
+        await this.synced.reset();
+    }
+}
+
 export class DiskCollectionRawBrowser {
     constructor(private collectionName: string) { }
     async initStorage(): Promise<IStorage<Buffer>> {

package/storage/FileFolderAPI.tsx

@@ -221,146 +221,8 @@ 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
-const getDirectoryHandleRaw = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
+export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
     if (isNode()) {
         return new NodeJSDirectoryHandleWrapper(path.resolve("./data/"));
     }
@@ -467,12 +329,6 @@ const getDirectoryHandleRaw = lazy(async function getDirectoryHandle(): Promise<
     }
 });
 
-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 | undefined>;
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
 } | 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 | undefined>
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>
 } | undefined
 > {
     const handle = await read(config.pointer);
@@ -71,14 +71,10 @@ export async function getFileSystemPointer(config: {
     let mode = config.pointer.split("_").at(-1);
     return {
         async onUserActivation(modeOverride) {
-            let requestedMode = modeOverride ?? mode;
-            let permission = await (handle as any).queryPermission({ mode: requestedMode });
-            if (permission !== "granted") {
-                permission = await (handle as any).requestPermission({ mode: requestedMode });
+            let testMode = await (handle as any).queryPermission({ mode: mode });
+            if (testMode !== mode) {
+                await (handle as any).requestPermission({ mode: modeOverride ?? mode });
             }
-            // 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;
         }
     };