monoidentity 0.13.1 → 0.14.0

package/dist/Monoidentity.svelte

@@ -3,12 +3,23 @@
   import { trackReady } from "./trackready.js";
   import type { Intent } from "./utils-transport.js";
 
-  let { app, intents, children }: { app: string; intents?: Intent[]; children: Snippet } = $props();
+  let {
+    app,
+    intents,
+    shouldBackup,
+    children,
+  }: {
+    app: string;
+    intents?: Intent[];
+    shouldBackup: (path: string) => boolean;
+    children: Snippet;
+  } = $props();
 
   let backup: (() => void) | undefined = $state();
   const ready = trackReady(
     app,
     intents || [],
+    shouldBackup,
     (startBackup) =>
       (backup = () => {
         startBackup();

package/dist/Monoidentity.svelte.d.ts

@@ -3,6 +3,7 @@ import type { Intent } from "./utils-transport.js";
 type $$ComponentProps = {
     app: string;
     intents?: Intent[];
+    shouldBackup: (path: string) => boolean;
     children: Snippet;
 };
 declare const Monoidentity: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/storage/_should.d.ts

@@ -0,0 +1 @@
+export declare const shouldPersist: (key: string) => boolean;

package/dist/storage/_should.js

@@ -0,0 +1 @@
+export const shouldPersist = (key) => key.includes(".cache/");

package/dist/storage/backupcloud.d.ts

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

package/dist/storage/backupcloud.js

@@ -1,11 +1,10 @@
 import { AwsClient } from "aws4fetch";
 import { storageClient, STORAGE_EVENT } from "./storageclient.svelte.js";
 import { addToSync } from "../storage.js";
+import { shouldPersist } from "./_should.js";
 const CLOUD_CACHE_KEY = "monoidentity-x/cloud-cache";
-const isJunk = (key) => key.includes(".obsidian/") || key.includes(".cache/");
-const keepAnyway = (key) => key.includes(".cache/");
 let unmount;
-const loadFromCloud = async (base, client) => {
+const loadFromCloud = async (shouldBackup, base, client) => {
     const listResp = await client.fetch(base);
     if (!listResp.ok)
         throw new Error(`List bucket failed: ${listResp.status}`);
@@ -13,7 +12,7 @@ const loadFromCloud = async (base, client) => {
     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));
+        .filter(({ key }) => shouldBackup(key));
     const prevCache = JSON.parse(localStorage[CLOUD_CACHE_KEY] || "{}");
     const nextCache = {};
     const model = {};
@@ -46,13 +45,13 @@ const loadFromCloud = async (base, client) => {
     localStorage[CLOUD_CACHE_KEY] = JSON.stringify(nextCache);
     return model;
 };
-const syncFromCloud = async (bucket, client) => {
-    const remote = await loadFromCloud(bucket.base, client);
+const syncFromCloud = async (shouldBackup, bucket, client) => {
+    const remote = await loadFromCloud(shouldBackup, bucket.base, client);
     const local = storageClient();
     for (const key of Object.keys(local)) {
         if (key in remote)
             continue;
-        if (keepAnyway(key))
+        if (shouldPersist(key))
             continue;
         delete local[key];
     }
@@ -60,16 +59,22 @@ const syncFromCloud = async (bucket, client) => {
         local[key] = value;
     }
 };
-export const backupCloud = async (bucket) => {
+export const backupCloud = async (shouldBackup, bucket) => {
     unmount?.();
     const client = new AwsClient({
         accessKeyId: bucket.accessKeyId,
         secretAccessKey: bucket.secretAccessKey,
     });
-    await syncFromCloud(bucket, client);
-    const syncIntervalId = setInterval(() => syncFromCloud(bucket, client), 15 * 60 * 1000);
+    await syncFromCloud(shouldBackup, bucket, client);
+    const syncIntervalId = setInterval(() => syncFromCloud(shouldBackup, bucket, client), 15 * 60 * 1000);
     // Continuous sync: mirror local changes to cloud
     const write = async (key, value) => {
+        if (!shouldBackup(key)) {
+            if (!shouldPersist(key))
+                console.warn("[monoidentity cloud]", key, "isn't marked to be backed up or saved");
+            return;
+        }
+        console.debug("[monoidentity cloud] saving", key);
         const url = `${bucket.base}/${key}`;
         if (value != undefined) {
             // PUT content (unconditional to start; you can add If-Match/If-None-Match for safety)
@@ -103,9 +108,6 @@ export const backupCloud = async (bucket) => {
         if (!key.startsWith("monoidentity/"))
             return;
         key = key.slice("monoidentity/".length);
-        if (isJunk(key))
-            return;
-        console.debug("[monoidentity cloud] saving", key);
         const promise = write(key, event.detail.value).catch((err) => {
             console.warn("[monoidentity cloud] save failed", key, err);
         });

package/dist/storage/backuplocally.d.ts

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

package/dist/storage/backuplocally.js

@@ -1,8 +1,9 @@
 import { createStore, get, set } from "idb-keyval";
 import { STORAGE_EVENT, storageClient } from "./storageclient.svelte.js";
 import { canBackup } from "../utils-transport.js";
+import { shouldPersist } from "./_should.js";
 let unmount;
-const saveToDir = (dir) => {
+const saveToDir = (shouldBackup, dir) => {
     let dirCache = {};
     const getDirCached = async (route) => {
         let key = "";
@@ -25,6 +26,11 @@ const saveToDir = (dir) => {
         const pathParts = key.split("/");
         const name = pathParts.at(-1);
         const value = event.detail.value;
+        if (!shouldBackup(key)) {
+            if (!shouldPersist(key))
+                console.warn("[monoidentity backup]", key, "isn't marked to be backed up or saved");
+            return;
+        }
         console.debug("[monoidentity backup] saving", name);
         const parent = await getDirCached(pathParts.slice(0, -1));
         if (value != undefined) {
@@ -42,7 +48,7 @@ const saveToDir = (dir) => {
         removeEventListener(STORAGE_EVENT, listener);
     };
 };
-export const backupLocally = async (requestBackup) => {
+export const backupLocally = async (shouldBackup, requestBackup) => {
     if (!canBackup)
         return;
     if (localStorage["monoidentity-x/backup"] == "off")
@@ -53,7 +59,7 @@ export const backupLocally = async (requestBackup) => {
         const dir = await get("backup", handles);
         if (!dir)
             throw new Error("No backup handle found");
-        unmount = saveToDir(dir);
+        unmount = saveToDir(shouldBackup, dir);
     }
     else {
         localStorage["monoidentity-x/backup"] = "off";
@@ -85,7 +91,7 @@ export const backupLocally = async (requestBackup) => {
                 location.reload();
                 return;
             }
-            unmount = saveToDir(dir);
+            unmount = saveToDir(shouldBackup, dir);
         });
     }
 };

package/dist/trackready.d.ts

@@ -1,2 +1,2 @@
 import { type Intent } from "./utils-transport.js";
-export declare const trackReady: (app: string, intents: Intent[], requestBackup: (startBackup: () => void) => void) => Promise<void>;
+export declare const trackReady: (app: string, intents: Intent[], shouldBackup: (path: string) => boolean, requestBackup: (startBackup: () => void) => void) => Promise<void>;

package/dist/trackready.js

@@ -5,7 +5,7 @@ import {} from "./utils-transport.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) => {
+export const trackReady = async (app, intents, shouldBackup, requestBackup) => {
     conf(app);
     let setup = localStorage["monoidentity-x/setup"]
         ? JSON.parse(localStorage["monoidentity-x/setup"])
@@ -33,10 +33,10 @@ export const trackReady = async (app, intents, requestBackup) => {
         throw new Error("halt: redirecting");
     }
     if (setup.method == "localStorage") {
-        await backupLocally(requestBackup);
+        await backupLocally(shouldBackup, requestBackup);
     }
     if (setup.method == "cloud") {
-        await backupCloud(setup);
+        await backupCloud(shouldBackup, setup);
     }
     for (const provision of provisions) {
         if ("createLoginRecognized" in provision) {

package/package.json

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