@interncom/diplomatic 0.0.12 → 0.0.14

package/dist/idbStore.d.ts

@@ -3,6 +3,7 @@ declare class IDBStore implements IClientStateStore {
     seed?: Uint8Array;
     hostURL?: string;
     hostID?: string;
+    wipe(): Promise<void>;
     getSeed(): Promise<Uint8Array | undefined>;
     setSeed(seed: Uint8Array): Promise<void>;
     getHostURL(): Promise<string | undefined>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { useClientState } from "./useClient";
+import { useClientState, useSyncOnResume } from "./useClient";
 import { StateManager, useStateWatcher } from './state';
 import { localStorageStore } from "./localStorageStore";
 import { idbStore } from "./idbStore";
@@ -6,5 +6,5 @@ import DiplomaticClient from "./client";
 import libsodiumCrypto from "./crypto";
 import { btoh, htob } from "./shared/lib";
 import { type IOp, Verb } from "./shared/types";
-export { useClientState, StateManager, useStateWatcher, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, };
+export { useClientState, useSyncOnResume, StateManager, useStateWatcher, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, };
 export type { IOp, };

package/dist/index.mjs

@@ -21,6 +21,17 @@ function useClientState(client) {
   }, [client]);
   return state;
 }
+function useSyncOnResume(client) {
+  useEffect(() => {
+    function handleOnline() {
+      client.sync();
+    }
+    window.addEventListener("online", handleOnline);
+    return () => {
+      window.removeEventListener("online", handleOnline);
+    };
+  }, [client]);
+}
 
 // src/state.ts
 import { useEffect as useEffect2, useState as useState2 } from "react";
@@ -101,6 +112,9 @@ var seedKey = "seedHex";
 var hostURLKey = "hostURL";
 var hostIDKey = "hostID";
 var LocalStorageStore = class {
+  async wipe() {
+    localStorage.clear();
+  }
   async getSeed() {
     const storedSeed = localStorage.getItem(seedKey);
     if (storedSeed) {
@@ -300,6 +314,17 @@ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {})
   });
   return openPromise;
 }
+function deleteDB(name, { blocked } = {}) {
+  const request = indexedDB.deleteDatabase(name);
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event
+    ));
+  }
+  return wrap(request).then(() => void 0);
+}
 var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
 var writeMethods = ["put", "add", "delete", "clear"];
 var cachedMethods = /* @__PURE__ */ new Map();
@@ -389,14 +414,24 @@ replaceTraps((oldTraps) => ({
 var dbPromise = openDB("client-store-db", 1, {
   upgrade(db) {
     db.createObjectStore("metaKV");
+    db.createObjectStore("uploadQueue", {
+      keyPath: "sha256"
+    });
+    db.createObjectStore("downloadQueue", {
+      keyPath: "path"
+    });
   }
 });
 var IDBStore = class {
   seed;
   hostURL;
   hostID;
+  async wipe() {
+    await deleteDB("client-store-db");
+  }
   async getSeed() {
-    const hex = await (await dbPromise).get("metaKV", "seed");
+    const db = await dbPromise;
+    const hex = await db.get("metaKV", "seed");
     if (!hex) {
       return;
     }
@@ -405,45 +440,60 @@ var IDBStore = class {
   }
   async setSeed(seed) {
     const hex = btoh(seed);
-    (await dbPromise).put("metaKV", hex, "seed");
+    const db = await dbPromise;
+    await db.put("metaKV", hex, "seed");
     this.seed = seed;
   }
   async getHostURL() {
-    const url = await (await dbPromise).get("metaKV", "hostURL");
+    const db = await dbPromise;
+    const url = await db.get("metaKV", "hostURL");
     return url;
   }
   async setHostURL(url) {
-    (await dbPromise).put("metaKV", url, "hostURL");
+    const db = await dbPromise;
+    db.put("metaKV", url, "hostURL");
   }
   async getHostID() {
-    const id = await (await dbPromise).get("metaKV", "hostID");
+    const db = await dbPromise;
+    const id = await db.get("metaKV", "hostID");
     return id;
   }
   async setHostID(id) {
-    (await dbPromise).put("metaKV", id, "hostID");
+    const db = await dbPromise;
+    await db.put("metaKV", id, "hostID");
   }
   uploadQueue = /* @__PURE__ */ new Map();
   enqueueUpload = async (sha256, cipherOp) => {
-    this.uploadQueue.set(sha256, cipherOp);
+    const db = await dbPromise;
+    await db.put("uploadQueue", { sha256, cipherOp });
   };
   dequeueUpload = async (sha256) => {
-    this.uploadQueue.delete(sha256);
+    const db = await dbPromise;
+    await db.delete("uploadQueue", sha256);
   };
   peekUpload = async (sha256) => {
-    return this.uploadQueue.get(sha256);
+    const db = await dbPromise;
+    const row = await db.get("uploadQueue", sha256);
+    return row?.cipherOp;
   };
   listUploads = async () => {
-    return Array.from(this.uploadQueue.keys());
+    const db = await dbPromise;
+    const sha256s = await db.getAllKeys("uploadQueue");
+    return sha256s;
   };
   downloadQueue = /* @__PURE__ */ new Set();
   enqueueDownload = async (path) => {
-    this.downloadQueue.add(path);
+    const db = await dbPromise;
+    await db.put("downloadQueue", { path });
   };
   dequeueDownload = async (path) => {
-    this.downloadQueue.delete(path);
+    const db = await dbPromise;
+    await db.delete("downloadQueue", path);
   };
   listDownloads = async () => {
-    return Array.from(this.downloadQueue.keys());
+    const db = await dbPromise;
+    const paths = await db.getAllKeys("downloadQueue");
+    return paths;
   };
 };
 var idbStore = new IDBStore();
@@ -8770,7 +8820,6 @@ var DiplomaticClient = class {
     };
   };
   async init(params) {
-    await this.store.init?.();
     if (params.seed) {
       const bytes = typeof params.seed === "string" ? htob(params.seed) : params.seed;
       await this.store.setSeed(bytes);
@@ -8926,5 +8975,6 @@ export {
   crypto_default as libsodiumCrypto,
   localStorageStore,
   useClientState,
-  useStateWatcher
+  useStateWatcher,
+  useSyncOnResume
 };

package/dist/localStorageStore.d.ts

@@ -1,5 +1,6 @@
 import type { IClientStateStore } from "./types";
 declare class LocalStorageStore implements IClientStateStore {
+    wipe(): Promise<void>;
     getSeed(): Promise<Uint8Array | undefined>;
     setSeed(seed: Uint8Array): Promise<void>;
     getHostURL(): Promise<string | undefined>;

package/dist/memoryStore.d.ts

@@ -3,6 +3,7 @@ declare class MemoryStore implements IClientStateStore {
     seed?: Uint8Array;
     hostURL?: string;
     hostID?: string;
+    wipe(): Promise<void>;
     getSeed(): Promise<Uint8Array | undefined>;
     setSeed(seed: Uint8Array): Promise<void>;
     getHostURL(): Promise<string | undefined>;

package/dist/types.d.ts

@@ -1,12 +1,12 @@
 import type { IOp } from "./shared/types";
 export interface IClientStateStore {
-    init?: () => Promise<void>;
     getSeed: () => Promise<Uint8Array | undefined>;
     setSeed: (seed: Uint8Array) => Promise<void>;
     getHostURL: () => Promise<string | undefined>;
     setHostURL: (url: string) => Promise<void>;
     getHostID: () => Promise<string | undefined>;
     setHostID: (id: string) => Promise<void>;
+    wipe: () => Promise<void>;
     enqueueUpload: (sha256: string, cipherOp: Uint8Array) => Promise<void>;
     dequeueUpload: (sha256: string) => Promise<void>;
     peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;

package/dist/useClient.d.ts

@@ -1,3 +1,4 @@
 import type { DiplomaticClientState } from "./types";
 import type DiplomaticClient from "./client";
 export declare function useClientState(client: DiplomaticClient): DiplomaticClientState;
+export declare function useSyncOnResume(client: DiplomaticClient): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "description": "Secure sync layer",
   "main": "dist/index.mjs",