@interncom/diplomatic 0.0.13 → 0.0.15

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { IOp, KeyPair } from "./shared/types";
-import type { IClientStateStore, DiplomaticClientState, Applier } from "./types";
+import type { IClientStateStore, Applier, IDiplomaticClientState } from "./types";
 import type { StateManager } from "./state";
 export interface IDiplomaticClientParams {
     store: IClientStateStore;
@@ -11,7 +11,7 @@ export interface IDiplomaticClientParams {
 export default class DiplomaticClient {
     store: IClientStateStore;
     applier: Applier;
-    listener?: (state: DiplomaticClientState) => void;
+    listener?: (state: IDiplomaticClientState) => void;
     seed?: Uint8Array;
     encKey?: Uint8Array;
     hostURL?: URL;
@@ -25,7 +25,8 @@ export default class DiplomaticClient {
     setSeed(seed: Uint8Array): Promise<void>;
     loadHost(): Promise<void>;
     register(hostURL: string): Promise<void>;
-    get state(): DiplomaticClientState;
+    emitUpdate(): Promise<void>;
+    getState(): Promise<IDiplomaticClientState>;
     processOps(): Promise<void>;
     pullOpPaths(): Promise<never[] | undefined>;
     fetchAndExecQueuedOps(): Promise<never[] | undefined>;

package/dist/idbStore.d.ts

@@ -15,10 +15,12 @@ declare class IDBStore implements IClientStateStore {
     dequeueUpload: (sha256: string) => Promise<void>;
     peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
     listUploads: () => Promise<string[]>;
+    numUploads: () => Promise<number>;
     downloadQueue: Set<string>;
     enqueueDownload: (path: string) => Promise<void>;
     dequeueDownload: (path: string) => Promise<void>;
     listDownloads: () => Promise<string[]>;
+    numDownloads: () => Promise<number>;
 }
 export declare const idbStore: IDBStore;
 export {};

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { useClientState } from "./useClient";
+import { useClientState, useSyncOnResume } from "./useClient";
 import { StateManager, useStateWatcher } from './state';
 import { localStorageStore } from "./localStorageStore";
 import { idbStore } from "./idbStore";
+import type { IDiplomaticClientState } from "./types";
 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 type { IOp, };
+export { useClientState, useSyncOnResume, StateManager, useStateWatcher, localStorageStore, idbStore, DiplomaticClient, libsodiumCrypto, btoh, htob, Verb, };
+export type { IOp, IDiplomaticClientState, };

package/dist/index.mjs

@@ -12,15 +12,32 @@ var __export = (target, all) => {
 
 // src/useClient.ts
 import { useState, useEffect } from "react";
-var initialState = "loading";
 function useClientState(client) {
-  const [state, setState] = useState(initialState);
+  const [state, setState] = useState();
   useEffect(() => {
-    setState(client.state);
-    client.listener = setState;
+    async function updateState() {
+      const state2 = await client.getState();
+      setState(state2);
+    }
+    client.listener = updateState;
+    updateState();
+    return () => {
+      client.listener = void 0;
+    };
   }, [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";
@@ -140,6 +157,9 @@ var LocalStorageStore = class {
   listUploads = async () => {
     return Array.from(this.uploadQueue.keys());
   };
+  numUploads = async () => {
+    return this.uploadQueue.size;
+  };
   downloadQueue = /* @__PURE__ */ new Set();
   enqueueDownload = async (path) => {
     this.downloadQueue.add(path);
@@ -150,6 +170,9 @@ var LocalStorageStore = class {
   listDownloads = async () => {
     return Array.from(this.downloadQueue.keys());
   };
+  numDownloads = async () => {
+    return this.downloadQueue.size;
+  };
 };
 var localStorageStore = new LocalStorageStore();
 
@@ -470,6 +493,10 @@ var IDBStore = class {
     const sha256s = await db.getAllKeys("uploadQueue");
     return sha256s;
   };
+  numUploads = async () => {
+    const db = await dbPromise;
+    return db.count("uploadQueue");
+  };
   downloadQueue = /* @__PURE__ */ new Set();
   enqueueDownload = async (path) => {
     const db = await dbPromise;
@@ -484,6 +511,10 @@ var IDBStore = class {
     const paths = await db.getAllKeys("downloadQueue");
     return paths;
   };
+  numDownloads = async () => {
+    const db = await dbPromise;
+    return db.count("downloadQueue");
+  };
 };
 var idbStore = new IDBStore();
 
@@ -8795,10 +8826,12 @@ var DiplomaticClient = class {
     this.websocket = new WebSocket(url);
     this.websocket.onopen = (e) => {
       console.log("CONNECTED");
+      this.emitUpdate();
     };
     this.websocket.onclose = (e) => {
       console.log("DISCONNECTED");
       this.connect(hostURL);
+      this.emitUpdate();
     };
     this.websocket.onmessage = (e) => {
       console.log(`RECEIVED: ${e.data}`);
@@ -8826,7 +8859,7 @@ var DiplomaticClient = class {
       await this.connect(this.hostURL);
     }
     await this.sync();
-    this.listener?.(this.state);
+    this.emitUpdate();
   }
   async loadSeed() {
     const seed = await this.store.getSeed();
@@ -8839,7 +8872,7 @@ var DiplomaticClient = class {
     this.seed = seed;
     this.encKey = await crypto_default.deriveXSalsa20Poly1305Key(seed);
     await this.store.setSeed(seed);
-    this.listener?.(this.state);
+    this.emitUpdate();
   }
   async loadHost() {
     if (!this.seed) {
@@ -8864,16 +8897,20 @@ var DiplomaticClient = class {
     await api_default.register(this.hostURL, this.hostKeyPair.publicKey, "tok123");
     await this.store.setHostURL(hostURL);
     await this.store.setHostID(hostID);
-    this.listener?.(this.state);
-  }
-  get state() {
-    if (!this.seed || !this.encKey) {
-      return "seedless";
-    }
-    if (!this.hostURL || !this.hostKeyPair) {
-      return "hostless";
-    }
-    return "ready";
+    this.emitUpdate();
+  }
+  async emitUpdate() {
+    const state = await this.getState();
+    this.listener?.(state);
+  }
+  async getState() {
+    return {
+      hasSeed: this.seed !== void 0 && this.encKey !== void 0,
+      hasHost: this.hostURL !== void 0 && this.hostKeyPair !== void 0,
+      connected: this.websocket?.readyState === WebSocket.OPEN,
+      numUploads: await this.store.numUploads(),
+      numDownloads: await this.store.numDownloads()
+    };
   }
   async processOps() {
     await this.pullOpPaths();
@@ -8889,6 +8926,7 @@ var DiplomaticClient = class {
     const paths = pathResp.paths;
     for (const path of paths) {
       await this.store.enqueueDownload(path);
+      this.emitUpdate();
     }
     this.lastFetchedAt = pathResp.fetchedAt;
   }
@@ -8906,10 +8944,12 @@ var DiplomaticClient = class {
       try {
         await this.applier(op);
         await this.store.dequeueDownload(path);
+        this.emitUpdate();
       } catch {
         const transient = true;
         if (!transient) {
           await this.store.dequeueDownload(path);
+          this.emitUpdate();
         }
       }
     }
@@ -8923,6 +8963,7 @@ var DiplomaticClient = class {
       await api_default.putDelta(this.hostURL, cipherOp, this.hostKeyPair);
     }
     await this.store.dequeueUpload(sha256);
+    this.emitUpdate();
   }
   async pushQueuedOps() {
     for (const sha256 of await this.store.listUploads()) {
@@ -8942,12 +8983,18 @@ var DiplomaticClient = class {
     const sha256 = await crypto_default.sha256Hash(cipherOp);
     const shaHex = btoh(sha256);
     await this.store.enqueueUpload(shaHex, cipherOp);
+    this.emitUpdate();
     try {
       await this.applier(op);
     } catch {
       await this.store.dequeueUpload(shaHex);
+      this.emitUpdate();
+    }
+    try {
+      await this.pushQueuedOp(shaHex);
+    } catch (err) {
+      console.info("failed to push");
     }
-    await this.pushQueuedOp(shaHex);
   }
   async upsert(type, body, version = 0) {
     const op = genUpsertOp(type, body, version);
@@ -8964,5 +9011,6 @@ export {
   crypto_default as libsodiumCrypto,
   localStorageStore,
   useClientState,
-  useStateWatcher
+  useStateWatcher,
+  useSyncOnResume
 };

package/dist/localStorageStore.d.ts

@@ -12,10 +12,12 @@ declare class LocalStorageStore implements IClientStateStore {
     dequeueUpload: (sha256: string) => Promise<void>;
     peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
     listUploads: () => Promise<string[]>;
+    numUploads: () => Promise<number>;
     downloadQueue: Set<string>;
     enqueueDownload: (path: string) => Promise<void>;
     dequeueDownload: (path: string) => Promise<void>;
     listDownloads: () => Promise<string[]>;
+    numDownloads: () => Promise<number>;
 }
 export declare const localStorageStore: LocalStorageStore;
 export {};

package/dist/memoryStore.d.ts

@@ -15,10 +15,12 @@ declare class MemoryStore implements IClientStateStore {
     dequeueUpload: (sha256: string) => Promise<void>;
     peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
     listUploads: () => Promise<string[]>;
+    numUploads: () => Promise<number>;
     downloadQueue: Set<string>;
     enqueueDownload: (path: string) => Promise<void>;
     dequeueDownload: (path: string) => Promise<void>;
     listDownloads: () => Promise<string[]>;
+    numDownloads: () => Promise<number>;
 }
 export declare const memoryStore: MemoryStore;
 export {};

package/dist/types.d.ts

@@ -11,9 +11,17 @@ export interface IClientStateStore {
     dequeueUpload: (sha256: string) => Promise<void>;
     peekUpload: (sha256: string) => Promise<Uint8Array | undefined>;
     listUploads: () => Promise<string[]>;
+    numUploads: () => Promise<number>;
     enqueueDownload: (path: string) => Promise<void>;
     dequeueDownload: (path: string) => Promise<void>;
     listDownloads: () => Promise<string[]>;
+    numDownloads: () => Promise<number>;
+}
+export interface IDiplomaticClientState {
+    hasSeed: boolean;
+    hasHost: boolean;
+    connected: boolean;
+    numUploads: number;
+    numDownloads: number;
 }
-export type DiplomaticClientState = "loading" | "seedless" | "hostless" | "ready";
 export type Applier = (op: IOp) => Promise<void>;

package/dist/useClient.d.ts

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

package/package.json

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