monoidentity 0.16.1 → 0.17.0

package/dist/+client.d.ts

@@ -1,5 +1,6 @@
 export * from "./+common.js";
 export { getLoginRecognized, relog, getVerification, getStorage, getScopedFS, completeSync, } from "./storage.js";
+export type { SyncStrategy } from "./storage/utils-storage.js";
 export { retrieveVerification } from "./verification-client.js";
 export { attest as rawAttest } from "./verification/attest.js";
 export { trackReady } from "./trackready.js";

package/dist/Monoidentity.svelte

@@ -2,16 +2,17 @@
   import type { Snippet } from "svelte";
   import { trackReady } from "./trackready.js";
   import type { Intent } from "./utils-transport.js";
+  import type { SyncStrategy } from "./storage/utils-storage.js";
 
   let {
     app,
     intents,
-    shouldBackup,
+    getSyncStrategy,
     children,
   }: {
     app: string;
     intents?: Intent[];
-    shouldBackup: (path: string) => boolean;
+    getSyncStrategy: (path: string) => SyncStrategy;
     children: Snippet;
   } = $props();
 
@@ -19,7 +20,7 @@
   const ready = trackReady(
     app,
     intents || [],
-    shouldBackup,
+    getSyncStrategy,
     (startBackup) =>
       (backup = () => {
         startBackup();

package/dist/Monoidentity.svelte.d.ts

@@ -1,9 +1,10 @@
 import type { Snippet } from "svelte";
 import type { Intent } from "./utils-transport.js";
+import type { SyncStrategy } from "./storage/utils-storage.js";
 type $$ComponentProps = {
     app: string;
     intents?: Intent[];
-    shouldBackup: (path: string) => boolean;
+    getSyncStrategy: (path: string) => SyncStrategy;
     children: Snippet;
 };
 declare const Monoidentity: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/storage/backupcloud.d.ts

@@ -1,2 +1,3 @@
 import type { Bucket } from "../utils-transport.js";
-export declare const backupCloud: (shouldBackup: (path: string) => boolean, bucket: Bucket) => Promise<void>;
+import { type SyncStrategy } from "./utils-storage.js";
+export declare const backupCloud: (getSyncStrategy: (path: string) => SyncStrategy, bucket: Bucket) => Promise<void>;

package/dist/storage/backupcloud.js

@@ -1,10 +1,10 @@
 import { AwsClient } from "aws4fetch";
 import { storageClient, STORAGE_EVENT } from "./storageclient.svelte.js";
 import { addToSync } from "../storage.js";
-import { shouldPersist } from "./_should.js";
+import { shouldPersist, enqueueSync } from "./utils-storage.js";
 const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
 let unmount;
-const loadFromCloud = async (shouldBackup, base, client) => {
+const loadFromCloud = async (getSyncStrategy, base, client) => {
     const listResp = await client.fetch(base);
     if (!listResp.ok)
         throw new Error(`List bucket failed: ${listResp.status}`);
@@ -12,7 +12,7 @@ const loadFromCloud = async (shouldBackup, base, client) => {
     const objects = [...listXml.matchAll(/<Key>(.*?)<\/Key>.*?<ETag>(.*?)<\/ETag>/gs)]
         .map((m) => m.slice(1).map((s) => s.replaceAll("&quot;", `"`).replaceAll("&apos;", `'`)))
         .map(([key, etag]) => ({ key, etag: etag.replaceAll(`"`, "") }))
-        .filter(({ key }) => shouldBackup(key));
+        .filter(({ key }) => getSyncStrategy(key).mode != "none");
     const prevCache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
     const nextCache = {};
     const model = {};
@@ -45,8 +45,8 @@ const loadFromCloud = async (shouldBackup, base, client) => {
     localStorage[CLOUD_CACHE_KEY] = JSON.stringify(nextCache);
     return model;
 };
-const syncFromCloud = async (shouldBackup, bucket, client) => {
-    const remote = await loadFromCloud(shouldBackup, bucket.base, client);
+const syncFromCloud = async (getSyncStrategy, bucket, client) => {
+    const remote = await loadFromCloud(getSyncStrategy, bucket.base, client);
     const local = storageClient();
     for (const key of Object.keys(local)) {
         if (key in remote)
@@ -61,17 +61,18 @@ const syncFromCloud = async (shouldBackup, bucket, client) => {
         local[key] = value;
     }
 };
-export const backupCloud = async (shouldBackup, bucket) => {
+export const backupCloud = async (getSyncStrategy, bucket) => {
     unmount?.();
     const client = new AwsClient({
         accessKeyId: bucket.accessKeyId,
         secretAccessKey: bucket.secretAccessKey,
     });
-    await syncFromCloud(shouldBackup, bucket, client);
-    const syncIntervalId = setInterval(() => syncFromCloud(shouldBackup, bucket, client), 15 * 60 * 1000);
+    await syncFromCloud(getSyncStrategy, bucket, client);
+    const syncIntervalId = setInterval(() => syncFromCloud(getSyncStrategy, bucket, client), 15 * 60 * 1000);
     // Continuous sync: mirror local changes to cloud
     const write = async (key, value) => {
-        if (!shouldBackup(key)) {
+        const strategy = getSyncStrategy(key);
+        if (strategy.mode == "none") {
             if (!shouldPersist(key))
                 console.warn("[monoidentity cloud]", key, "isn't marked to be backed up or saved");
             return;
@@ -105,15 +106,23 @@ export const backupCloud = async (shouldBackup, bucket) => {
             localStorage[CLOUD_CACHE_KEY] = JSON.stringify(cache);
         }
     };
+    const writeWrapped = async (key, value) => write(key, value).catch((err) => {
+        console.error("[monoidentity cloud] save failed", key, err);
+    });
     const listener = (event) => {
-        let key = event.detail.key;
-        if (!key.startsWith("monoidentity/"))
+        const fullKey = event.detail.key;
+        if (!fullKey.startsWith("monoidentity/"))
+            return;
+        const key = fullKey.slice("monoidentity/".length);
+        const strategy = getSyncStrategy(key);
+        if (strategy.mode == "none")
             return;
-        key = key.slice("monoidentity/".length);
-        const promise = write(key, event.detail.value).catch((err) => {
-            console.warn("[monoidentity cloud] save failed", key, err);
-        });
-        addToSync(promise);
+        if (strategy.mode == "immediate") {
+            addToSync(writeWrapped(key, event.detail.value));
+        }
+        else if (strategy.mode == "debounced") {
+            enqueueSync(fullKey, strategy.debounceMs, () => writeWrapped(key, localStorage[fullKey]));
+        }
     };
     addEventListener(STORAGE_EVENT, listener);
     unmount = () => {

package/dist/storage/backuplocally.d.ts

@@ -1 +1,2 @@
-export declare const backupLocally: (shouldBackup: (path: string) => boolean, requestBackup: (startBackup: () => void) => void) => Promise<void>;
+import { type SyncStrategy } from "./utils-storage.js";
+export declare const backupLocally: (getSyncStrategy: (path: string) => SyncStrategy, requestBackup: (startBackup: () => void) => void) => Promise<void>;

package/dist/storage/backuplocally.js

@@ -1,9 +1,9 @@
 import { createStore, get, set } from "idb-keyval";
 import { STORAGE_EVENT, storageClient } from "./storageclient.svelte.js";
 import { canBackup } from "../utils-localstorage.js";
-import { shouldPersist } from "./_should.js";
+import { shouldPersist } from "./utils-storage.js";
 let unmount;
-const saveToDir = (shouldBackup, dir) => {
+const saveToDir = (getSyncStrategy, dir) => {
     let dirCache = {};
     const getDirCached = async (route) => {
         let key = "";
@@ -18,19 +18,9 @@ const saveToDir = (shouldBackup, dir) => {
         }
         return parent;
     };
-    const listener = async (event) => {
-        let key = event.detail.key;
-        if (!key.startsWith("monoidentity/"))
-            return;
-        key = key.slice("monoidentity/".length);
+    const writeFile = async (key, value) => {
         const pathParts = key.split("/");
         const name = pathParts.at(-1);
-        const value = event.detail.value;
-        if (!shouldBackup(key)) {
-            if (!shouldPersist(key))
-                console.warn("[monoidentity backup]", key, "isn't marked to be backed up or saved");
-            return;
-        }
         console.debug("[monoidentity backup] saving", name);
         const parent = await getDirCached(pathParts.slice(0, -1));
         if (value != undefined) {
@@ -43,12 +33,26 @@ const saveToDir = (shouldBackup, dir) => {
             await parent.removeEntry(name);
         }
     };
+    const listener = async (event) => {
+        const fullKey = event.detail.key;
+        if (!fullKey.startsWith("monoidentity/"))
+            return;
+        const key = fullKey.slice("monoidentity/".length);
+        const strategy = getSyncStrategy(key);
+        if (strategy.mode == "none") {
+            if (!shouldPersist(key))
+                console.warn("[monoidentity backup]", key, "isn't marked to be backed up or saved");
+            return;
+        }
+        // Directly write
+        await writeFile(key, event.detail.value);
+    };
     addEventListener(STORAGE_EVENT, listener);
     return () => {
         removeEventListener(STORAGE_EVENT, listener);
     };
 };
-export const backupLocally = async (shouldBackup, requestBackup) => {
+export const backupLocally = async (getSyncStrategy, requestBackup) => {
     if (!canBackup)
         return;
     if (localStorage["monoidentity-x/backup"] == "off")
@@ -59,7 +63,7 @@ export const backupLocally = async (shouldBackup, requestBackup) => {
         const dir = await get("backup", handles);
         if (!dir)
             throw new Error("No backup handle found");
-        unmount = saveToDir(shouldBackup, dir);
+        unmount = saveToDir(getSyncStrategy, dir);
     }
     else {
         localStorage["monoidentity-x/backup"] = "off";
@@ -91,7 +95,7 @@ export const backupLocally = async (shouldBackup, requestBackup) => {
                 location.reload();
                 return;
             }
-            unmount = saveToDir(shouldBackup, dir);
+            unmount = saveToDir(getSyncStrategy, dir);
         });
     }
 };

package/dist/storage/storageclient.svelte.js

@@ -1,3 +1,4 @@
+import { flush } from "./utils-storage.js";
 export const STORAGE_EVENT = "monoidentity-storage";
 const announce = (key, value) => {
     // Announce to all, even third parties
@@ -25,10 +26,36 @@ export const storageClient = (prefix, unprefix, serialize, deserialize) => {
     else {
         prefix = (key) => `monoidentity/${key}`;
     }
+    const getScopedKeys = () => {
+        const keys = [];
+        for (const key in localStorage) {
+            if (!key.startsWith("monoidentity/"))
+                continue;
+            let scopedKey = key.slice("monoidentity/".length);
+            if (unprefix) {
+                const unprefixed = unprefix(scopedKey);
+                if (!unprefixed)
+                    continue;
+                scopedKey = unprefixed;
+            }
+            keys.push(scopedKey);
+        }
+        return keys;
+    };
     return new Proxy({}, {
         get(_, key) {
             if (typeof key == "symbol")
                 return undefined;
+            if (key == "flush") {
+                return async (userKey) => {
+                    if (userKey) {
+                        await flush([prefix(userKey)]);
+                    }
+                    else {
+                        await flush(getScopedKeys().map((k) => prefix(k)));
+                    }
+                };
+            }
             key = prefix(key);
             storageCounters[key];
             const raw = localStorage[key];
@@ -50,20 +77,7 @@ export const storageClient = (prefix, unprefix, serialize, deserialize) => {
         },
         ownKeys() {
             allCounter;
-            const keys = [];
-            for (let key in localStorage) {
-                if (!key.startsWith("monoidentity/"))
-                    continue;
-                key = key.slice("monoidentity/".length);
-                if (unprefix) {
-                    const unprefixed = unprefix(key);
-                    if (!unprefixed)
-                        continue;
-                    key = unprefixed;
-                }
-                keys.push(key);
-            }
-            return keys;
+            return getScopedKeys();
         },
         getOwnPropertyDescriptor(_, key) {
             key = prefix(key);

package/dist/storage/utils-storage.d.ts

@@ -0,0 +1,11 @@
+export declare const shouldPersist: (key: string) => boolean;
+export type SyncStrategy = {
+    mode: "none";
+} | {
+    mode: "immediate";
+} | {
+    mode: "debounced";
+    debounceMs: number;
+};
+export declare const enqueueSync: (key: string, debounceMs: number, sync: () => Promise<void>) => void;
+export declare const flush: (keys: string[]) => Promise<void>;

package/dist/storage/utils-storage.js

@@ -0,0 +1,38 @@
+export const shouldPersist = (key) => key.includes(".cache/");
+const syncQueue = {};
+export const enqueueSync = (key, debounceMs, sync) => {
+    // Cancel existing timeout if any
+    if (syncQueue[key]) {
+        clearTimeout(syncQueue[key].timeout);
+    }
+    // Set new timeout
+    const timeout = setTimeout(() => {
+        const entry = syncQueue[key];
+        if (!entry)
+            throw new Error("Sync entry missing");
+        delete syncQueue[key];
+        entry.sync();
+    }, debounceMs);
+    syncQueue[key] = { timeout, sync };
+};
+export const flush = async (keys) => {
+    const entries = keys
+        .map((key) => [key, syncQueue[key]])
+        .filter((item) => Boolean(item[1]));
+    // Clear queue first
+    for (const [k, entry] of entries) {
+        clearTimeout(entry.timeout);
+        delete syncQueue[k];
+    }
+    // Then flush all
+    await Promise.all(entries.map(([_, entry]) => entry.sync()));
+};
+if (import.meta.hot) {
+    import.meta.hot.dispose(() => {
+        for (const key in syncQueue) {
+            const entry = syncQueue[key];
+            delete syncQueue[key];
+            clearTimeout(entry.timeout);
+        }
+    });
+}

package/dist/storage.js

@@ -43,5 +43,8 @@ export const setVerification = (jwt) => {
     const client = storageClient();
     client[VERIFICATION_PATH] = jwt;
 };
-export const getStorage = (realm) => storageClient((key) => `.${realm}/${app}/${key}.devalue`, undefined, stringify, parse);
+export const getStorage = (realm) => {
+    const prefix = `.${realm}/${app}/`;
+    return storageClient((key) => `${prefix}${key}.devalue`, (key) => (key.startsWith(prefix) ? key.slice(prefix.length, -".devalue".length) : undefined), stringify, parse);
+};
 export const getScopedFS = (dir) => storageClient((key) => `${dir}/${key}`, (key) => (key.startsWith(dir + "/") ? key.slice(dir.length + 1) : undefined));

package/dist/trackready.d.ts

@@ -1,2 +1,3 @@
 import { type Intent } from "./utils-transport.js";
-export declare const trackReady: (app: string, intents: Intent[], shouldBackup: (path: string) => boolean, requestBackup: (startBackup: () => void) => void) => Promise<void>;
+import type { SyncStrategy } from "./storage/utils-storage.js";
+export declare const trackReady: (app: string, intents: Intent[], getSyncStrategy: (path: string) => SyncStrategy, requestBackup: (startBackup: () => void) => void) => Promise<void>;

package/dist/trackready.js

@@ -6,7 +6,7 @@ import { conf, setLoginRecognized } from "./storage.js";
 import { backupLocally } from "./storage/backuplocally.js";
 import { backupCloud } from "./storage/backupcloud.js";
 import { switchToHub } from "./utils-hub.js";
-export const trackReady = async (app, intents, shouldBackup, requestBackup) => {
+export const trackReady = async (app, intents, getSyncStrategy, requestBackup) => {
     conf(app);
     let setup = localStorage["monoidentity-x/setup"]
         ? JSON.parse(localStorage["monoidentity-x/setup"])
@@ -28,10 +28,10 @@ export const trackReady = async (app, intents, shouldBackup, requestBackup) => {
         switchToHub([{ storage: true }, ...intents]);
     }
     if (setup.method == "localStorage") {
-        await backupLocally(shouldBackup, requestBackup);
+        await backupLocally(getSyncStrategy, requestBackup);
     }
     if (setup.method == "cloud") {
-        await backupCloud(shouldBackup, setup);
+        await backupCloud(getSyncStrategy, setup);
     }
     for (const provision of provisions) {
         if ("createLoginRecognized" in provision) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "license": "ISC",
   "repository": "KTibow/monoidentity",
   "author": {
@@ -33,24 +33,24 @@
   "dependencies": {
     "@tsndr/cloudflare-worker-jwt": "^3.2.0",
     "aws4fetch": "^1.0.20",
-    "devalue": "^5.4.2",
-    "fast-studentvue": "^2.0.3",
+    "devalue": "^5.5.0",
+    "fast-studentvue": "^2.1.1",
     "idb-keyval": "^6.2.2",
     "valibot": "^1.1.0"
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.48.4",
+    "@sveltejs/kit": "^2.48.5",
     "@sveltejs/package": "^2.5.4",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
     "@types/wicg-file-system-access": "^2023.10.7",
-    "knip": "^5.68.0",
+    "knip": "^5.69.1",
     "monoserve": "^3.2.2",
     "publint": "^0.3.15",
-    "rolldown": "1.0.0-beta.47",
-    "school-districts": "^4.0.0",
-    "svelte": "^5.43.5",
-    "svelte-check": "^4.3.3",
+    "rolldown": "^1.0.0-beta.47",
+    "school-districts": "^5.0.1",
+    "svelte": "^5.43.6",
+    "svelte-check": "^4.3.4",
     "tinyglobby": "^0.2.15",
     "typescript": "^5.9.3",
     "vite": "^7.2.2"

package/dist/storage/_should.d.ts

@@ -1 +0,0 @@
-export declare const shouldPersist: (key: string) => boolean;

package/dist/storage/_should.js

@@ -1 +0,0 @@
-export const shouldPersist = (key) => key.includes(".cache/");