@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -0,0 +1,540 @@
+import { selfId, joinRoom } from "@trystero-p2p/nostr";
+import { LOG_LEVEL_INFO, LOG_LEVEL_NOTICE } from "../../common/types.js";
+import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
+import {
+  DIRECTION_RESPONSE,
+  ResponsePreventedError,
+  DIRECTION_REQUEST
+} from "./types.js";
+import { StoredMapLike } from "../../dataobject/StoredMap.js";
+import { TrysteroReplicatorP2PClient } from "./TrysteroReplicatorP2PClient.js";
+import { createHostingDB } from "./ProxiedDB.js";
+import { EVENT_PLATFORM_UNLOADED } from "../../events/coreEvents.js";
+import { shareRunningResult } from "octagonal-wheels/concurrency/lock_v2";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
+import { RpcRoom } from "../../rpc/index.js";
+import { TRYSTERO_RPC_DEFAULTS } from "../../rpc/transports/TrysteroTransport.js";
+import { toRpcMethodName } from "./rpcCompat.js";
+import { generateJoinRoomOptions } from "../../rpc/transports/trysteroUtils.js";
+import { subscribeConnectionStatus, subscribeFailureDiagnosis } from "../../rpc/transports/DiagRTCPeerConnections.js";
+import {} from "../../rpc/transports/DiagRTCPeerConnections.types.js";
+const EVENT_SERVER_STATUS = "p2p-server-status";
+const EVENT_MAKE_DECISION = "make-decision-p2p-peer";
+const EVENT_REVOKE_DECISION = "revoke-decision-p2p-peer";
+const EVENT_ADVERTISEMENT_RECEIVED = "p2p-advertisement-received";
+const EVENT_DEVICE_LEAVED = "p2p-device-leaved";
+const EVENT_REQUEST_STATUS = "p2p-request-status";
+const EVENT_P2P_REQUEST_FORCE_OPEN = "p2p-request-force-open";
+const EVENT_P2P_CONNECTED = "p2p-connected";
+const EVENT_P2P_DISCONNECTED = "p2p-disconnected";
+const EVENT_P2P_REPLICATOR_STATUS = "p2p-replicator-status";
+const EVENT_P2P_REPLICATOR_PROGRESS = "p2p-replicator-progress";
+class TrysteroReplicatorP2PServer {
+  _env;
+  _room;
+  _serverPeerId;
+  _activeRoomId = "";
+  ___send;
+  assignedFunctions = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Map();
+  _bindingObjects = [];
+  _rpcRoom;
+  _peerStatusEventCleanup = void 0;
+  _peerFailureAnalysisCleanup = void 0;
+  _peerConnectionEventCleanup() {
+    if (this._peerStatusEventCleanup) {
+      this._peerStatusEventCleanup();
+      this._peerStatusEventCleanup = void 0;
+    }
+    if (this._peerFailureAnalysisCleanup) {
+      this._peerFailureAnalysisCleanup();
+      this._peerFailureAnalysisCleanup = void 0;
+    }
+  }
+  _diagStats = {
+    totalNewConnections: 0,
+    totalFailedConnections: 0,
+    totalSuccessfulConnections: 0,
+    totalClosedConnections: 0,
+    details: {}
+  };
+  get isDisposed() {
+    return !this._room;
+  }
+  get isServing() {
+    return this._room !== void 0;
+  }
+  async ensureLeaved() {
+    if (this._room) {
+      try {
+        await this._room?.leave();
+      } catch (ex) {
+        Logger(
+          `Some error has been occurred while leaving the room, but possibly can be ignored`,
+          LOG_LEVEL_VERBOSE
+        );
+        Logger(ex, LOG_LEVEL_VERBOSE);
+      }
+      this._room = void 0;
+      this._env.events.emitEvent(EVENT_P2P_DISCONNECTED);
+    }
+  }
+  async setRoom(room) {
+    await this._room?.leave();
+    this._room = room;
+  }
+  async shutdown() {
+    try {
+      await this.close();
+      await this.ensureLeaved();
+      this._rpcRoom?.close();
+      this._rpcRoom = void 0;
+    } catch (ex) {
+      Logger(`Some error has been occurred while shutting down the server`, LOG_LEVEL_INFO);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    }
+  }
+  async dispatchConnectionStatus() {
+    const adsTasks = [...this.knownAdvertisements].map(async (e) => {
+      const isAccepted = await this.acceptedPeers.get(e.name);
+      const isTemporaryAccepted = this.temporaryAcceptedPeers.get(e.peerId);
+      return {
+        ...e,
+        isAccepted,
+        isTemporaryAccepted
+      };
+    });
+    const ads = await Promise.all(adsTasks);
+    this._env.events.emitEvent(EVENT_SERVER_STATUS, {
+      isConnected: this.isServing,
+      knownAdvertisements: ads,
+      serverPeerId: this.serverPeerId,
+      roomId: this._activeRoomId,
+      diag: this._diagStats
+    });
+  }
+  constructor(env, _serverPeerId = selfId) {
+    this._env = env;
+    this._serverPeerId = _serverPeerId;
+    this._env.events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
+      void this.shutdown();
+    });
+    this.acceptedPeers = new StoredMapLike(
+      this._env.simpleStore,
+      "p2p-device-decisions"
+    );
+  }
+  async makeDecision(decision) {
+    if (decision.decision) {
+      if (decision.isTemporary) {
+        this.temporaryAcceptedPeers.set(decision.peerId, true);
+      } else {
+        await this.acceptedPeers.set(decision.name, true);
+      }
+    } else {
+      if (decision.isTemporary) {
+        this.temporaryAcceptedPeers.set(decision.peerId, false);
+      } else {
+        await this.acceptedPeers.set(decision.name, false);
+      }
+    }
+    await this.dispatchConnectionStatus();
+  }
+  async revokeDecision(decision) {
+    this.temporaryAcceptedPeers.delete(decision.peerId);
+    await this.acceptedPeers.delete(decision.name);
+    await this.dispatchConnectionStatus();
+  }
+  get room() {
+    return this._room;
+  }
+  get serverPeerId() {
+    return this._serverPeerId;
+  }
+  get db() {
+    return this._env.db;
+  }
+  get confirm() {
+    return this._env.confirm;
+  }
+  get settings() {
+    return this._env.settings;
+  }
+  get isEnabled() {
+    return this.settings.P2P_Enabled;
+  }
+  get deviceInfo() {
+    return {
+      currentPeerId: this._serverPeerId,
+      name: this._env.deviceName,
+      platform: this._env.platform,
+      version: "0.0.0"
+    };
+  }
+  _sendAdvertisement;
+  // _advertisementTimer?: ReturnType<typeof setInterval>;
+  sendAdvertisement(peerId) {
+    if (!this.isEnabled) return;
+    const devInfo = this.deviceInfo;
+    const data = {
+      peerId: devInfo.currentPeerId,
+      name: devInfo.name,
+      platform: devInfo.platform
+    };
+    if (this._sendAdvertisement) {
+      Logger(`peerId: ${this.serverPeerId} Sending Advertisement to ${peerId ?? "All"}`, LOG_LEVEL_VERBOSE);
+      void this._sendAdvertisement(data, peerId);
+    }
+  }
+  // startAdvertisementBroadcast() {
+  //     if (this._advertisementTimer) {
+  //         clearInterval(this._advertisementTimer);
+  //     }
+  //     this._advertisementTimer = setInterval(() => {
+  //         if (!this.isServing || !this.isEnabled) {
+  //             return;
+  //         }
+  //         this.sendAdvertisement();
+  //     }, ADVERTISEMENT_REBROADCAST_INTERVAL_MS);
+  // }
+  // stopAdvertisementBroadcast() {
+  //     if (this._advertisementTimer) {
+  //         clearInterval(this._advertisementTimer);
+  //         this._advertisementTimer = undefined;
+  //     }
+  // }
+  _knownAdvertisements = /* @__PURE__ */ new Map();
+  get knownAdvertisements() {
+    return [...this._knownAdvertisements.values()];
+  }
+  onAdvertisement(data, peerId) {
+    if (!this.isEnabled) return;
+    Logger(`Advertisement from ${peerId}`, LOG_LEVEL_VERBOSE);
+    if (peerId === this.serverPeerId) return;
+    if (data.peerId === this.serverPeerId) return;
+    if (data.peerId !== peerId) return;
+    this._knownAdvertisements.set(peerId, data);
+    void this.dispatchConnectionStatus();
+    void this._env.events.emitEvent(EVENT_ADVERTISEMENT_RECEIVED, data);
+  }
+  acceptedPeers;
+  temporaryAcceptedPeers = /* @__PURE__ */ new Map();
+  confirmUserToAccept(peerId) {
+    return shareRunningResult(`confirmUserToAccept-${peerId}`, () => this._confirmUserToAccept(peerId));
+  }
+  _confirmUserToAccept(peerId) {
+    const peerInfo = this._knownAdvertisements.get(peerId);
+    if (!peerInfo) throw new Error("Unknown Peer");
+    const peerName = peerInfo.name;
+    const message = `Are you sure to establish connection to ${peerName} (${peerId})?
+You can chose as follows:
+- Accept: Accept all connections from this peer.
+- Ignore: Reject all connections from this peer.
+- Accept Temporarily: Accept the connection for this session only.
+- Ignore Temporarily: Reject the connection for this session only.
+
+>[!INFO] You can revoke your decision from the Peer-to-Peer Replicator Pane.`;
+    const OPTION_ACCEPT = "Accept";
+    const OPTION_IGNORE = "Ignore";
+    const OPTION_ACCEPT_TEMPORARILY = "Accept Temporarily";
+    const OPTION_IGNORE_TEMPORARILY = "Ignore Temporarily";
+    const OPTIONS = [OPTION_ACCEPT, OPTION_IGNORE, OPTION_ACCEPT_TEMPORARILY, OPTION_IGNORE_TEMPORARILY];
+    return this.confirm.askSelectStringDialogue(message, OPTIONS, {
+      title: "P2P Connection Request",
+      defaultAction: "Ignore Temporarily",
+      timeout: 30
+    }).then((decision) => {
+      if (decision === OPTION_ACCEPT_TEMPORARILY) {
+        this.temporaryAcceptedPeers.set(peerId, true);
+        void this.dispatchConnectionStatus();
+        return true;
+      } else if (decision === OPTION_IGNORE_TEMPORARILY) {
+        this.temporaryAcceptedPeers.set(peerId, false);
+        void this.dispatchConnectionStatus();
+        return false;
+      } else if (decision === OPTION_ACCEPT) {
+        this.temporaryAcceptedPeers.delete(peerId);
+        void this.acceptedPeers.set(peerName, true);
+        void this.dispatchConnectionStatus();
+        return true;
+      } else if (decision === OPTION_IGNORE) {
+        this.temporaryAcceptedPeers.delete(peerId);
+        void this.acceptedPeers.set(peerName, false);
+        void this.dispatchConnectionStatus();
+        return false;
+      } else {
+        throw new ResponsePreventedError("User Accepting failed");
+      }
+    });
+  }
+  _acceptablePeers = new Computed({
+    evaluation: (settings) => {
+      return `${settings?.P2P_AutoAcceptingPeers ?? ""}`.split(",").map((e) => e.trim()).filter((e) => !!e).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+    }
+  });
+  _shouldDenyPeers = new Computed({
+    evaluation: (settings) => {
+      return `${settings?.P2P_AutoDenyingPeers ?? ""}`.split(",").map((e) => e.trim()).filter((e) => !!e).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+    }
+  });
+  async isAcceptablePeer(peerId) {
+    if (!this.isEnabled) return void 0;
+    const peerInfo = this._knownAdvertisements.get(peerId);
+    if (!peerInfo) return false;
+    const peerName = peerInfo.name;
+    if (this.temporaryAcceptedPeers.has(peerId)) return this.temporaryAcceptedPeers.get(peerId);
+    const accepted = await this.acceptedPeers.get(peerName);
+    if (accepted !== void 0 && accepted !== null) return accepted;
+    const isAcceptable = (await this._acceptablePeers.update(this.settings)).value.some((e) => e.test(peerName));
+    const isDeny = (await this._shouldDenyPeers.update(this.settings)).value.some((e) => e.test(peerName));
+    if (isAcceptable) {
+      if (isDeny) return false;
+      this.temporaryAcceptedPeers.set(peerId, true);
+      void this.dispatchConnectionStatus();
+      return true;
+    }
+    if (this.settings.P2P_IsHeadless) {
+      return false;
+    }
+    return await this.confirmUserToAccept(peerId);
+  }
+  async __send(data, peerId) {
+    if (!this.isEnabled) return;
+    if (!await this.isAcceptablePeer(peerId)) {
+      Logger(`Invalid Message to ${peerId}`, LOG_LEVEL_VERBOSE);
+      Logger(data, LOG_LEVEL_VERBOSE);
+      return;
+    }
+    if (this.___send) {
+      return await this.___send(data, peerId);
+    } else {
+      Logger(`Cannot send response, no send function`);
+    }
+  }
+  async processArrivedRPC(data, peerId) {
+    if (!this.isEnabled) return;
+    if (!data.type.startsWith("!")) {
+      const isAcceptable = await this.isAcceptablePeer(peerId);
+      if (!isAcceptable) {
+        throw new Error(`Not acceptable peer ${peerId}`);
+      }
+    } else {
+    }
+    if (data.direction === DIRECTION_RESPONSE) {
+      this.__onResponse(data, peerId);
+    } else if (data.direction === DIRECTION_REQUEST) {
+      await this.__onRequest(data, peerId);
+    } else {
+      throw new Error(`Invalid Message from ${peerId}`);
+    }
+  }
+  _onPeerJoin(peerId) {
+    if (!this._room) {
+      Logger(`Received peer join event from ${peerId}, but no active room. Ignoring.`, LOG_LEVEL_VERBOSE);
+      return;
+    }
+    const peers = this._room.getPeers();
+    const peer = peers[peerId];
+    Logger(`Peer joined: ${peerId}`, LOG_LEVEL_VERBOSE);
+    this.activePeer.set(peerId, peer);
+    this.sendAdvertisement(peerId);
+  }
+  _onPeerLeave(peerId) {
+    Logger(`Peer left: ${peerId}`, LOG_LEVEL_VERBOSE);
+    this._knownAdvertisements.delete(peerId);
+    const peerConn = this.activePeer.get(peerId);
+    if (peerConn) {
+      peerConn.close();
+      this.activePeer.delete(peerId);
+    }
+    void this._env.events.emitEvent(EVENT_DEVICE_LEAVED, peerId);
+    void this.dispatchConnectionStatus();
+  }
+  activePeer = /* @__PURE__ */ new Map();
+  onAfterJoinRoom() {
+    Logger(`Initializing...`, LOG_LEVEL_VERBOSE);
+    const room = this.room;
+    if (!room) throw new Error("This server has been already disconnected");
+    const [sendRpc, arrivedRpc] = room.makeAction("rpc2");
+    const transport = {
+      send: (message, peerId) => {
+        return sendRpc(message, peerId).then(() => void 0);
+      },
+      onMessage: (handler) => {
+        arrivedRpc((data, peerId) => {
+          handler(data, peerId);
+        });
+        return () => void 0;
+      },
+      onPeerJoin: (handler) => {
+        room.onPeerJoin((peerId) => {
+          this._onPeerJoin(peerId);
+          handler(peerId);
+        });
+        return () => void 0;
+      },
+      onPeerLeave: (handler) => {
+        room.onPeerLeave((peerId) => {
+          this._onPeerLeave(peerId);
+          handler(peerId);
+        });
+        return () => void 0;
+      }
+    };
+    this._rpcRoom?.close();
+    this._rpcRoom = new RpcRoom({
+      ...TRYSTERO_RPC_DEFAULTS,
+      transport,
+      canAcceptRequest: async (peerId, method) => {
+        if (method === toRpcMethodName("!reqAuth")) return true;
+        return await this.isAcceptablePeer(peerId) === true;
+      },
+      onProtocolWarning: (message, peerId) => {
+        Logger(`RPC Protocol warning${peerId ? ` from ${peerId}` : ""}: ${message}`, LOG_LEVEL_VERBOSE);
+      }
+    });
+    const [adSend, adArrived] = room.makeAction("ad");
+    this._sendAdvertisement = adSend;
+    adArrived((data, peerId) => {
+      void this.onAdvertisement(data, peerId);
+    });
+    this._env.events.emitEvent(EVENT_P2P_CONNECTED);
+    void this.dispatchConnectionStatus();
+  }
+  async startService(bindings = []) {
+    if (!this.isEnabled) {
+      Logger(this._env.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    const servingDB = createHostingDB(this._env);
+    this._bindingObjects = [...bindings, servingDB];
+    this._bindingObjects.forEach((b) => {
+      this.serveObject(b);
+    });
+    await Promise.resolve(this.sendAdvertisement());
+  }
+  async start(bindings = []) {
+    await this.shutdown();
+    if (!this.settings.P2P_Enabled) {
+      Logger(this._env.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    const options = generateJoinRoomOptions(this.settings);
+    const roomId = this.settings.P2P_roomID;
+    this._peerConnectionEventCleanup();
+    this._peerStatusEventCleanup = subscribeConnectionStatus((status) => {
+      this._diagStats = status;
+      void this.dispatchConnectionStatus();
+    });
+    this._peerFailureAnalysisCleanup = subscribeFailureDiagnosis((status) => {
+      Logger(`[P2P] Connection failure detected: ${status.userMessage}`, LOG_LEVEL_NOTICE);
+    });
+    const room = joinRoom(options, roomId, {
+      handshakeTimeoutMs: 3e4,
+      onJoinError: (error) => {
+        Logger("Some peer Failed to join Trystero room");
+        Logger(error, LOG_LEVEL_VERBOSE);
+      }
+    });
+    await this.setRoom(room);
+    this._activeRoomId = roomId;
+    this.onAfterJoinRoom();
+    void this.dispatchConnectionStatus();
+    await this.startService(bindings);
+  }
+  /**
+   * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
+   * @param type
+   * @param func
+   */
+  serveFunction(type, func) {
+    this.assignedFunctions.set(type, func);
+    this._rpcRoom?.register(toRpcMethodName(type), async (peerId, ...args) => {
+      return await Promise.resolve(func.apply(this, [peerId, ...args]));
+    });
+  }
+  serveObject(obj) {
+    const keys = Object.keys(obj);
+    keys.forEach((key) => {
+      if (key.toString().startsWith("_")) return;
+      const func = obj[key].bind(obj);
+      this.assignedFunctions.set(key.toString(), func);
+      this._rpcRoom?.register(toRpcMethodName(key.toString()), async (_peerId, ...args) => {
+        return await Promise.resolve(func(...args));
+      });
+    });
+  }
+  __onResponse(data, peerId) {
+    const peer = this.clients.get(peerId);
+    if (!peer) {
+      Logger(`Response from unknown peer ${peerId}`, LOG_LEVEL_VERBOSE);
+      return;
+    }
+    peer.__onResponse(data);
+  }
+  async __onRequest(data, peerId) {
+    try {
+      const func = this.assignedFunctions.get(data.type);
+      if (typeof func !== "function")
+        throw new Error(`Cannot serve function ${data.type}, no function provided or I am only a client`);
+      const r = await Promise.resolve(func.apply(this, data.args));
+      await this.__send({ type: data.type, seq: data.seq, direction: DIRECTION_RESPONSE, data: r }, peerId);
+    } catch (e) {
+      if (e instanceof ResponsePreventedError) {
+        Logger(`Serving function: [FAILED] ${data.type}: Response prevented.`, LOG_LEVEL_VERBOSE);
+        return;
+      }
+      Logger(`Serving function: [FAILED] ${data.type} sending back the failure information`, LOG_LEVEL_VERBOSE);
+      Logger(e instanceof Error ? e.message : e, LOG_LEVEL_VERBOSE);
+      await this.__send(
+        { type: data.type, seq: data.seq, direction: DIRECTION_RESPONSE, data: void 0, error: e },
+        peerId
+      );
+    }
+  }
+  async close() {
+    this.assignedFunctions.clear();
+    const peers = this.room?.getPeers() ?? {};
+    this.clients.forEach((client) => client.close());
+    this.clients.clear();
+    this._rpcRoom?.close();
+    this._rpcRoom = void 0;
+    for (const [, peer] of Object.entries(peers)) {
+      peer.close();
+    }
+    await this.ensureLeaved();
+    this._activeRoomId = "";
+    this._knownAdvertisements.clear();
+    this._peerConnectionEventCleanup();
+    await this.dispatchConnectionStatus();
+  }
+  getConnection(peerId) {
+    if (this.clients.has(peerId)) {
+      return this.clients.get(peerId);
+    }
+    if (!this._knownAdvertisements.has(peerId)) {
+      throw new Error(`Unknown Peer ${peerId}`);
+    }
+    const client = new TrysteroReplicatorP2PClient(this, peerId);
+    this.clients.set(peerId, client);
+    return client;
+  }
+  get rpcRoom() {
+    return this._rpcRoom;
+  }
+}
+export {
+  EVENT_ADVERTISEMENT_RECEIVED,
+  EVENT_DEVICE_LEAVED,
+  EVENT_MAKE_DECISION,
+  EVENT_P2P_CONNECTED,
+  EVENT_P2P_DISCONNECTED,
+  EVENT_P2P_REPLICATOR_PROGRESS,
+  EVENT_P2P_REPLICATOR_STATUS,
+  EVENT_P2P_REQUEST_FORCE_OPEN,
+  EVENT_REQUEST_STATUS,
+  EVENT_REVOKE_DECISION,
+  EVENT_SERVER_STATUS,
+  TrysteroReplicatorP2PServer as P2PHost,
+  TrysteroReplicatorP2PServer
+};

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

@@ -0,0 +1,11 @@
+import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
+import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import type { P2PLogCollector } from "./P2PLogCollector.js";
+export type UseP2PReplicatorResult = {
+    replicator: LiveSyncTrysteroReplicator;
+};
+export type P2PPaneParams = {
+    replicator: LiveSyncTrysteroReplicator;
+    p2pLogCollector: P2PLogCollector;
+    storeP2PStatusLine: ReactiveSource<string>;
+};

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

@@ -0,0 +1,35 @@
+import type { LiveSyncEventHub } from "../../hub/hub.js";
+import type { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import type { Advertisement } from "./types.js";
+/**
+ * Minimal interface that a P2P replicator instance should satisfy for addP2PEventHandlers to work.
+ */
+export interface P2PReplicatorLike {
+    onNewPeer(peer: Advertisement): Promise<void> | void;
+    onPeerLeaved(peerId: string): void;
+    requestStatus(): void;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    /** Indicates whether the room is currently active. */
+    readonly isServing?: boolean;
+    /** Legacy: host object that may carry isServing (LiveSyncTrysteroReplicator). */
+    readonly server?: {
+        isServing?: boolean;
+    };
+}
+/**
+ * Add event handlers for P2P replication related events.
+ * @param instance P2PReplicatorLike instance
+ */
+export declare function addP2PEventHandlers(instance: P2PReplicatorLike, events: LiveSyncEventHub): void;
+/**
+ * open P2P replicator if not opened yet.
+ * @param instance
+ */
+export declare function openP2PReplicator(instance: P2PReplicatorLike): Promise<void>;
+/**
+ * close P2P replicator
+ * @param instance
+ */
+export declare function closeP2PReplicator(instance: P2PReplicatorLike): Promise<void>;
+export type { LiveSyncTrysteroReplicator };

package/dist/replication/trystero/addP2PEventHandlers.js

@@ -0,0 +1,43 @@
+import { EVENT_DATABASE_REBUILT, EVENT_PLATFORM_UNLOADED, EVENT_SETTING_SAVED } from "../../events/coreEvents.js";
+import { EVENT_ADVERTISEMENT_RECEIVED, EVENT_DEVICE_LEAVED, EVENT_REQUEST_STATUS } from "./TrysteroReplicatorP2PServer.js";
+function addP2PEventHandlers(instance, events) {
+  events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (peer) => {
+    void instance.onNewPeer(peer);
+  });
+  events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => {
+    instance.onPeerLeaved(peerId);
+  });
+  events.onEvent(EVENT_REQUEST_STATUS, () => {
+    instance.requestStatus();
+  });
+  events.onEvent(EVENT_DATABASE_REBUILT, async () => {
+    await instance.open();
+  });
+  events.onEvent(EVENT_PLATFORM_UNLOADED, () => {
+    void instance.close();
+  });
+  events.onEvent(EVENT_SETTING_SAVED, async (settings) => {
+    const isOpen = instance.isServing ?? instance.server?.isServing ?? false;
+    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
+      await instance.open();
+      return;
+    }
+    if (isOpen) {
+      await instance.close();
+    }
+  });
+}
+async function openP2PReplicator(instance) {
+  const isOpen = instance.isServing ?? instance.server?.isServing ?? false;
+  if (!isOpen) {
+    await instance.open();
+  }
+}
+async function closeP2PReplicator(instance) {
+  await instance.close();
+}
+export {
+  addP2PEventHandlers,
+  closeP2PReplicator,
+  openP2PReplicator
+};

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

@@ -0,0 +1 @@
+export declare function toRpcMethodName(method: string): string;

package/dist/replication/trystero/rpcCompat.js

@@ -0,0 +1,9 @@
+const DB_METHODS = /* @__PURE__ */ new Set(["info", "changes", "revsDiff", "bulkDocs", "bulkGet", "put", "get"]);
+function toRpcMethodName(method) {
+  if (method.includes(".") || method.includes("/")) return method;
+  if (DB_METHODS.has(method)) return `db.${method}`;
+  return `legacy/${method}`;
+}
+export {
+  toRpcMethodName
+};