monoidentity 0.11.0 → 0.11.2

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

@@ -16,18 +16,15 @@ export const createLocalStorage = () => createStore({
         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 = [];

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/trackready.js

@@ -27,12 +27,15 @@ export const trackReady = async (app, intents, requestBackup) => {
             redirectURI: location.origin,
         });
         location.href = target.toString();
-        return;
+        await new Promise(() => {
+            /* never resolves */
+        });
+        throw new Error("unreachable");
     }
     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.11.0",
+  "version": "0.11.2",
   "repository": "KTibow/monoidentity",
   "author": {
     "name": "KTibow"