@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/P2PReplicatorCore.js

@@ -0,0 +1,126 @@
+import { AutoAccepting, REMOTE_P2P } from "../../common/types.js";
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
+import { EVENT_REQUEST_OPEN_P2P } from "../../events/coreEvents.js";
+import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import { Logger, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "../../common/logger.js";
+import { P2PLogCollector } from "./P2PLogCollector.js";
+import { addP2PEventHandlers } from "./addP2PEventHandlers.js";
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
+function useP2PReplicator(host, viewTypeAndFactory) {
+  const env = { services: host.services };
+  let replicator = new LiveSyncTrysteroReplicator(env);
+  const activeReplicator = {
+    get instance() {
+      return replicator;
+    }
+  };
+  const events = host.services.context.events;
+  addP2PEventHandlers(activeReplicator.instance, events);
+  const p2pLogCollector = new P2PLogCollector(events);
+  const storeP2PStatusLine = reactiveSource("");
+  p2pLogCollector.p2pReplicationLine.onChanged((line) => {
+    storeP2PStatusLine.value = line.value;
+  });
+  host.services.appLifecycle.onResumed.addHandler(() => {
+    const settings = host.services.setting.currentSettings();
+    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
+      compatGlobal.setTimeout(() => void replicator.open(), 100);
+    }
+    return Promise.resolve(true);
+  });
+  host.services.appLifecycle.onUnload.addHandler(async () => {
+    await replicator.close();
+    return true;
+  });
+  host.services.appLifecycle.onSuspending.addHandler(async () => {
+    await replicator.close();
+    return true;
+  });
+  host.services.databaseEvents.onDatabaseInitialisation.addHandler(async () => {
+    await replicator.close();
+    return true;
+  });
+  host.services.setting.suspendExtraSync.addHandler(() => {
+    const s = host.services.setting.currentSettings();
+    if (s.remoteType !== REMOTE_P2P) {
+      s.P2P_Enabled = false;
+    }
+    s.P2P_AutoAccepting = AutoAccepting.NONE;
+    s.P2P_AutoBroadcast = false;
+    s.P2P_AutoStart = false;
+    s.P2P_AutoSyncPeers = "";
+    s.P2P_AutoWatchPeers = "";
+    return Promise.resolve(true);
+  });
+  host.services.replicator.getNewReplicator.addHandler(
+    async (settingOverride = {}) => {
+      const settings = { ...host.services.setting.currentSettings(), ...settingOverride };
+      if (settings.remoteType == REMOTE_P2P) {
+        try {
+          await replicator.close();
+        } catch (e) {
+          Logger(`Error closing existing p2p replicator`);
+          Logger(e, LOG_LEVEL_VERBOSE);
+        }
+        const newReplicator = new LiveSyncTrysteroReplicator({ services: host.services });
+        replicator = newReplicator;
+        return Promise.resolve(replicator);
+      }
+      return void 0;
+    }
+  );
+  if (viewTypeAndFactory) {
+    const [viewType, factory] = viewTypeAndFactory;
+    const openPane = () => host.services.API.showWindow(viewType);
+    host.services.appLifecycle.onInitialise.addHandler(() => {
+      host.services.API.registerWindow(viewType, factory);
+      events.onEvent(EVENT_REQUEST_OPEN_P2P, () => {
+        void openPane();
+      });
+      host.services.API.addCommand({
+        id: "open-p2p-replicator",
+        name: "P2P Sync : Open P2P Replicator",
+        callback: () => {
+          void openPane();
+        }
+      });
+      host.services.API.addCommand({
+        id: "p2p-establish-connection",
+        name: "P2P Sync : Connect to the Signalling Server",
+        checkCallback: (isChecking) => {
+          if (isChecking) return !(replicator.server?.isServing ?? false);
+          void replicator.open();
+        }
+      });
+      host.services.API.addCommand({
+        id: "p2p-close-connection",
+        name: "P2P Sync : Disconnect from the Signalling Server",
+        checkCallback: (isChecking) => {
+          if (isChecking) return replicator.server?.isServing ?? false;
+          Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);
+          void replicator.close();
+        }
+      });
+      host.services.API.addCommand({
+        id: "replicate-now-by-p2p",
+        name: "Replicate now by P2P",
+        checkCallback: (isChecking) => {
+          const settings = host.services.setting.currentSettings();
+          if (isChecking) {
+            if (settings.remoteType == REMOTE_P2P) return false;
+            return replicator.server?.isServing ?? false;
+          }
+          void replicator.replicateFromCommand(false);
+        }
+      });
+      host.services.API.addRibbonIcon("waypoints", "P2P Replicator", () => {
+        void openPane();
+      })?.classList.add("livesync-ribbon-replicate-p2p");
+      return Promise.resolve(true);
+    });
+  }
+  return { replicator, p2pLogCollector, storeP2PStatusLine };
+}
+export {
+  useP2PReplicator
+};

package/dist/replication/trystero/P2PReplicatorPaneCommon.d.ts

@@ -0,0 +1,41 @@
+import type { InjectableServiceHub } from "../../services/InjectableServices.js";
+export declare const EVENT_P2P_PEER_SHOW_EXTRA_MENU = "p2p-peer-show-extra-menu";
+export declare enum AcceptedStatus {
+    UNKNOWN = "Unknown",
+    ACCEPTED = "Accepted",
+    DENIED = "Denied",
+    ACCEPTED_IN_SESSION = "Accepted in session",
+    DENIED_IN_SESSION = "Denied in session"
+}
+export type PeerExtraMenuEvent = {
+    peer: PeerStatus;
+    event: MouseEvent;
+};
+export declare enum ConnectionStatus {
+    CONNECTED = "Connected",
+    CONNECTED_LIVE = "Connected(live)",
+    DISCONNECTED = "Disconnected"
+}
+export type PeerStatus = {
+    name: string;
+    peerId: string;
+    syncOnConnect: boolean;
+    watchOnConnect: boolean;
+    syncOnReplicationCommand: boolean;
+    accepted: AcceptedStatus;
+    status: ConnectionStatus;
+    isFetching: boolean;
+    isSending: boolean;
+    isWatching: boolean;
+};
+declare global {
+    interface LSEvents {
+        [EVENT_P2P_PEER_SHOW_EXTRA_MENU]: PeerExtraMenuEvent;
+    }
+}
+export interface PluginShim {
+    services: InjectableServiceHub;
+    core: {
+        services: InjectableServiceHub;
+    };
+}

package/dist/replication/trystero/P2PReplicatorPaneCommon.js

@@ -0,0 +1,20 @@
+const EVENT_P2P_PEER_SHOW_EXTRA_MENU = "p2p-peer-show-extra-menu";
+var AcceptedStatus = /* @__PURE__ */ ((AcceptedStatus2) => {
+  AcceptedStatus2["UNKNOWN"] = "Unknown";
+  AcceptedStatus2["ACCEPTED"] = "Accepted";
+  AcceptedStatus2["DENIED"] = "Denied";
+  AcceptedStatus2["ACCEPTED_IN_SESSION"] = "Accepted in session";
+  AcceptedStatus2["DENIED_IN_SESSION"] = "Denied in session";
+  return AcceptedStatus2;
+})(AcceptedStatus || {});
+var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
+  ConnectionStatus2["CONNECTED"] = "Connected";
+  ConnectionStatus2["CONNECTED_LIVE"] = "Connected(live)";
+  ConnectionStatus2["DISCONNECTED"] = "Disconnected";
+  return ConnectionStatus2;
+})(ConnectionStatus || {});
+export {
+  AcceptedStatus,
+  ConnectionStatus,
+  EVENT_P2P_PEER_SHOW_EXTRA_MENU
+};

package/dist/replication/trystero/ProxiedDB.d.ts

@@ -0,0 +1,13 @@
+import { type ReplicatorHostEnv } from "./types.js";
+import type { EntryDoc } from "../../common/models/db.definition.js";
+export declare function createHostingDB(env: ReplicatorHostEnv): {
+    info: () => Promise<PouchDB.Core.DatabaseInfo>;
+    changes: (options: PouchDB.Core.ChangesOptions) => PouchDB.Core.Changes<EntryDoc>;
+    revsDiff: (diff: PouchDB.Core.RevisionDiffOptions) => Promise<PouchDB.Core.RevisionDiffResponse>;
+    bulkDocs: (docs: PouchDB.Core.PutDocument<EntryDoc & Record<string, unknown>>[], options?: PouchDB.Core.BulkDocsOptions) => Promise<(PouchDB.Core.Response | PouchDB.Core.Error)[]>;
+    bulkGet: (options: PouchDB.Core.BulkGetOptions) => Promise<PouchDB.Core.BulkGetResponse<EntryDoc>>;
+    put: (doc: PouchDB.Core.PutDocument<EntryDoc & Record<string, unknown>>, options?: PouchDB.Core.PutOptions) => Promise<PouchDB.Core.Response>;
+    get: (id: string, options?: PouchDB.Core.GetOptions) => Promise<EntryDoc & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta>;
+    _stopHosting: () => void;
+};
+export type HostingDB = ReturnType<typeof createHostingDB>;

package/dist/replication/trystero/ProxiedDB.js

@@ -0,0 +1,20 @@
+import {} from "./types.js";
+function createHostingDB(env) {
+  let db = env.db;
+  const hostingDB = {
+    info: () => db.info(),
+    changes: (options) => db.changes(options),
+    revsDiff: (diff) => db.revsDiff(diff),
+    bulkDocs: (docs, options) => db.bulkDocs(docs, options),
+    bulkGet: (options) => db.bulkGet(options),
+    put: (doc, options) => db.put(doc, options),
+    get: (id, options) => db.get(id, options),
+    _stopHosting: () => {
+      db = void 0;
+    }
+  };
+  return hostingDB;
+}
+export {
+  createHostingDB
+};

package/dist/replication/trystero/TrysteroReplicator.d.ts

@@ -0,0 +1,152 @@
+import { type EntryDoc, type ObsidianLiveSyncSettings } from "../../common/types.js";
+import { type ProgressInfo } from "../../pouchdb/ReplicatorShim.js";
+import type { Confirm } from "../../interfaces/Confirm.js";
+import { type Advertisement, type ReplicatorHostEnv } from "./types.js";
+import { EVENT_P2P_REPLICATOR_PROGRESS, EVENT_P2P_REPLICATOR_STATUS, P2PHost } from "./TrysteroReplicatorP2PServer.js";
+export type P2PReplicatorStatus = {
+    isBroadcasting: boolean;
+    replicatingTo: string[];
+    replicatingFrom: string[];
+    watchingPeers: string[];
+};
+export type P2PReplicationProgress = {
+    peerId: string;
+    peerName: string;
+    fetching: {
+        max: number;
+        current: number;
+        isActive: boolean;
+    };
+    sending: {
+        max: number;
+        current: number;
+        isActive: boolean;
+    };
+};
+export type P2PReplicationReport = {
+    peerId: string;
+    peerName: string;
+} & ({
+    fetching: {
+        max: number;
+        current: number;
+        isActive: boolean;
+    };
+} | {
+    sending: {
+        max: number;
+        current: number;
+        isActive: boolean;
+    };
+});
+declare global {
+    interface LSEvents {
+        [EVENT_P2P_REPLICATOR_STATUS]: P2PReplicatorStatus;
+        [EVENT_P2P_REPLICATOR_PROGRESS]: P2PReplicationReport;
+    }
+}
+export type AllReplicationClientStatus = {
+    [peerId: string]: {
+        isReplicatingTo: boolean;
+        isReplicatingFrom: boolean;
+        isWatching: boolean;
+        stats: P2PReplicationProgress;
+    };
+};
+export declare class TrysteroReplicator {
+    _env: ReplicatorHostEnv;
+    server?: P2PHost;
+    replicationStatus(): {};
+    get settings(): import("../../common/types.js").P2PSyncSetting;
+    get db(): PouchDB.Database<EntryDoc>;
+    get deviceName(): string;
+    get platform(): string;
+    get confirm(): Confirm;
+    get translate(): import("../../context.js").MessageTranslator;
+    private runFiniteReplicationActivity;
+    constructor(env: ReplicatorHostEnv, server?: P2PHost);
+    close(): Promise<void>;
+    open(): Promise<void>;
+    makeSureOpened(): Promise<void>;
+    get autoSyncPeers(): RegExp[];
+    get autoWatchPeers(): RegExp[];
+    onNewPeer(peer: Advertisement): Promise<void>;
+    onPeerLeaved(peerId: string): void;
+    _onSetup: boolean;
+    setOnSetup(): void;
+    clearOnSetup(): void;
+    getTweakSettings(fromPeerId: string): Promise<Partial<ObsidianLiveSyncSettings>>;
+    getCommands(): {
+        reqSync: (fromPeerId: string) => Promise<{
+            error: any;
+            ok?: undefined;
+        } | {
+            ok: boolean;
+            error?: undefined;
+        }>;
+        "!reqAuth": (fromPeerId: string) => Promise<boolean>;
+        getTweakSettings: (fromPeerId: string) => Promise<Partial<ObsidianLiveSyncSettings>>;
+        onProgress: (fromPeerId: string) => Promise<{
+            error: Error;
+        }>;
+        getAllConfig: (fromPeerId: string) => Promise<string | {
+            error: Error;
+        }>;
+        onProgressAcknowledged: (fromPeerId: string, info: ProgressInfo) => Promise<void>;
+        getIsBroadcasting: () => Promise<boolean>;
+        requestBroadcasting: (peerId: string) => Promise<true | {
+            error: Error;
+        }>;
+    };
+    requestAuthenticate(peerId: string): Promise<boolean>;
+    lastSeq: string | number;
+    requestSynchroniseToPeer(peerId: string): Promise<Awaited<ReturnType<ReturnType<typeof this.getCommands>["reqSync"]>>>;
+    requestSynchroniseToAllAvailablePeers(): Promise<void>;
+    dispatchStatus(): void;
+    requestStatus(): void;
+    changes?: PouchDB.Core.Changes<EntryDoc>;
+    _isBroadcasting: boolean;
+    disableBroadcastChanges(): void;
+    enableBroadcastChanges(): void;
+    get knownAdvertisements(): Advertisement[];
+    availableReplicationPairs: Set<string>;
+    sync(remotePeer: string, showNotice?: boolean): Promise<{
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    _replicateToPeers: Set<string>;
+    _replicateFromPeers: Set<string>;
+    dispatchReplicationProgress(peerId: string, info?: ProgressInfo): void;
+    onReplicationProgress(peerId: string, info?: ProgressInfo): boolean;
+    onProgressAcknowledged(peerId: string, info?: ProgressInfo): boolean;
+    acknowledgeProgress(remotePeerId: string, info?: ProgressInfo): void;
+    replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean): Promise<{
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    notifyProgress(excludePeerId?: string): Promise<void>;
+    requestBroadcastChanges(peerId: string): Promise<unknown>;
+    getRemoteIsBroadcasting(peerId: string): Promise<unknown>;
+    _watchingPeers: Set<string>;
+    watchPeer(peerId: string): void;
+    unwatchPeer(peerId: string): void;
+    onUpdateDatabase(fromPeerId: string): Promise<false | {
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    getRemoteConfig(peerId: string): Promise<false | ObsidianLiveSyncSettings>;
+    checkTweakValues(peerId: string): Promise<boolean>;
+    replicateFromCommand(showResult?: boolean): Promise<void>;
+    disconnectFromServer(): void;
+    pauseServe(): Promise<void>;
+    allowReconnection(): void;
+}