monoidentity 0.0.4 → 0.2.0

package/dist/Monoidentity.svelte

@@ -6,11 +6,82 @@
   let { app, scopes, children }: { app: string; scopes: Scope[]; children: Snippet } = $props();
 
   let ready = $state(false);
-  trackReady(app, scopes, () => (ready = true));
+  let backup: (() => void) | undefined = $state();
+  trackReady(
+    app,
+    scopes,
+    (callback) => {
+      backup = () => {
+        callback();
+        backup = undefined;
+      };
+    },
+    () => (ready = true),
+  );
 </script>
 
+{#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>
+{/snippet}
+
 {#if ready}
   {@render children()}
+  {#if backup}
+    <div class="backup toast">
+      {@render backupUI(backup, () => (backup = undefined))}
+    </div>
+  {/if}
+{:else if backup}
+  <div class="backup center">
+    {@render backupUI(backup, () => (backup = undefined))}
+  </div>
 {:else}
-  <p style:margin="auto">Setting up</p>
+  <p class="center">Setting up</p>
 {/if}
+
+<style>
+  .backup {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+
+    background-color: light-dark(#000, #fff);
+    color: light-dark(#fff, #000);
+    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;
+      }
+    }
+  }
+  .toast {
+    position: fixed;
+    right: 1rem;
+    top: 1rem;
+    z-index: 1000;
+  }
+  .center {
+    margin: auto;
+  }
+</style>

package/dist/_createstore.d.ts

@@ -0,0 +1,10 @@
+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>;
+};
+export declare const createStore: (implementation: ProxyHandlerWithoutTarget) => Dict;
+export {};

package/dist/_createstore.js

@@ -0,0 +1,9 @@
+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/_localstorage.d.ts

@@ -0,0 +1,3 @@
+import { type Dict } from "./_createstore.js";
+export declare const init: () => Dict;
+export declare const wrapWithBackup: (storage: Dict, requestBackup: (callback: () => void) => void) => Dict;

package/dist/_localstorage.js

@@ -0,0 +1,134 @@
+import { createStore } from "./_createstore.js";
+import { wrapWithReplay } from "./_replay.js";
+import { canBackup } from "./utils-callback.js";
+import { openDB } from "idb";
+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);
+};
+const get = (key) => {
+    if (typeof key != "string")
+        return undefined;
+    const value = localStorage.getItem(prefixed(key));
+    if (value == null)
+        return undefined;
+    return value;
+};
+export const init = () => createStore({
+    has(key) {
+        return typeof key == "string" && localStorage.getItem(prefixed(key)) !== null;
+    },
+    get,
+    set(key, value) {
+        if (typeof key == "string") {
+            localStorage.setItem(prefixed(key), value);
+            return true;
+        }
+        return false;
+    },
+    deleteProperty(key) {
+        if (typeof key == "string") {
+            localStorage.removeItem(prefixed(key));
+            return true;
+        }
+        return false;
+    },
+    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;
+    },
+});
+export const wrapWithBackup = (storage, requestBackup) => {
+    if (!canBackup)
+        return storage;
+    if (localStorage["monoidentity-x/backup"] == "off")
+        return storage;
+    const { proxy, flush, setTransmit, load } = wrapWithReplay(storage);
+    const getDir = async () => {
+        const db = await openDB("monoidentity-x");
+        const handle = (await db.get("handles", "backup"));
+        if (!handle)
+            throw new Error("No backup handle found");
+        return handle;
+    };
+    const setDir = async (dir) => {
+        const db = await openDB("monoidentity-x", 1, {
+            upgrade(db) {
+                db.createObjectStore("handles");
+            },
+        });
+        await db.put("handles", dir, "backup");
+    };
+    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, "");
+            await load(backup);
+            localStorage["monoidentity-x/backup"] = "on";
+        });
+    }
+    return proxy;
+};

package/dist/_replay.d.ts

@@ -0,0 +1,16 @@
+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): Promise<void>;
+};
+export {};

package/dist/_replay.js

@@ -0,0 +1,97 @@
+import { throttle } from "./utils-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(async (path) => {
+                const mod = modifications[path];
+                await tx(path, mod);
+            })
+                .map((task, i) => task
+                .then(() => {
+                const path = paths[i];
+                delete modifications[path];
+            })
+                .catch((err) => {
+                const path = paths[i];
+                console.warn("[monoidentity] transmit failed, will retry later", { path, 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
+        async load(external) {
+            modifications = {};
+            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/index.d.ts

@@ -1,3 +1,4 @@
 export { default as Monoidentity } from "./Monoidentity.svelte";
 export { getLogin, getStorage } from "./storage.js";
 export * from "./trackready.js";
+export { encode, decode } from "./utils-base36.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { default as Monoidentity } from "./Monoidentity.svelte";
 export { getLogin, getStorage } from "./storage.js";
 export * from "./trackready.js";
+export { encode, decode } from "./utils-base36.js";

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { type Login } from "./utils-login.js";
+import { type Login } from "./utils-base36.js";
 export declare const setup: (i: Record<string, string>, a: string) => void;
 export declare const getLogin: () => Login;
-export declare const getStorage: (realm: "cache") => Record<string, any>;
+export declare const getStorage: (realm: "cache") => import("./_createstore.js").Dict;

package/dist/storage.js

@@ -1,5 +1,6 @@
 import { stringify, parse } from "devalue";
-import { decode } from "./utils-login.js";
+import { decode } from "./utils-base36.js";
+import { createStore } from "./_createstore.js";
 let implementation;
 let app = "";
 export const setup = (i, a) => {
@@ -7,30 +8,30 @@ export const setup = (i, a) => {
     app = a;
 };
 export const getLogin = () => {
-    const storage = implementation;
-    if (!storage)
+    if (!implementation)
         throw new Error("No implementation set");
-    const login = storage[".core/login.encjson"];
+    const login = implementation[".core/login.encjson"];
     if (!login)
         throw new Error("No login found");
     return JSON.parse(decode(login));
 };
 export const getStorage = (realm) => {
     const prefix = (text) => `.${realm}/${app}/${text}`;
-    const storage = implementation;
     if (!app)
         throw new Error("No app set");
-    if (!storage)
-        throw new Error("No implementation set");
-    return new Proxy({}, {
-        get(_, key) {
-            const item = storage[prefix(key)];
+    return createStore({
+        get(key) {
+            if (!implementation)
+                throw new Error("No implementation set");
+            const item = implementation[prefix(key)];
             if (!item)
                 return undefined;
             return parse(item);
         },
-        set(_, key, value) {
-            storage[prefix(key)] = stringify(value);
+        set(key, value) {
+            if (!implementation)
+                throw new Error("No implementation set");
+            implementation[prefix(key)] = stringify(value);
             return true;
         },
     });

package/dist/trackready.d.ts

@@ -1,2 +1,2 @@
 import { type Scope } from "./utils-scope.js";
-export declare const trackReady: (app: string, scopes: Scope[], callback: () => void) => void;
+export declare const trackReady: (app: string, scopes: Scope[], requestBackup: (callback: () => void) => void, callback: () => void) => void;

package/dist/trackready.js

@@ -1,24 +1,20 @@
 import { rememberCallback } from "./utils-callback.js";
 import {} from "./utils-scope.js";
-import { init as initLocal } from "./storage-private-local.js";
+import { init as initLocal, wrapWithBackup } from "./_localstorage.js";
 import { setup } from "./storage.js";
-export const trackReady = (app, scopes, callback) => {
+export const trackReady = (app, scopes, requestBackup, callback) => {
     const params = new URLSearchParams(location.hash.slice(1));
     let memory = localStorage.monoidentityMemory
         ? JSON.parse(localStorage.monoidentityMemory)
         : undefined;
-    let createNew = false;
     let fileTasks = undefined;
     const paramCB = params.get("monoidentitycallback");
     if (paramCB) {
         history.replaceState(null, "", location.pathname);
         const cb = JSON.parse(paramCB);
-        console.log("got callback", cb); // todo remove
+        // console.debug("[monoidentity] callback", cb);
         memory = rememberCallback(cb, memory);
         localStorage.monoidentityMemory = JSON.stringify(memory);
-        if (cb.connect.method == "file" && cb.connect.createNew) {
-            createNew = true;
-        }
         fileTasks = cb.fileTasks;
     }
     if (!memory) {
@@ -34,19 +30,18 @@ export const trackReady = (app, scopes, callback) => {
         // TODO
         throw new Error("unimplemented");
     }
-    else if (memory.method == "file") {
-        // TODO (use createNew here)
-        throw new Error("unimplemented");
-    }
     else if (memory.method == "localStorage") {
         storage = initLocal();
+        storage = wrapWithBackup(storage, requestBackup);
     }
     else {
         throw new Error("unreachable");
     }
     setup(storage, app);
-    for (const file in fileTasks) {
-        storage[file] = fileTasks[file];
+    if (fileTasks) {
+        for (const file in fileTasks) {
+            storage[file] = fileTasks[file];
+        }
     }
     callback();
 };

package/dist/utils-callback.d.ts

@@ -1,23 +1,17 @@
-export declare const supportsFile: boolean;
 type Setup = {
     method: "cloud";
     jwt: string;
-} | {
-    method: "file";
-    createNew?: never;
 } | {
     method: "localStorage";
 };
-export type Memory = Setup & {
-    knownFiles: string[];
-};
+export type Memory = Setup;
 export type Callback = {
     scopes: string[];
     connect: Setup | {
-        method: "file";
-        createNew: boolean;
+        method: "localStorage";
     };
     fileTasks: Record<string, string> | undefined;
 };
+export declare const canBackup: boolean;
 export declare const rememberCallback: (data: Callback, pastMemory?: Memory) => Memory;
 export {};

package/dist/utils-callback.js

@@ -1,27 +1,7 @@
-export const supportsFile = "showSaveFilePicker" in window;
+export const canBackup = navigator.userAgent.includes("CrOS") && Boolean(window.showDirectoryPicker);
 export const rememberCallback = (data, pastMemory) => {
-    const { scopes, connect, fileTasks } = data;
-    const setup = connect.method == "cloud" ? { method: "cloud", jwt: connect.jwt } : { method: connect.method };
-    let knownFilesSet = new Set();
-    if (pastMemory) {
-        for (const file of pastMemory.knownFiles) {
-            knownFilesSet.add(file);
-        }
-    }
-    if (fileTasks) {
-        for (const file of Object.keys(fileTasks)) {
-            knownFilesSet.add(file);
-        }
-    }
-    if (scopes.includes("login-recognized")) {
-        const path = ".core/login.encjson";
-        if (connect.method == "cloud") {
-            knownFilesSet.add(path);
-        }
-        else if (!knownFilesSet.has(path)) {
-            console.warn("unexpected login deficit");
-        }
-    }
-    const knownFiles = Array.from(knownFilesSet);
-    return { ...setup, knownFiles };
+    const { connect } = data;
+    return connect.method == "cloud"
+        ? { method: "cloud", jwt: connect.jwt }
+        : { method: connect.method };
 };

package/dist/utils-timing.d.ts

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

package/dist/utils-timing.js

@@ -0,0 +1,21 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.0.4",
+  "version": "0.2.0",
   "repository": "KTibow/monoidentity",
   "author": {
     "name": "KTibow"
@@ -28,13 +28,15 @@
     "svelte": "^5.0.0"
   },
   "dependencies": {
-    "devalue": "^5.3.2"
+    "devalue": "^5.3.2",
+    "idb": "^8.0.3"
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.9",
     "@sveltejs/kit": "^2.22.0",
     "@sveltejs/package": "^2.0.0",
     "@sveltejs/vite-plugin-svelte": "^6.0.0",
+    "@types/wicg-file-system-access": "^2023.10.6",
     "publint": "^0.3.2",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",

package/dist/storage-private-local.d.ts

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

package/dist/storage-private-local.js

@@ -1,56 +0,0 @@
-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);
-};
-const target = {};
-const get = (_, key) => {
-    if (typeof key != "string")
-        return undefined;
-    const value = localStorage.getItem(prefixed(key));
-    if (value == null)
-        return undefined;
-    return value;
-};
-export const init = () => new Proxy(target, {
-    get,
-    set(_, key, value) {
-        if (typeof key == "string") {
-            localStorage.setItem(prefixed(key), value);
-            return true;
-        }
-        return false;
-    },
-    deleteProperty(_, key) {
-        if (typeof key == "string") {
-            localStorage.removeItem(prefixed(key));
-            return true;
-        }
-        return false;
-    },
-    has(_, key) {
-        return typeof key == "string" && localStorage.getItem(prefixed(key)) !== null;
-    },
-    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) {
-        if (typeof key == "string" && localStorage.getItem(prefixed(key)) !== null) {
-            return {
-                enumerable: true,
-                configurable: true,
-                value: get(target, key),
-            };
-        }
-        return undefined;
-    },
-});