@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/TrysteroReplicatorP2PClient.js

@@ -0,0 +1,80 @@
+import {
+  BULK_GET_RPC_TIMEOUT,
+  DEFAULT_RPC_TIMEOUT
+} from "./types.js";
+import { toRpcMethodName } from "./rpcCompat.js";
+class TrysteroReplicatorP2PClient {
+  _server;
+  _connectedPeerId;
+  _remoteDB;
+  get remoteDB() {
+    return this._remoteDB;
+  }
+  constructor(server, connectedPeerId) {
+    this._server = server;
+    this._connectedPeerId = connectedPeerId;
+    this._remoteDB = this._bindRemoteDB();
+  }
+  _bindRemoteDB() {
+    return {
+      info: this.bindRemoteFunction("info"),
+      changes: this.bindRemoteFunction("changes"),
+      revsDiff: this.bindRemoteFunction("revsDiff"),
+      bulkDocs: this.bindRemoteFunction("bulkDocs"),
+      bulkGet: this.bindRemoteFunction("bulkGet", BULK_GET_RPC_TIMEOUT),
+      put: this.bindRemoteFunction("put"),
+      get: this.bindRemoteFunction("get")
+    };
+  }
+  _sendRPC(type, args, timeout = DEFAULT_RPC_TIMEOUT) {
+    const room = this._server?.rpcRoom;
+    if (!room) {
+      throw new Error("Not connected to any room");
+    }
+    const session = room.session(this._connectedPeerId);
+    return session.call(toRpcMethodName(type), args, timeout);
+  }
+  __onResponse(_data) {
+  }
+  bindRemoteFunction(type, timeout = DEFAULT_RPC_TIMEOUT) {
+    return async (...args) => {
+      const room = this._server?.rpcRoom;
+      if (!room) {
+        throw new Error("Not connected to any room");
+      }
+      return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, timeout);
+    };
+  }
+  async invokeRemoteFunction(type, args, timeout = DEFAULT_RPC_TIMEOUT) {
+    const room = this._server?.rpcRoom;
+    if (!room) {
+      throw new Error("Not connected to any room");
+    }
+    return await room.session(this._connectedPeerId).call(toRpcMethodName(type), args, timeout);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a generic function binder, so we can't be more specific about the types here.
+  bindRemoteObjectFunctions(key, timeout = DEFAULT_RPC_TIMEOUT) {
+    return async (...args) => {
+      const room = this._server?.rpcRoom;
+      if (!room) {
+        throw new Error("Not connected to any room");
+      }
+      return await room.session(this._connectedPeerId).call(toRpcMethodName(key.toString()), args, timeout);
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a generic function binder, so we can't be more specific about the types here.
+  async invokeRemoteObjectFunction(key, args, timeout = DEFAULT_RPC_TIMEOUT) {
+    const room = this._server?.rpcRoom;
+    if (!room) {
+      throw new Error("Not connected to any room");
+    }
+    return await room.session(this._connectedPeerId).call(toRpcMethodName(key.toString()), args, timeout);
+  }
+  close() {
+    this._remoteDB = void 0;
+    this._server = void 0;
+  }
+}
+export {
+  TrysteroReplicatorP2PClient
+};

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

@@ -0,0 +1,2 @@
+import { TrysteroReplicatorP2PServer } from "./TrysteroReplicatorP2PServer.js";
+export { TrysteroReplicatorP2PServer as TrysteroConnection };

package/dist/replication/trystero/TrysteroReplicatorP2PConnection.js

@@ -0,0 +1,4 @@
+import { TrysteroReplicatorP2PServer } from "./TrysteroReplicatorP2PServer.js";
+export {
+  TrysteroReplicatorP2PServer as TrysteroConnection
+};

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

@@ -0,0 +1,117 @@
+import { type ActionSender, type Room } from "@trystero-p2p/nostr";
+import { type P2PSyncSetting } from "../../common/types.js";
+import { type ReplicatorHostEnv, type FullFilledDeviceInfo, type Request, type Response, type Payload, type Advertisement, type BindableObject, type BindableFunction } from "./types.js";
+import { StoredMapLike } from "../../dataobject/StoredMap.js";
+import { TrysteroReplicatorP2PClient } from "./TrysteroReplicatorP2PClient.js";
+import { Computed } from "octagonal-wheels/dataobject/Computed";
+import { RpcRoom, type JsonLike } from "../../rpc/index.js";
+import { type DiagRTCStats } from "../../rpc/transports/DiagRTCPeerConnections.types.js";
+export type PeerInfo = Advertisement & {
+    isAccepted: boolean | undefined;
+    isTemporaryAccepted: boolean | undefined;
+};
+export type AcceptanceDecision = {
+    peerId: string;
+    name: string;
+    decision: boolean;
+    isTemporary: boolean;
+};
+export type RevokeAcceptanceDecision = {
+    peerId: string;
+    name: string;
+};
+export type P2PServerInfo = {
+    isConnected: boolean;
+    knownAdvertisements: PeerInfo[];
+    serverPeerId: string;
+    roomId: string;
+    diag: DiagRTCStats;
+};
+export declare const EVENT_SERVER_STATUS = "p2p-server-status";
+export declare const EVENT_MAKE_DECISION = "make-decision-p2p-peer";
+export declare const EVENT_REVOKE_DECISION = "revoke-decision-p2p-peer";
+export declare const EVENT_ADVERTISEMENT_RECEIVED = "p2p-advertisement-received";
+export declare const EVENT_DEVICE_LEAVED = "p2p-device-leaved";
+export declare const EVENT_REQUEST_STATUS = "p2p-request-status";
+export declare const EVENT_P2P_REQUEST_FORCE_OPEN = "p2p-request-force-open";
+export declare const EVENT_P2P_CONNECTED = "p2p-connected";
+export declare const EVENT_P2P_DISCONNECTED = "p2p-disconnected";
+export declare const EVENT_P2P_REPLICATOR_STATUS = "p2p-replicator-status";
+export declare const EVENT_P2P_REPLICATOR_PROGRESS = "p2p-replicator-progress";
+declare global {
+    interface LSEvents {
+        [EVENT_SERVER_STATUS]: P2PServerInfo;
+        [EVENT_MAKE_DECISION]: AcceptanceDecision;
+        [EVENT_REVOKE_DECISION]: RevokeAcceptanceDecision;
+        [EVENT_ADVERTISEMENT_RECEIVED]: Advertisement;
+        [EVENT_DEVICE_LEAVED]: string;
+        [EVENT_REQUEST_STATUS]: undefined;
+        [EVENT_P2P_REQUEST_FORCE_OPEN]: undefined;
+        [EVENT_P2P_CONNECTED]: undefined;
+        [EVENT_P2P_DISCONNECTED]: undefined;
+    }
+}
+export declare class TrysteroReplicatorP2PServer {
+    _env: ReplicatorHostEnv;
+    _room?: Room;
+    _serverPeerId: string;
+    _activeRoomId: string;
+    ___send?: ActionSender<Payload>;
+    assignedFunctions: Map<string, BindableFunction>;
+    clients: Map<string, TrysteroReplicatorP2PClient>;
+    _bindingObjects: BindableObject[];
+    _rpcRoom?: RpcRoom;
+    protected _peerStatusEventCleanup: (() => void) | undefined;
+    protected _peerFailureAnalysisCleanup: (() => void) | undefined;
+    protected _peerConnectionEventCleanup(): void;
+    _diagStats: DiagRTCStats;
+    get isDisposed(): boolean;
+    get isServing(): boolean;
+    ensureLeaved(): Promise<void>;
+    setRoom(room: Room): Promise<void>;
+    shutdown(): Promise<void>;
+    dispatchConnectionStatus(): Promise<void>;
+    constructor(env: ReplicatorHostEnv, _serverPeerId?: string);
+    makeDecision(decision: AcceptanceDecision): Promise<void>;
+    revokeDecision(decision: RevokeAcceptanceDecision): Promise<void>;
+    get room(): Room;
+    get serverPeerId(): string;
+    get db(): PouchDB.Database<import("../../common/types.js").EntryDoc>;
+    get confirm(): import("../../interfaces/Confirm.js").Confirm;
+    get settings(): P2PSyncSetting;
+    get isEnabled(): boolean;
+    get deviceInfo(): FullFilledDeviceInfo;
+    _sendAdvertisement?: ActionSender<Advertisement>;
+    sendAdvertisement(peerId?: string): void;
+    _knownAdvertisements: Map<string, Advertisement>;
+    get knownAdvertisements(): Advertisement[];
+    onAdvertisement(data: Advertisement, peerId: string): void;
+    acceptedPeers: StoredMapLike<boolean>;
+    temporaryAcceptedPeers: Map<string, boolean>;
+    confirmUserToAccept(peerId: string): Promise<boolean>;
+    _confirmUserToAccept(peerId: string): Promise<boolean>;
+    _acceptablePeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
+    _shouldDenyPeers: Computed<[settings: P2PSyncSetting], RegExp[]>;
+    isAcceptablePeer(peerId: string): Promise<boolean>;
+    __send(data: Payload, peerId: string): Promise<void[]>;
+    processArrivedRPC(data: Payload, peerId: string): Promise<void>;
+    private _onPeerJoin;
+    private _onPeerLeave;
+    activePeer: Map<string, RTCPeerConnection>;
+    onAfterJoinRoom(): void;
+    startService(bindings?: BindableObject[]): Promise<void>;
+    start(bindings?: BindableObject[]): Promise<void>;
+    /**
+     * @deprecated Use serveFunction or serveObject instead. This is only for backward compatibility and may be removed in the future.
+     * @param type
+     * @param func
+     */
+    serveFunction<T extends JsonLike[], U>(type: string, func: (peerId: string, ...args: T) => U | Promise<U>): void;
+    serveObject<T>(obj: BindableObject<T>): void;
+    __onResponse(data: Response, peerId: string): void;
+    __onRequest(data: Request, peerId: string): Promise<void>;
+    close(): Promise<void>;
+    getConnection(peerId: string): TrysteroReplicatorP2PClient;
+    get rpcRoom(): RpcRoom;
+}
+export { TrysteroReplicatorP2PServer as P2PHost };