monoidentity 0.11.2 → 0.12.0

package/dist/+client.d.ts

@@ -0,0 +1,6 @@
+export * from "./+common.js";
+export { getLoginRecognized, getVerification, getStorage, getScopedFS } from "./storage.js";
+export { retrieveVerification } from "./verification-client.js";
+export { default as rawAttest } from "./verification/attest-remote.js";
+export { trackReady } from "./trackready.js";
+export { default as Monoidentity } from "./Monoidentity.svelte";

package/dist/+client.js

@@ -0,0 +1,6 @@
+export * from "./+common.js";
+export { getLoginRecognized, getVerification, getStorage, getScopedFS } from "./storage.js";
+export { retrieveVerification } from "./verification-client.js";
+export { default as rawAttest } from "./verification/attest-remote.js";
+export { trackReady } from "./trackready.js";
+export { default as Monoidentity } from "./Monoidentity.svelte";

package/dist/+common.d.ts

@@ -0,0 +1 @@
+export { encode, decode } from "./utils-base36.js";

package/dist/+common.js

@@ -0,0 +1 @@
+export { encode, decode } from "./utils-base36.js";

package/dist/+server.d.ts

@@ -0,0 +1,2 @@
+export * from "./+common.js";
+export { useVerification } from "./verification-server.js";

package/dist/+server.js

@@ -0,0 +1,2 @@
+export * from "./+common.js";
+export { useVerification } from "./verification-server.js";

package/dist/Monoidentity.svelte

@@ -19,10 +19,8 @@
 
 {#snippet backupUI(yes: () => void, no: () => void)}
   <p>Avoid reconfiguration with a backup folder.</p>
-  <div class="buttons">
-    <button class="primary" onclick={yes}>Connect</button>
-    <button onclick={no}>Skip</button>
-  </div>
+  <button onclick={no}>Skip</button>
+  <button class="primary" onclick={yes}>Connect</button>
 {/snippet}
 
 {#await ready}
@@ -40,32 +38,36 @@
   .backup {
     display: flex;
     flex-direction: column;
-    gap: 0.5rem;
-
-    background-color: light-dark(#000, #fff);
-    color: light-dark(#fff, #000);
+    gap: 0.25rem;
     line-height: 1;
-    padding: 0.75rem;
-    border-radius: 1.5rem;
 
-    > .buttons {
+    > * {
       display: flex;
-      gap: 0.5rem;
-      > button {
-        display: flex;
-        flex: 1;
-        align-items: center;
-        justify-content: center;
-        height: 2rem;
-        border-radius: 0.75rem;
-        &.primary {
-          background-color: light-dark(#fff, #000);
-          color: light-dark(#000, #fff);
-        }
-        border: none;
-        font: inherit;
-        cursor: pointer;
+      align-items: center;
+      justify-content: center;
+      height: 3rem;
+      margin: 0;
+      padding-inline: 0.5rem;
+      border-radius: 0.5rem;
+      border: none;
+      font: inherit;
+      &:first-child {
+        border-start-start-radius: 1.5rem;
+        border-start-end-radius: 1.5rem;
+      }
+      &:last-child {
+        border-end-start-radius: 1.5rem;
+        border-end-end-radius: 1.5rem;
       }
+      background-color: light-dark(#fff, #000);
+      color: light-dark(#000, #fff);
+    }
+    > button {
+      cursor: pointer;
+    }
+    > .primary {
+      background-color: light-dark(#000, #fff);
+      color: light-dark(#fff, #000);
     }
   }
   .toast {

package/dist/storage/backupcloud.d.ts

@@ -0,0 +1,2 @@
+import type { Bucket } from "../utils-bucket.js";
+export declare const backupCloud: (bucket: Bucket) => Promise<void>;

package/dist/storage/backupcloud.js

@@ -0,0 +1,107 @@
+import { AwsClient } from "aws4fetch";
+import { storageClient, STORAGE_EVENT } from "./storageclient.svelte.js";
+const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
+const isJunk = (key) => key.includes(".obsidian/") || key.includes(".cache/");
+const loadFromCloud = async (base, client) => {
+    const listResp = await client.fetch(base);
+    if (!listResp.ok)
+        throw new Error(`List bucket failed: ${listResp.status}`);
+    const listXml = await listResp.text();
+    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 }) => !isJunk(key));
+    const prevCache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
+    const nextCache = {};
+    const model = {};
+    await Promise.all(objects.map(async ({ key, etag }) => {
+        const cached = prevCache[key];
+        if (cached?.etag == etag) {
+            model[key] = cached.content;
+            nextCache[key] = cached;
+            return;
+        }
+        console.debug("[monoidentity cloud] loading", key);
+        const r = await client.fetch(`${base}/${key}`);
+        if (!r.ok)
+            throw new Error(`Fetch ${key} failed: ${r.status}`);
+        let content;
+        if (key.endsWith(".md") || key.endsWith(".devalue")) {
+            content = await r.text();
+        }
+        else {
+            const buf = new Uint8Array(await r.arrayBuffer());
+            content = "";
+            const chunk = 8192;
+            for (let i = 0; i < buf.length; i += chunk) {
+                content += String.fromCharCode.apply(null, buf.subarray(i, i + chunk));
+            }
+        }
+        model[key] = content;
+        nextCache[key] = { etag, content };
+    }));
+    localStorage[CLOUD_CACHE_KEY] = JSON.stringify(nextCache);
+    return model;
+};
+const syncFromCloud = async (bucket, client) => {
+    const remote = await loadFromCloud(bucket.base, client);
+    const local = storageClient();
+    for (const key of Object.keys(local)) {
+        if (!(key in remote)) {
+            delete local[key];
+        }
+    }
+    for (const [key, value] of Object.entries(remote)) {
+        local[key] = value;
+    }
+};
+export const backupCloud = async (bucket) => {
+    const client = new AwsClient({
+        accessKeyId: bucket.accessKeyId,
+        secretAccessKey: bucket.secretAccessKey,
+    });
+    await syncFromCloud(bucket, client);
+    setInterval(() => syncFromCloud(bucket, client), 15 * 60 * 1000);
+    // Continuous sync: mirror local changes to cloud
+    addEventListener(STORAGE_EVENT, async (event) => {
+        let key = event.detail.key;
+        if (!key.startsWith("monoidentity/"))
+            return;
+        key = key.slice("monoidentity/".length);
+        if (isJunk(key))
+            return;
+        console.debug("[monoidentity cloud] saving", key);
+        const url = `${bucket.base}/${key}`;
+        try {
+            if (event.detail.value != undefined) {
+                // PUT content (unconditional to start; you can add If-Match/If-None-Match for safety)
+                const r = await client.fetch(url, {
+                    method: "PUT",
+                    headers: { "content-type": "application/octet-stream" },
+                    body: event.detail.value,
+                });
+                if (!r.ok)
+                    throw new Error(`PUT ${key} failed: ${r.status}`);
+                // Update cache
+                const etag = r.headers.get("etag")?.replaceAll('"', "");
+                if (etag) {
+                    const cache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
+                    cache[key] = { etag, content: event.detail.value };
+                    localStorage[CLOUD_CACHE_KEY] = JSON.stringify(cache);
+                }
+            }
+            else {
+                // DELETE key
+                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);
+            }
+        }
+        catch (err) {
+            console.warn("[monoidentity cloud] sync failed", key, err);
+        }
+    });
+};

package/dist/storage/backuplocally.d.ts

@@ -0,0 +1 @@
+export declare const backupLocally: (requestBackup: (startBackup: () => void) => void) => Promise<void>;

package/dist/storage/backuplocally.js

@@ -0,0 +1,85 @@
+import { createStore, get, set } from "idb-keyval";
+import { STORAGE_EVENT, storageClient } from "./storageclient.svelte.js";
+import { canBackup } from "../utils-transport.js";
+const saveToDir = (dir) => {
+    let dirCache = {};
+    const getDirCached = async (route) => {
+        let key = "";
+        let parent = dir;
+        for (const path of route) {
+            key += "/";
+            key += path;
+            if (!dirCache[key]) {
+                dirCache[key] = await parent.getDirectoryHandle(path, { create: true });
+            }
+            parent = dirCache[key];
+        }
+        return parent;
+    };
+    addEventListener(STORAGE_EVENT, async (event) => {
+        let key = event.detail.key;
+        if (!key.startsWith("monoidentity/"))
+            return;
+        key = key.slice("monoidentity/".length);
+        const pathParts = key.split("/");
+        const name = pathParts.at(-1);
+        const value = event.detail.value;
+        console.debug("[monoidentity backup] saving", name);
+        const parent = await getDirCached(pathParts.slice(0, -1));
+        if (value != undefined) {
+            const file = await parent.getFileHandle(name, { create: true });
+            const writable = await file.createWritable();
+            await writable.write(value);
+            await writable.close();
+        }
+        else {
+            await parent.removeEntry(name);
+        }
+    });
+};
+export const backupLocally = async (requestBackup) => {
+    if (!canBackup)
+        return;
+    if (localStorage["monoidentity-x/backup"] == "off")
+        return;
+    const handles = createStore("monoidentity-x", "handles");
+    if (localStorage["monoidentity-x/backup"] == "on") {
+        const dir = await get("backup", handles);
+        if (!dir)
+            throw new Error("No backup handle found");
+        saveToDir(dir);
+    }
+    else {
+        localStorage["monoidentity-x/backup"] = "off";
+        requestBackup(async () => {
+            const dir = await showDirectoryPicker({ mode: "readwrite" });
+            await set("backup", dir, handles);
+            localStorage["monoidentity-x/backup"] = "on";
+            // Restore from backup
+            const backup = {};
+            const traverse = async (d, path) => {
+                for await (const entry of d.values()) {
+                    if (entry.kind == "file") {
+                        const file = await entry.getFile();
+                        const text = await file.text();
+                        backup[`${path}${entry.name}`] = text;
+                    }
+                    else if (entry.kind == "directory") {
+                        await traverse(entry, `${path}${entry.name}/`);
+                    }
+                }
+            };
+            await traverse(dir, "");
+            if (Object.keys(backup).length) {
+                const client = storageClient();
+                for (const key in backup) {
+                    console.debug("[monoidentity backup] loading", key);
+                    client[key] = backup[key];
+                }
+                location.reload();
+                return;
+            }
+            saveToDir(dir);
+        });
+    }
+};

package/dist/storage/storageclient.svelte.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface WindowEventMap {
+        "monoidentity-storage": CustomEvent<{
+            key: string;
+            value: string | undefined;
+        }>;
+    }
+}
+export declare const STORAGE_EVENT = "monoidentity-storage";
+export declare const storageClient: (prefix?: (key: string) => string, unprefix?: (key: string) => string | undefined, serialize?: (data: any) => string, deserialize?: (data: string) => any) => Record<string, any>;

package/dist/storage/storageclient.svelte.js

@@ -0,0 +1,69 @@
+export const STORAGE_EVENT = "monoidentity-storage";
+const announce = (key, value) => {
+    // Announce to all, even third parties
+    window.dispatchEvent(new CustomEvent(STORAGE_EVENT, { detail: { key, value } }));
+};
+const storageCounters = $state({});
+let allCounter = $state(0);
+const increment = (key) => {
+    storageCounters[key] = (storageCounters[key] || 0) + 1;
+    allCounter++;
+};
+addEventListener(STORAGE_EVENT, (event) => increment(event.detail.key));
+addEventListener("storage", (event) => {
+    if (event.storageArea != localStorage)
+        return;
+    if (!event.key)
+        return;
+    increment(event.key);
+});
+export const storageClient = (prefix, unprefix, serialize, deserialize) => {
+    if (prefix) {
+        const oldPrefix = prefix;
+        prefix = (key) => `monoidentity/${oldPrefix(key)}`;
+    }
+    else {
+        prefix = (key) => `monoidentity/${key}`;
+    }
+    return new Proxy({}, {
+        get(_, key) {
+            key = prefix(key);
+            storageCounters[key];
+            const raw = localStorage[key];
+            return raw && deserialize ? deserialize(raw) : raw;
+        },
+        set(_, key, value) {
+            key = prefix(key);
+            localStorage[key] = serialize ? serialize(value) : value;
+            announce(key, value);
+            return true;
+        },
+        deleteProperty(_, key) {
+            key = prefix(key);
+            delete localStorage[key];
+            announce(key);
+            return true;
+        },
+        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;
+        },
+        getOwnPropertyDescriptor(_, key) {
+            key = prefix(key);
+            return Reflect.getOwnPropertyDescriptor(localStorage, key);
+        },
+    });
+};

package/dist/storage.d.ts

@@ -1,12 +1,10 @@
-export declare const conf: (i: Record<string, string>, a: string) => void;
-export declare const LOGIN_RECOGNIZED_PATH = ".core/login.encjson";
+export declare const conf: (a: string) => void;
 export declare const getLoginRecognized: () => {
     email: string;
     password: string;
 };
-export declare const VERIFICATION_PATH = ".core/verification.jwt";
-export declare const getVerification: () => Promise<string>;
+export declare const setLoginRecognized: (login: string) => void;
+export declare const getVerification: () => Promise<any>;
 export declare const setVerification: (jwt: string) => void;
-export declare const useVerification: (jwt: string) => Promise<import("@tsndr/cloudflare-worker-jwt").JwtData<{}, {}>>;
 export declare const getStorage: (realm: "config" | "cache") => Record<string, any>;
-export declare const getScopedFS: (dir: string) => Record<string, string>;
+export declare const getScopedFS: (dir: string) => Record<string, any>;

package/dist/storage.js

@@ -1,128 +1,38 @@
 import { stringify, parse } from "devalue";
 import { parse as useSchema } from "valibot";
 import { decode } from "./utils-base36.js";
-import { createStore } from "./storage/createstore.js";
 import { login as loginSchema } from "./utils-transport.js";
 import { verify } from "@tsndr/cloudflare-worker-jwt";
 import publicKey from "./verification/public-key.js";
-let implementation;
-let app = "";
-export const conf = (i, a) => {
-    implementation = i;
+import { storageClient } from "./storage/storageclient.svelte.js";
+let app = "unknown";
+export const conf = (a) => {
     app = a;
 };
-export const LOGIN_RECOGNIZED_PATH = ".core/login.encjson";
+const LOGIN_RECOGNIZED_PATH = ".core/login.encjson";
 export const getLoginRecognized = () => {
-    if (!implementation)
-        throw new Error("No implementation set");
-    const login = implementation[LOGIN_RECOGNIZED_PATH];
+    const client = storageClient();
+    const login = client[LOGIN_RECOGNIZED_PATH];
     if (!login)
         throw new Error("No login found");
     return useSchema(loginSchema, JSON.parse(decode(login)));
 };
-export const VERIFICATION_PATH = ".core/verification.jwt";
+export const setLoginRecognized = (login) => {
+    const client = storageClient();
+    client[LOGIN_RECOGNIZED_PATH] = login;
+};
+const VERIFICATION_PATH = ".core/verification.jwt";
 export const getVerification = async () => {
-    if (!implementation)
-        throw new Error("No implementation set");
-    const jwt = implementation[VERIFICATION_PATH];
+    const client = storageClient();
+    const jwt = client[VERIFICATION_PATH];
     if (!jwt)
         throw new Error("No verification found");
     await verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
     return jwt;
 };
 export const setVerification = (jwt) => {
-    if (!implementation)
-        throw new Error("No implementation set");
-    implementation[VERIFICATION_PATH] = jwt;
-};
-export const useVerification = async (jwt) => {
-    const result = await verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
-    return result;
+    const client = storageClient();
+    client[VERIFICATION_PATH] = jwt;
 };
-const withPrefix = (obj, prefix, unprefix) => new Proxy(obj, {
-    get(target, prop) {
-        return target[prefix(prop)];
-    },
-    set(target, prop, value) {
-        target[prefix(prop)] = value;
-        return true;
-    },
-    has(target, prop) {
-        return prefix(prop) in target;
-    },
-    deleteProperty(target, prop) {
-        return delete target[prefix(prop)];
-    },
-    ownKeys(target) {
-        if (typeof unprefix != "function") {
-            throw new Error("unprefix must be a function");
-        }
-        return Object.keys(target)
-            .map((key) => unprefix(key))
-            .filter((key) => typeof key == "string");
-    },
-    getOwnPropertyDescriptor(target, prop) {
-        return Reflect.getOwnPropertyDescriptor(target, prefix(prop));
-    },
-});
-export const getStorage = (realm) => withPrefix(createStore({
-    get(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        const item = implementation[key];
-        return item ? parse(item) : undefined;
-    },
-    set(key, value) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        implementation[key] = stringify(value);
-        return true;
-    },
-    has(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return key in implementation;
-    },
-    deleteProperty(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return delete implementation[key];
-    },
-}), (text) => {
-    if (!app)
-        throw new Error("No app set");
-    return `.${realm}/${app}/${text}.devalue`;
-});
-export const getScopedFS = (dir) => withPrefix(createStore({
-    get(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return implementation[key];
-    },
-    set(key, value) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        implementation[key] = value;
-        return true;
-    },
-    has(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return key in implementation;
-    },
-    deleteProperty(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return delete implementation[key];
-    },
-    ownKeys() {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return Object.keys(implementation);
-    },
-    getOwnPropertyDescriptor(key) {
-        if (!implementation)
-            throw new Error("No implementation set");
-        return Reflect.getOwnPropertyDescriptor(implementation, key);
-    },
-}), (text) => `${dir}/${text}`, (text) => (text.startsWith(`${dir}/`) ? text.slice(dir.length + 1) : undefined));
+export const getStorage = (realm) => storageClient((key) => `.${realm}/${app}/${key}.devalue`, undefined, stringify, parse);
+export const getScopedFS = (dir) => storageClient((key) => `${dir}/${key}`, (key) => (key.startsWith(dir + "/") ? key.slice(dir.length + 1) : undefined));

package/dist/trackready.js

@@ -1,14 +1,17 @@
 import {} from "./utils-transport.js";
-import { createLocalStorage } from "./storage/createlocalstorage.js";
-import { wrapBackup } from "./storage/wrapbackup.js";
-import { wrapCloud } from "./storage/wrapcloud.js";
-import { LOGIN_RECOGNIZED_PATH, conf } from "./storage.js";
+// import { createLocalStorage } from "./storage/createlocalstorage.js";
+// import { wrapBackup } from "./storage/wrapbackup.js";
+// import { wrapCloud } from "./storage/wrapcloud.js";
+import { conf, setLoginRecognized } from "./storage.js";
+import { backupLocally } from "./storage/backuplocally.js";
+import { backupCloud } from "./storage/backupcloud.js";
 export const trackReady = async (app, intents, requestBackup) => {
-    const params = new URLSearchParams(location.hash.slice(1));
+    conf(app);
     let setup = localStorage["monoidentity-x/setup"]
         ? JSON.parse(localStorage["monoidentity-x/setup"])
         : undefined;
     let provisions = [];
+    const params = new URLSearchParams(location.hash.slice(1));
     const cb = params.get("monoidentitycallback");
     if (cb) {
         history.replaceState(null, "", location.pathname);
@@ -27,27 +30,17 @@ export const trackReady = async (app, intents, requestBackup) => {
             redirectURI: location.origin,
         });
         location.href = target.toString();
-        await new Promise(() => {
-            /* never resolves */
-        });
-        throw new Error("unreachable");
+        throw new Error("halt: redirecting");
     }
-    let storage;
-    if (setup.method == "cloud") {
-        storage = createLocalStorage();
-        storage = await wrapCloud(storage, setup);
-    }
-    else if (setup.method == "localStorage") {
-        storage = createLocalStorage();
-        storage = wrapBackup(storage, requestBackup);
+    if (setup.method == "localStorage") {
+        await backupLocally(requestBackup);
     }
-    else {
-        throw new Error("unreachable");
+    if (setup.method == "cloud") {
+        await backupCloud(setup);
     }
-    conf(storage, app);
     for (const provision of provisions) {
         if ("createLoginRecognized" in provision) {
-            storage[LOGIN_RECOGNIZED_PATH] = provision.createLoginRecognized;
+            setLoginRecognized(provision.createLoginRecognized);
         }
     }
 };

package/dist/verification-server.d.ts

@@ -0,0 +1 @@
+export declare const useVerification: (jwt: string) => Promise<import("@tsndr/cloudflare-worker-jwt").JwtData<{}, {}>>;

package/dist/verification-server.js

@@ -0,0 +1,6 @@
+import { verify } from "@tsndr/cloudflare-worker-jwt";
+import publicKey from "./verification/public-key.js";
+export const useVerification = async (jwt) => {
+    const result = await verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
+    return result;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "repository": "KTibow/monoidentity",
   "author": {
     "name": "KTibow"
@@ -15,16 +15,15 @@
   "sideEffects": [
     "**/*.css"
   ],
-  "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/+client.d.ts",
+      "svelte": "./dist/+client.js"
     },
-    "./Monoidentity.svelte": {
-      "types": "./dist/Monoidentity.svelte.d.ts",
-      "svelte": "./dist/Monoidentity.svelte"
+    "./server": {
+      "types": "./dist/+server.d.ts",
+      "import": "./dist/+server.js"
     }
   },
   "peerDependencies": {

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { getLoginRecognized, getVerification, useVerification, getStorage, getScopedFS, } from "./storage.js";
-export { retrieveVerification } from "./storage-attest.js";
-export { default as rawAttest } from "./verification/attest-remote.js";
-export { trackReady } from "./trackready.js";
-export { encode, decode } from "./utils-base36.js";

package/dist/index.js

@@ -1,5 +0,0 @@
-export { getLoginRecognized, getVerification, useVerification, getStorage, getScopedFS, } from "./storage.js";
-export { retrieveVerification } from "./storage-attest.js";
-export { default as rawAttest } from "./verification/attest-remote.js";
-export { trackReady } from "./trackready.js";
-export { encode, decode } from "./utils-base36.js";

package/dist/storage/_cloud.d.ts

@@ -1,3 +0,0 @@
-import type { AwsClient } from "aws4fetch";
-export declare const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
-export declare const loadCloud: (url: string, client: AwsClient) => Promise<Record<string, string>>;

package/dist/storage/_cloud.js

@@ -1,39 +0,0 @@
-const bytesToBinaryString = (bytes) => {
-    const chunkSize = 8192;
-    let result = "";
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-        const chunk = bytes.subarray(i, i + chunkSize);
-        result += String.fromCharCode.apply(null, chunk);
-    }
-    return result;
-};
-export const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
-export const loadCloud = async (url, client) => {
-    // List bucket (source of truth)
-    const listResponse = await client.fetch(url);
-    const listXml = await listResponse.text();
-    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 }) => !key.includes(".obsidian"));
-    // Build model by enriching list with content
-    const model = {};
-    const cache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
-    const newCache = {};
-    await Promise.all(objects.map(async ({ key, etag }) => {
-        // Cache hit: reuse existing content
-        if (cache[key]?.etag == etag) {
-            model[key] = cache[key].content;
-            newCache[key] = cache[key];
-            return;
-        }
-        // Cache miss: fetch from S3
-        const response = await client.fetch(`${url}/${key}`);
-        const buffer = await response.arrayBuffer();
-        const content = bytesToBinaryString(new Uint8Array(buffer));
-        model[key] = content;
-        newCache[key] = { etag, content };
-    }));
-    localStorage[CLOUD_CACHE_KEY] = JSON.stringify(newCache);
-    return model;
-};

package/dist/storage/_md5.d.ts

@@ -1 +0,0 @@
-export declare const md5: (s: string) => string;

package/dist/storage/_md5.js

@@ -1,52 +0,0 @@
-// Based on https://github.com/jbt/tiny-hashes/blob/master/md5/md5.js
-// @ts-nocheck
-var k = [], i = 0;
-for (; i < 64;) {
-    k[i] = 0 | (Math.sin(++i % Math.PI) * 4294967296);
-}
-export const md5 = (s) => {
-    for (let i = 0; i < s.length; i++) {
-        if (s.charCodeAt(i) > 255) {
-            // We weren't passed a binary string
-            console.log("?!");
-            s = new TextDecoder().decode(new TextEncoder().encode(s));
-            break;
-        }
-    }
-    var b, c, d, h = [(b = 0x67452301), (c = 0xefcdab89), ~b, ~c], words = [], j = s + "\x80", a = j.length;
-    s = (--a / 4 + 2) | 15;
-    // See "Length bits" in notes
-    words[--s] = a * 8;
-    for (; ~a;) {
-        // a !== -1
-        words[a >> 2] |= j.charCodeAt(a) << (8 * a--);
-    }
-    for (i = j = 0; i < s; i += 16) {
-        a = h;
-        for (; j < 64; a = [
-            (d = a[3]),
-            b +
-                (((d =
-                    a[0] +
-                        [(b & c) | (~b & d), (d & b) | (~d & c), b ^ c ^ d, c ^ (b | ~d)][(a = j >> 4)] +
-                        k[j] +
-                        ~~words[i | ([j, 5 * j + 1, 3 * j + 5, 7 * j][a] & 15)]) <<
-                    (a = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21][4 * a + (j++ % 4)])) |
-                    (d >>> -a)),
-            b,
-            c,
-        ]) {
-            b = a[1] | 0;
-            c = a[2];
-        }
-        // See "Integer safety" in notes
-        for (j = 4; j;)
-            h[--j] += a[j];
-        // j === 0
-    }
-    for (s = ""; j < 32;) {
-        s += ((h[j >> 3] >> ((1 ^ j++) * 4)) & 15).toString(16);
-        // s += ((h[j >> 3] >> (4 ^ 4 * j++)) & 15).toString(16);
-    }
-    return s;
-};

package/dist/storage/_replay.d.ts

@@ -1,16 +0,0 @@
-import type { Dict } from "./createstore.js";
-type Modification = {
-    type: "set";
-    old?: string;
-    new: string;
-} | {
-    type: "delete";
-};
-type Transmit = (path: string, mod: Modification) => Promise<void>;
-export declare const wrapWithReplay: (storage: Dict) => {
-    proxy: Dict;
-    flush: () => Promise<void>;
-    setTransmit(tx: Transmit): void;
-    load(external: Dict): void;
-};
-export {};

package/dist/storage/_replay.js

@@ -1,95 +0,0 @@
-import { throttle } from "./_timing.js";
-export const wrapWithReplay = (storage) => {
-    let modifications = {};
-    if (localStorage["monoidentity-x/backup/modifications"]) {
-        modifications = JSON.parse(localStorage["monoidentity-x/backup/modifications"]);
-    }
-    const save = () => {
-        if (Object.keys(modifications).length) {
-            localStorage["monoidentity-x/backup/modifications"] = JSON.stringify(modifications);
-        }
-        else {
-            delete localStorage["monoidentity-x/backup/modifications"];
-        }
-    };
-    window.addEventListener("beforeunload", save);
-    window.addEventListener("pagehide", save);
-    let transmit;
-    const flush = throttle(async () => {
-        try {
-            const tx = transmit;
-            if (!tx)
-                return;
-            const paths = Object.keys(modifications);
-            const tasks = paths.map((path) => (async () => {
-                const mod = modifications[path];
-                delete modifications[path];
-                if (mod.type == "set" && mod.old == mod.new) {
-                    return;
-                }
-                await tx(path, mod);
-            })()
-                .catch((err) => {
-                console.warn(`[monoidentity] transmitting "${path}" failed`, err);
-            }));
-            await Promise.all(tasks);
-        }
-        finally {
-            save();
-        }
-    }, 1000);
-    const proxy = new Proxy(storage, {
-        set(target, prop, value) {
-            let old = target[prop];
-            target[prop] = value;
-            const oldMod = modifications[prop];
-            if (oldMod?.type == "set")
-                old = oldMod.old;
-            modifications[prop] = { type: "set", old, new: value };
-            flush();
-            return true;
-        },
-        deleteProperty(target, prop) {
-            const success = delete target[prop];
-            if (success) {
-                modifications[prop] = { type: "delete" };
-                flush();
-            }
-            return success;
-        },
-    });
-    return {
-        proxy,
-        flush,
-        setTransmit(tx) {
-            transmit = tx;
-        },
-        // load() just resets to the external version
-        // if you have modifications, flush() them first
-        load(external) {
-            modifications = {};
-            save();
-            for (const [key, value] of Object.entries(external)) {
-                storage[key] = value;
-            }
-            for (const key of Object.keys(storage)) {
-                if (!(key in external)) {
-                    delete storage[key];
-                }
-            }
-            // // If for *some* reason, there are pending modifications, rebase and resend them
-            // for (const [key, mod] of Object.entries(oldModifications)) {
-            //   if (mod.type == "set") {
-            //     if (proxy[key] != mod.old)
-            //       console.warn(
-            //         `[monoidentity] modification to "${key}" will be force applied over external change`,
-            //       );
-            //     proxy[key] = mod.new;
-            //   } else if (mod.type == "delete") {
-            //     delete proxy[key];
-            //   }
-            // }
-            // flush();
-        },
-    };
-};

package/dist/storage/_timing.d.ts

@@ -1 +0,0 @@
-export declare function throttle(fn: () => Promise<unknown>, delay: number): () => Promise<void>;

package/dist/storage/_timing.js

@@ -1,21 +0,0 @@
-export function throttle(fn, delay) {
-    let isRunning = false;
-    let hasPendingCall = false;
-    return async () => {
-        hasPendingCall = true;
-        if (isRunning) {
-            return;
-        }
-        try {
-            isRunning = true;
-            while (hasPendingCall) {
-                hasPendingCall = false;
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                await fn();
-            }
-        }
-        finally {
-            isRunning = false;
-        }
-    };
-}

package/dist/storage/createlocalstorage.d.ts

@@ -1 +0,0 @@
-export declare const createLocalStorage: () => Record<string, string>;

package/dist/storage/createlocalstorage.js

@@ -1,42 +0,0 @@
-import { createStore } from "./createstore.js";
-const prefix = "monoidentity/";
-const prefixed = (key) => `${prefix}${key}`;
-const unprefixed = (key) => {
-    if (!key.startsWith(prefix))
-        throw new Error("Key is not prefixed");
-    return key.slice(prefix.length);
-};
-export const createLocalStorage = () => createStore({
-    has(key) {
-        return typeof key == "string" && localStorage[prefixed(key)] !== undefined;
-    },
-    get(key) {
-        if (typeof key != "string")
-            return undefined;
-        return localStorage[prefixed(key)];
-    },
-    set(key, value) {
-        if (typeof key != "string")
-            return false;
-        localStorage[prefixed(key)] = value;
-        return true;
-    },
-    deleteProperty(key) {
-        if (typeof key != "string")
-            return false;
-        return delete localStorage[prefixed(key)];
-    },
-    ownKeys() {
-        const keys = [];
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.startsWith(prefix)) {
-                keys.push(unprefixed(key));
-            }
-        }
-        return keys;
-    },
-    getOwnPropertyDescriptor(key) {
-        return Reflect.getOwnPropertyDescriptor(localStorage, prefixed(key));
-    },
-});

package/dist/storage/createstore.d.ts

@@ -1,11 +0,0 @@
-export type Dict = Record<string, string>;
-type ProxyHandlerWithoutTarget = {
-    has?(p: string | symbol): boolean;
-    get?(p: string | symbol, receiver: any): any;
-    set?(p: string | symbol, newValue: any, receiver: any): boolean;
-    deleteProperty?(p: string | symbol): boolean;
-    ownKeys?(): ArrayLike<string | symbol>;
-    getOwnPropertyDescriptor?(p: string | symbol): PropertyDescriptor | undefined;
-};
-export declare const createStore: <T>(implementation: ProxyHandlerWithoutTarget) => Record<string, T>;
-export {};

package/dist/storage/createstore.js

@@ -1,9 +0,0 @@
-export const createStore = (implementation) => {
-    const target = {};
-    const handler = {};
-    for (const key of Object.keys(implementation)) {
-        const trap = implementation[key];
-        handler[key] = (_, ...args) => trap(...args);
-    }
-    return new Proxy(target, handler);
-};

package/dist/storage/wrapbackup.d.ts

@@ -1,2 +0,0 @@
-import { type Dict } from "./createstore.js";
-export declare const wrapBackup: (storage: Dict, requestBackup: (startBackup: () => void) => void) => Dict;

package/dist/storage/wrapbackup.js

@@ -1,88 +0,0 @@
-import {} from "./createstore.js";
-import { wrapWithReplay } from "./_replay.js";
-import { canBackup } from "../utils-transport.js";
-import { get, set, createStore } from "idb-keyval";
-export const wrapBackup = (storage, requestBackup) => {
-    if (!canBackup)
-        return storage;
-    if (localStorage["monoidentity-x/backup"] == "off")
-        return storage;
-    const { proxy, flush, setTransmit, load } = wrapWithReplay(storage);
-    const store = createStore("monoidentity-x", "handles");
-    const getDir = async () => {
-        const handle = await get("backup", store);
-        if (!handle)
-            throw new Error("No backup handle found");
-        return handle;
-    };
-    const setDir = async (dir) => {
-        await set("backup", dir, store);
-    };
-    const init = async (dir) => {
-        let dirCache = {};
-        const getDirCached = async (route) => {
-            let key = "";
-            let parent = dir;
-            for (const path of route) {
-                key += "/";
-                key += path;
-                if (!dirCache[key]) {
-                    dirCache[key] = await parent.getDirectoryHandle(path, { create: true });
-                }
-                parent = dirCache[key];
-            }
-            return parent;
-        };
-        setTransmit(async (path, mod) => {
-            const pathParts = path.split("/");
-            const parent = await getDirCached(pathParts.slice(0, -1));
-            if (mod.type == "set") {
-                const file = await parent.getFileHandle(pathParts.at(-1), { create: true });
-                const writable = await file.createWritable();
-                await writable.write(mod.new);
-                await writable.close();
-            }
-            else if (mod.type == "delete") {
-                await parent.removeEntry(pathParts.at(-1));
-            }
-        });
-        await flush();
-    };
-    if (localStorage["monoidentity-x/backup"] == "on") {
-        getDir()
-            .then((dir) => init(dir))
-            .catch(() => {
-            delete localStorage["monoidentity-x/backup"];
-        });
-    }
-    else {
-        localStorage["monoidentity-x/backup"] = "off";
-        requestBackup(async () => {
-            const dir = await showDirectoryPicker({ mode: "readwrite" });
-            await setDir(dir);
-            await init(dir);
-            // Restore from backup
-            const backup = {};
-            const traverse = async (d, path) => {
-                for await (const entry of d.values()) {
-                    if (entry.kind == "file") {
-                        const file = await entry.getFile();
-                        const text = await file.text();
-                        backup[`${path}${entry.name}`] = text;
-                    }
-                    else if (entry.kind == "directory") {
-                        await traverse(entry, `${path}${entry.name}/`);
-                    }
-                }
-            };
-            await traverse(dir, "");
-            const hasBackup = Boolean(Object.keys(backup).length);
-            if (hasBackup)
-                load(backup);
-            localStorage["monoidentity-x/backup"] = "on";
-            if (hasBackup)
-                location.reload();
-        });
-    }
-    return proxy;
-};

package/dist/storage/wrapcloud.d.ts

@@ -1,3 +0,0 @@
-import type { Dict } from "./createstore.js";
-import type { Bucket } from "../utils-bucket.js";
-export declare const wrapCloud: (storage: Dict, bucket: Bucket) => Promise<Dict>;

package/dist/storage/wrapcloud.js

@@ -1,54 +0,0 @@
-import { wrapWithReplay } from "./_replay.js";
-import { AwsClient } from "aws4fetch";
-import { CLOUD_CACHE_KEY, loadCloud } from "./_cloud.js";
-import { md5 } from "./_md5.js";
-export const wrapCloud = async (storage, bucket) => {
-    const client = new AwsClient({
-        accessKeyId: bucket.accessKeyId,
-        secretAccessKey: bucket.secretAccessKey,
-    });
-    const { proxy, setTransmit, flush, load } = wrapWithReplay(storage);
-    const isFirstLoad = !localStorage[CLOUD_CACHE_KEY];
-    if (isFirstLoad) {
-        const data = await loadCloud(bucket.base, client);
-        load(data);
-    }
-    setTransmit(async (path, mod) => {
-        if (mod.type == "set") {
-            const url = `${bucket.base}/${path}`;
-            const headers = new Headers();
-            if (mod.old) {
-                // Update only if current matches our known prior content
-                const etagFromOld = md5(mod.old);
-                headers.set("If-Match", `"${etagFromOld}"`);
-            }
-            else {
-                // Create only if it does not already exist
-                headers.set("If-None-Match", "*");
-            }
-            const r = await client.fetch(url, {
-                method: "PUT",
-                headers,
-                body: mod.new,
-            });
-            if (!r.ok) {
-                throw new Error(`Cloud is ${r.status}ing`);
-            }
-        }
-        else if (mod.type == "delete") {
-            const url = `${bucket.base}/${path}`;
-            const r = await client.fetch(url, {
-                method: "DELETE",
-            });
-            if (!r.ok)
-                throw new Error(`Cloud is ${r.status}ing`);
-        }
-    });
-    if (!isFirstLoad) {
-        flush().then(async () => {
-            const data = await loadCloud(bucket.base, client);
-            load(data);
-        });
-    }
-    return proxy;
-};