monoidentity 0.0.1

package/dist/Monoidentity.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  import type { Snippet } from "svelte";
+  import type { Scope } from "../../../src/lib.js";
+  import { trackReady } from "./trackready.js";
+
+  let { app, scopes, children }: { app: string; scopes: Scope[]; children: Snippet } = $props();
+
+  let ready = $state(false);
+  trackReady(app, scopes, () => (ready = true));
+</script>
+
+{#if ready}
+  {@render children()}
+{:else}
+  <p style:margin="auto">Setting up</p>
+{/if}

package/dist/Monoidentity.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from "svelte";
+import type { Scope } from "../../../src/lib.js";
+type $$ComponentProps = {
+    app: string;
+    scopes: Scope[];
+    children: Snippet;
+};
+declare const Monoidentity: import("svelte").Component<$$ComponentProps, {}, "">;
+type Monoidentity = ReturnType<typeof Monoidentity>;
+export default Monoidentity;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// Reexport your entry components here

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

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

package/dist/storage-private-local.js

@@ -0,0 +1,63 @@
+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 + 1);
+};
+const target = {};
+const get = (_, key) => {
+    if (typeof key == "string") {
+        const value = localStorage.getItem(prefixed(key));
+        if (value == null)
+            return undefined;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return undefined;
+};
+export const init = () => new Proxy(target, {
+    get,
+    set(_, key, value) {
+        if (typeof key == "string") {
+            const serialized = typeof value == "string" ? value : JSON.stringify(value);
+            localStorage.setItem(prefixed(key), serialized);
+            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;
+    },
+});

package/dist/storage.d.ts

@@ -0,0 +1,2 @@
+export declare const setup: (i: Record<string, string>, a: string) => void;
+export declare const getStorage: (realm: "cache") => Record<string, any>;

package/dist/storage.js

@@ -0,0 +1,27 @@
+import { stringify, parse } from "devalue";
+let implementation;
+let app = "";
+export const setup = (i, a) => {
+    implementation = i;
+    app = a;
+};
+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)];
+            if (!item)
+                return undefined;
+            return parse(item);
+        },
+        set(_, key, value) {
+            storage[prefix(key)] = stringify(value);
+            return true;
+        },
+    });
+};

package/dist/trackready.d.ts

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

package/dist/trackready.js

@@ -0,0 +1,39 @@
+import { rememberCallback } from "../../../src/lib.js";
+import { init as initLocal } from "./storage-private-local.js";
+import { setup } from "./storage.js";
+export const trackReady = (app, scopes, callback) => {
+    const params = new URLSearchParams(location.hash.slice(1));
+    let memory = localStorage.monoidentityMemory
+        ? JSON.parse(localStorage.monoidentityMemory)
+        : undefined;
+    let createNew = false;
+    const paramCB = params.get("monoidentitycallback");
+    if (paramCB) {
+        history.replaceState(null, "", location.pathname);
+        const cb = JSON.parse(paramCB);
+        console.log("got callback", cb); // todo remove
+        if (cb.connect.method == "file" && cb.connect.createNew) {
+            createNew = true;
+        }
+        memory = rememberCallback(cb, memory);
+        localStorage.monoidentityMemory = JSON.stringify(memory);
+    }
+    if (!memory) {
+        const params = new URLSearchParams();
+        params.set("app", app);
+        params.set("scopes", scopes.join(","));
+        params.set("redirectURI", location.origin);
+        location.href = `https://usemonoidentity.web.app/#${params.toString()}`;
+        return;
+    }
+    if (memory.method == "cloud") {
+        // TODO
+    }
+    else if (memory.method == "file") {
+        // TODO (use createNew here)
+    }
+    else if (memory.method == "localStorage") {
+        setup(initLocal(), app);
+    }
+    callback();
+};

package/dist/utils.d.ts

@@ -0,0 +1,31 @@
+export declare const scopeDefs: {
+    "login-recognized": {
+        files: string[];
+    };
+    storage: {
+        files: never[];
+    };
+};
+export type Scope = keyof typeof scopeDefs;
+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 Callback = {
+    connect: Setup | {
+        method: "file";
+        createNew: boolean;
+    };
+    fileTasks: Record<string, string> | undefined;
+};
+export declare const rememberCallback: (data: Callback, pastMemory?: Memory) => Memory;
+export {};

package/dist/utils.js

@@ -0,0 +1,26 @@
+export const scopeDefs = {
+    "login-recognized": {
+        files: [".config/login.encjson"],
+    },
+    storage: {
+        files: [],
+    },
+};
+export const supportsFile = "showSaveFilePicker" in window;
+export const rememberCallback = (data, pastMemory) => {
+    const { 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);
+        }
+    }
+    const knownFiles = Array.from(knownFilesSet);
+    return { ...setup, knownFiles };
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "monoidentity",
+  "version": "0.0.1",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "dependencies": {
+    "devalue": "^5.3.2"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-static": "^3.0.9",
+    "@sveltejs/kit": "^2.22.0",
+    "@sveltejs/package": "^2.0.0",
+    "@sveltejs/vite-plugin-svelte": "^6.0.0",
+    "publint": "^0.3.2",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vite": "^7.0.4"
+  },
+  "keywords": [
+    "svelte"
+  ],
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && pnpm run prepack",
+    "preview": "vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
+  }
+}