monoidentity 0.17.1 → 0.18.0

package/dist/+client.d.ts

@@ -3,5 +3,5 @@ export { getLoginRecognized, relog, getVerification, getStorage, getScopedFS, co
 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";
+export { syncFinished, readyUp } from "./readyup.js";
 export { default as Monoidentity } from "./Monoidentity.svelte";

package/dist/+client.js

@@ -2,5 +2,5 @@ export * from "./+common.js";
 export { getLoginRecognized, relog, getVerification, getStorage, getScopedFS, completeSync, } from "./storage.js";
 export { retrieveVerification } from "./verification-client.js";
 export { attest as rawAttest } from "./verification/attest.js";
-export { trackReady } from "./trackready.js";
+export { syncFinished, readyUp } from "./readyup.js";
 export { default as Monoidentity } from "./Monoidentity.svelte";

package/dist/Monoidentity.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
   import type { Snippet } from "svelte";
-  import { trackReady } from "./trackready.js";
+  import { readyUp } from "./readyup.js";
   import type { Intent } from "./utils-transport.js";
   import type { SyncStrategy } from "./storage/utils-storage.js";
 
@@ -17,7 +17,7 @@
   } = $props();
 
   let backup: (() => void) | undefined = $state();
-  const ready = trackReady(
+  readyUp(
     app,
     intents || [],
     getSyncStrategy,
@@ -35,11 +35,7 @@
   <button class="primary" onclick={yes}>Connect</button>
 {/snippet}
 
-{#await ready}
-  <p class="center">Setting up</p>
-{:then}
-  {@render children()}
-{/await}
+{@render children()}
 {#if backup}
   <div class="backup toast">
     {@render backupUI(backup, () => (backup = undefined))}
@@ -88,7 +84,4 @@
     top: 1rem;
     z-index: 1000;
   }
-  .center {
-    margin: auto;
-  }
 </style>

package/dist/readyup.d.ts

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

package/dist/{trackready.js → readyup.js}

@@ -6,7 +6,11 @@ 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, getSyncStrategy, requestBackup) => {
+let resolveSyncFinished;
+export const syncFinished = new Promise((resolve) => {
+    resolveSyncFinished = resolve;
+});
+export const readyUp = (app, intents, getSyncStrategy, requestBackup) => {
     conf(app);
     let setup = localStorage["monoidentity-x/setup"]
         ? JSON.parse(localStorage["monoidentity-x/setup"])
@@ -27,15 +31,18 @@ export const trackReady = async (app, intents, getSyncStrategy, requestBackup) =
     if (!setup) {
         switchToHub([{ storage: true }, ...intents]);
     }
-    if (setup.method == "localStorage") {
-        await backupLocally(getSyncStrategy, requestBackup);
-    }
-    if (setup.method == "cloud") {
-        await backupCloud(getSyncStrategy, setup);
-    }
     for (const provision of provisions) {
         if ("createLoginRecognized" in provision) {
             setLoginRecognized(provision.createLoginRecognized);
         }
     }
+    (async () => {
+        if (setup.method == "localStorage") {
+            await backupLocally(getSyncStrategy, requestBackup);
+        }
+        if (setup.method == "cloud") {
+            await backupCloud(getSyncStrategy, setup);
+        }
+        resolveSyncFinished();
+    })();
 };

package/dist/storage/backupcloud.js

@@ -2,9 +2,26 @@ import { AwsClient } from "aws4fetch";
 import { storageClient, STORAGE_EVENT } from "./storageclient.svelte.js";
 import { addToSync } from "../storage.js";
 import { shouldPersist, enqueueSync } from "./utils-storage.js";
-const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
+import { get, set } from "idb-keyval";
+import { store } from "./utils-idb.js";
+const CLOUD_CACHE_KEY = "cloud-cache";
 let unmount;
+let cache;
+const initCache = async () => {
+    cache = (await get(CLOUD_CACHE_KEY, store)) || {};
+};
+const getCache = () => {
+    if (!cache)
+        throw new Error("Cache not initialized");
+    return cache;
+};
+const saveCache = async () => {
+    if (!cache)
+        throw new Error("Cache not initialized");
+    await set(CLOUD_CACHE_KEY, cache, store);
+};
 const loadFromCloud = async (getSyncStrategy, base, client) => {
+    const cachePromise = initCache();
     const listResp = await client.fetch(base);
     if (!listResp.ok)
         throw new Error(`List bucket failed: ${listResp.status}`);
@@ -12,8 +29,9 @@ const loadFromCloud = async (getSyncStrategy, 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 }) => getSyncStrategy(key).mode != "none");
-    const prevCache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
+        .filter(({ key }) => getSyncStrategy(key));
+    await cachePromise;
+    const prevCache = getCache();
     const nextCache = {};
     const model = {};
     await Promise.all(objects.map(async ({ key, etag }) => {
@@ -42,7 +60,8 @@ const loadFromCloud = async (getSyncStrategy, base, client) => {
         model[key] = content;
         nextCache[key] = { etag, content };
     }));
-    localStorage[CLOUD_CACHE_KEY] = JSON.stringify(nextCache);
+    cache = nextCache;
+    saveCache();
     return model;
 };
 const syncFromCloud = async (getSyncStrategy, bucket, client) => {
@@ -72,7 +91,7 @@ export const backupCloud = async (getSyncStrategy, bucket) => {
     // Continuous sync: mirror local changes to cloud
     const write = async (key, value) => {
         const strategy = getSyncStrategy(key);
-        if (strategy.mode == "none") {
+        if (!strategy) {
             if (!shouldPersist(key))
                 console.warn("[monoidentity cloud]", key, "isn't marked to be backed up or saved");
             return;
@@ -91,9 +110,8 @@ export const backupCloud = async (getSyncStrategy, bucket) => {
             // Update cache
             const etag = r.headers.get("etag")?.replaceAll('"', "");
             if (etag) {
-                const cache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
-                cache[key] = { etag, content: value };
-                localStorage[CLOUD_CACHE_KEY] = JSON.stringify(cache);
+                getCache()[key] = { etag, content: value };
+                saveCache();
             }
         }
         else {
@@ -101,9 +119,6 @@ export const backupCloud = async (getSyncStrategy, bucket) => {
             const r = await client.fetch(url, { method: "DELETE" });
             if (!r.ok && r.status != 404)
                 throw new Error(`DELETE ${key} failed: ${r.status}`);
-            const cache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
-            delete cache[key];
-            localStorage[CLOUD_CACHE_KEY] = JSON.stringify(cache);
         }
     };
     const writeWrapped = async (key, value) => write(key, value).catch((err) => {
@@ -115,7 +130,7 @@ export const backupCloud = async (getSyncStrategy, bucket) => {
             return;
         const key = fullKey.slice("monoidentity/".length);
         const strategy = getSyncStrategy(key);
-        if (strategy.mode == "none")
+        if (!strategy)
             return;
         if (strategy.mode == "immediate") {
             addToSync(writeWrapped(key, event.detail.value));

package/dist/storage/backuplocally.js

@@ -1,7 +1,10 @@
-import { createStore, get, set } from "idb-keyval";
+import { get, set } from "idb-keyval";
 import { STORAGE_EVENT, storageClient } from "./storageclient.svelte.js";
 import { canBackup } from "../utils-localstorage.js";
 import { shouldPersist } from "./utils-storage.js";
+import { store } from "./utils-idb.js";
+const TOGGLE_KEY = "monoidentity-x/local-backup";
+const HANDLE_KEY = "backup-handle";
 let unmount;
 const saveToDir = (getSyncStrategy, dir) => {
     let dirCache = {};
@@ -39,7 +42,7 @@ const saveToDir = (getSyncStrategy, dir) => {
             return;
         const key = fullKey.slice("monoidentity/".length);
         const strategy = getSyncStrategy(key);
-        if (strategy.mode == "none") {
+        if (!strategy) {
             if (!shouldPersist(key))
                 console.warn("[monoidentity backup]", key, "isn't marked to be backed up or saved");
             return;
@@ -55,22 +58,21 @@ const saveToDir = (getSyncStrategy, dir) => {
 export const backupLocally = async (getSyncStrategy, requestBackup) => {
     if (!canBackup)
         return;
-    if (localStorage["monoidentity-x/backup"] == "off")
+    if (localStorage[TOGGLE_KEY] == "off")
         return;
     unmount?.();
-    const handles = createStore("monoidentity-x", "handles");
-    if (localStorage["monoidentity-x/backup"] == "on") {
-        const dir = await get("backup", handles);
+    if (localStorage[TOGGLE_KEY] == "on") {
+        const dir = await get(HANDLE_KEY, store);
         if (!dir)
             throw new Error("No backup handle found");
         unmount = saveToDir(getSyncStrategy, dir);
     }
     else {
-        localStorage["monoidentity-x/backup"] = "off";
+        localStorage[TOGGLE_KEY] = "off";
         requestBackup(async () => {
             const dir = await showDirectoryPicker({ mode: "readwrite" });
-            await set("backup", dir, handles);
-            localStorage["monoidentity-x/backup"] = "on";
+            await set(HANDLE_KEY, dir, store);
+            localStorage[TOGGLE_KEY] = "on";
             // Restore from backup
             const backup = {};
             const traverse = async (d, path) => {

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

@@ -0,0 +1 @@
+export declare const store: import("idb-keyval").UseStore;

package/dist/storage/utils-idb.js

@@ -0,0 +1,2 @@
+import { createStore } from "idb-keyval";
+export const store = createStore("monoidentity-x", "keyval");

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

@@ -1,7 +1,5 @@
 export declare const shouldPersist: (key: string) => boolean;
-export type SyncStrategy = {
-    mode: "none";
-} | {
+export type SyncStrategy = undefined | {
     mode: "immediate";
 } | {
     mode: "debounced";

package/dist/storage/utils-storage.js

@@ -1,4 +1,4 @@
-export const shouldPersist = (key) => key.includes(".cache/");
+export const shouldPersist = (key) => key.startsWith(".cache/") || key.startsWith(".local/");
 const syncQueue = {};
 export const enqueueSync = (key, debounceMs, sync) => {
     // Cancel existing timeout if any

package/dist/storage.js

@@ -15,9 +15,13 @@ export const addToSync = (p) => {
     syncPromise = syncPromise.then(() => p);
 };
 export const completeSync = () => syncPromise;
-const LOGIN_RECOGNIZED_PATH = ".core/login.encjson";
+const LOGIN_RECOGNIZED_PATH = ".local/login.encjson";
 export const getLoginRecognized = () => {
     const client = storageClient();
+    if (client[".core/login.encjson"]) {
+        client[LOGIN_RECOGNIZED_PATH] = client[".core/login.encjson"];
+        delete client[".core/login.encjson"];
+    }
     const login = client[LOGIN_RECOGNIZED_PATH];
     if (!login)
         throw new Error("No login found");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "license": "ISC",
   "repository": "KTibow/monoidentity",
   "author": {

package/dist/trackready.d.ts

@@ -1,3 +0,0 @@
-import { type Intent } from "./utils-transport.js";
-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>;