monoidentity 0.10.2 → 0.11.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { getLoginRecognized, getVerification, useVerification, getStorage } from "./storage.js";
+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";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { getLoginRecognized, getVerification, useVerification, getStorage } from "./storage.js";
+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";

package/dist/storage/_replay.js

@@ -23,17 +23,14 @@ export const wrapWithReplay = (storage) => {
             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) {
-                    delete modifications[path];
                     return;
                 }
                 await tx(path, mod);
             })()
                 .catch((err) => {
                 console.warn(`[monoidentity] transmitting "${path}" failed`, err);
-            })
-                .finally(() => {
-                delete modifications[path];
             }));
             await Promise.all(tasks);
         }

package/dist/storage/createlocalstorage.js

@@ -13,24 +13,18 @@ export const createLocalStorage = () => createStore({
     get(key) {
         if (typeof key != "string")
             return undefined;
-        const value = localStorage[prefixed(key)];
-        if (value == null)
-            return undefined;
-        return value;
+        return localStorage[prefixed(key)];
     },
     set(key, value) {
-        if (typeof key == "string") {
-            localStorage[prefixed(key)] = value;
-            return true;
-        }
-        return false;
+        if (typeof key != "string")
+            return false;
+        localStorage[prefixed(key)] = value;
+        return true;
     },
     deleteProperty(key) {
-        if (typeof key == "string") {
-            delete localStorage[prefixed(key)];
-            return true;
-        }
-        return false;
+        if (typeof key != "string")
+            return false;
+        return delete localStorage[prefixed(key)];
     },
     ownKeys() {
         const keys = [];
@@ -42,4 +36,7 @@ export const createLocalStorage = () => createStore({
         }
         return keys;
     },
+    getOwnPropertyDescriptor(key) {
+        return Reflect.getOwnPropertyDescriptor(localStorage, prefixed(key));
+    },
 });

package/dist/storage/createstore.d.ts

@@ -5,6 +5,7 @@ type ProxyHandlerWithoutTarget = {
     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/wrapcloud.d.ts

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

package/dist/storage/wrapcloud.js

@@ -2,7 +2,7 @@ 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 = (storage, bucket) => {
+export const wrapCloud = async (storage, bucket) => {
     const client = new AwsClient({
         accessKeyId: bucket.accessKeyId,
         secretAccessKey: bucket.secretAccessKey,
@@ -10,43 +10,41 @@ export const wrapCloud = (storage, bucket) => {
     const { proxy, setTransmit, flush, load } = wrapWithReplay(storage);
     const isFirstLoad = !localStorage[CLOUD_CACHE_KEY];
     if (isFirstLoad) {
-        loadCloud(bucket.base, client).then((data) => {
-            load(data);
-            location.reload();
-        });
+        const data = await loadCloud(bucket.base, client);
+        load(data);
     }
-    else {
-        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`);
-                }
+    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 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`);
+            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);

package/dist/storage.d.ts

@@ -9,3 +9,4 @@ export declare const getVerification: () => Promise<string>;
 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>;

package/dist/storage.js

@@ -39,37 +39,90 @@ export const useVerification = async (jwt) => {
     const result = await verify(jwt, publicKey, { algorithm: "ES256", throwError: true });
     return result;
 };
-export const getStorage = (realm) => {
-    const prefix = (text) => {
-        if (!app)
-            throw new Error("No app set");
-        return `.${realm}/${app}/${text}.devalue`;
-    };
-    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) {
-            if (!implementation)
-                throw new Error("No implementation set");
-            implementation[prefix(key)] = stringify(value);
-            return true;
-        },
-        has(key) {
-            if (!implementation)
-                throw new Error("No implementation set");
-            return prefix(key) in implementation;
-        },
-        deleteProperty(key) {
-            if (!implementation)
-                throw new Error("No implementation set");
-            const k = prefix(key);
-            return delete implementation[k];
-        },
-    });
-};
+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));

package/dist/trackready.js

@@ -32,7 +32,7 @@ export const trackReady = async (app, intents, requestBackup) => {
     let storage;
     if (setup.method == "cloud") {
         storage = createLocalStorage();
-        storage = wrapCloud(storage, setup);
+        storage = await wrapCloud(storage, setup);
     }
     else if (setup.method == "localStorage") {
         storage = createLocalStorage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "repository": "KTibow/monoidentity",
   "author": {
     "name": "KTibow"