Move toju-app into own its folder

toju-app/src/app/infrastructure/realtime/peer-connection-manager/shared.ts

@@ -0,0 +1,107 @@
+import { Subject } from 'rxjs';
+import { ChatEvent } from '../../../shared-kernel';
+import { WebRTCLogger } from '../logging/webrtc-logger';
+import {
+  DisconnectedPeerEntry,
+  IdentifyCredentials,
+  PeerData,
+  VoiceStateSnapshot
+} from '../realtime.types';
+
+/**
+ * Callbacks the PeerConnectionManager needs from the owning service.
+ * This keeps the manager decoupled from Angular DI / signals.
+ */
+export interface PeerConnectionCallbacks {
+  /** Send a raw JSON message via the signaling server. */
+  sendRawMessage(msg: Record<string, unknown>): void;
+  /** Get the current local media stream (mic audio). */
+  getLocalMediaStream(): MediaStream | null;
+  /** Whether signaling is currently connected. */
+  isSignalingConnected(): boolean;
+  /** Returns the current voice/screen state snapshot for broadcasting. */
+  getVoiceStateSnapshot(): VoiceStateSnapshot;
+  /** Returns the identify credentials (oderId + displayName). */
+  getIdentifyCredentials(): IdentifyCredentials | null;
+  /** Returns the local peer ID. */
+  getLocalPeerId(): string;
+  /** Whether screen sharing is active. */
+  isScreenSharingActive(): boolean;
+}
+
+export interface PeerConnectionManagerState {
+  activePeerConnections: Map<string, PeerData>;
+  remotePeerStreams: Map<string, MediaStream>;
+  remotePeerVoiceStreams: Map<string, MediaStream>;
+  remotePeerScreenShareStreams: Map<string, MediaStream>;
+  disconnectedPeerTracker: Map<string, DisconnectedPeerEntry>;
+  peerReconnectTimers: Map<string, ReturnType<typeof setInterval>>;
+  peerDisconnectGraceTimers: Map<string, ReturnType<typeof setTimeout>>;
+  pendingPings: Map<string, number>;
+  peerPingTimers: Map<string, ReturnType<typeof setInterval>>;
+  peerLatencies: Map<string, number>;
+  peerLatencyChanged$: Subject<{ peerId: string; latencyMs: number }>;
+  peerNegotiationQueue: Map<string, Promise<void>>;
+  peerConnected$: Subject<string>;
+  peerDisconnected$: Subject<string>;
+  remoteStream$: Subject<{ peerId: string; stream: MediaStream }>;
+  messageReceived$: Subject<ChatEvent>;
+  connectedPeersChanged$: Subject<string[]>;
+  connectedPeersList: string[];
+}
+
+export interface PeerConnectionManagerContext {
+  readonly logger: WebRTCLogger;
+  readonly callbacks: PeerConnectionCallbacks;
+  readonly state: PeerConnectionManagerState;
+}
+
+export interface RemovePeerOptions {
+  preserveReconnectState?: boolean;
+}
+
+export interface ConnectionLifecycleHandlers {
+  clearPeerDisconnectGraceTimer(peerId: string): void;
+  addToConnectedPeers(peerId: string): void;
+  clearPeerReconnectTimer(peerId: string): void;
+  requestVoiceStateFromPeer(peerId: string): void;
+  schedulePeerDisconnectRecovery(peerId: string): void;
+  trackDisconnectedPeer(peerId: string): void;
+  removePeer(peerId: string, options?: RemovePeerOptions): void;
+  schedulePeerReconnect(peerId: string): void;
+  handleRemoteTrack(event: RTCTrackEvent, remotePeerId: string): void;
+  setupDataChannel(channel: RTCDataChannel, remotePeerId: string): void;
+}
+
+export interface NegotiationHandlers {
+  createPeerConnection(remotePeerId: string, isInitiator: boolean): PeerData;
+}
+
+export interface RecoveryHandlers {
+  removePeer(peerId: string, options?: RemovePeerOptions): void;
+  createPeerConnection(peerId: string, isInitiator: boolean): PeerData;
+  createAndSendOffer(peerId: string): Promise<void>;
+}
+
+export function createPeerConnectionManagerState(): PeerConnectionManagerState {
+  return {
+    activePeerConnections: new Map<string, PeerData>(),
+    remotePeerStreams: new Map<string, MediaStream>(),
+    remotePeerVoiceStreams: new Map<string, MediaStream>(),
+    remotePeerScreenShareStreams: new Map<string, MediaStream>(),
+    disconnectedPeerTracker: new Map<string, DisconnectedPeerEntry>(),
+    peerReconnectTimers: new Map<string, ReturnType<typeof setInterval>>(),
+    peerDisconnectGraceTimers: new Map<string, ReturnType<typeof setTimeout>>(),
+    pendingPings: new Map<string, number>(),
+    peerPingTimers: new Map<string, ReturnType<typeof setInterval>>(),
+    peerLatencies: new Map<string, number>(),
+    peerLatencyChanged$: new Subject<{ peerId: string; latencyMs: number }>(),
+    peerNegotiationQueue: new Map<string, Promise<void>>(),
+    peerConnected$: new Subject<string>(),
+    peerDisconnected$: new Subject<string>(),
+    remoteStream$: new Subject<{ peerId: string; stream: MediaStream }>(),
+    messageReceived$: new Subject<ChatEvent>(),
+    connectedPeersChanged$: new Subject<string[]>(),
+    connectedPeersList: []
+  };
+}