fixed tests

public/js/services/PublisherRTCManager.ts

@@ -0,0 +1,103 @@
+import type { ISignalingMessage } from '../interfaces/IWebRTCClient.ts';
+
+export class PublisherRTCManager {
+  private peerConnections: Map<string, RTCPeerConnection> = new Map();
+  private localStream: MediaStream | null = null;
+  private onSubscriberCountChange?: (count: number) => void;
+
+  private rtcConfiguration: RTCConfiguration = {
+    iceServers: [
+      { urls: 'stun:stun.l.google.com:19302' },
+      { urls: 'stun:stun1.l.google.com:19302' }
+    ]
+  };
+
+  constructor(onSubscriberCountChange?: (count: number) => void) {
+    this.onSubscriberCountChange = onSubscriberCountChange;
+  }
+
+  setLocalStream(stream: MediaStream): void {
+    this.localStream = stream;
+  }
+
+  async createOfferForSubscriber(subscriberId: string): Promise<RTCSessionDescriptionInit> {
+    const peerConnection = this.createPeerConnection(subscriberId);
+    
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(track => {
+        peerConnection.addTrack(track, this.localStream!);
+      });
+    }
+
+    const offer = await peerConnection.createOffer();
+    await peerConnection.setLocalDescription(offer);
+    
+    return offer;
+  }
+
+  async handleAnswer(subscriberId: string, answer: RTCSessionDescriptionInit): Promise<void> {
+    const peerConnection = this.peerConnections.get(subscriberId);
+    if (peerConnection) {
+      await peerConnection.setRemoteDescription(answer);
+    }
+  }
+
+  async handleIceCandidate(subscriberId: string, candidate: RTCIceCandidateInit): Promise<void> {
+    const peerConnection = this.peerConnections.get(subscriberId);
+    if (peerConnection && candidate) {
+      await peerConnection.addIceCandidate(candidate);
+    }
+  }
+
+  removeSubscriber(subscriberId: string): void {
+    const peerConnection = this.peerConnections.get(subscriberId);
+    if (peerConnection) {
+      peerConnection.close();
+      this.peerConnections.delete(subscriberId);
+      this.updateSubscriberCount();
+    }
+  }
+
+  closeAllConnections(): void {
+    this.peerConnections.forEach((pc, id) => {
+      pc.close();
+    });
+    this.peerConnections.clear();
+    this.updateSubscriberCount();
+  }
+
+  private createPeerConnection(subscriberId: string): RTCPeerConnection {
+    const peerConnection = new RTCPeerConnection(this.rtcConfiguration);
+
+    peerConnection.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.onIceCandidate?.(subscriberId, event.candidate);
+      }
+    };
+
+    peerConnection.onconnectionstatechange = () => {
+      console.log(`Connection state for ${subscriberId}:`, peerConnection.connectionState);
+      if (peerConnection.connectionState === 'failed' || 
+          peerConnection.connectionState === 'disconnected') {
+        this.removeSubscriber(subscriberId);
+      }
+    };
+
+    this.peerConnections.set(subscriberId, peerConnection);
+    this.updateSubscriberCount();
+    
+    return peerConnection;
+  }
+
+  private updateSubscriberCount(): void {
+    if (this.onSubscriberCountChange) {
+      this.onSubscriberCountChange(this.peerConnections.size);
+    }
+  }
+
+  private onIceCandidate?: (subscriberId: string, candidate: RTCIceCandidate) => void;
+
+  setOnIceCandidate(handler: (subscriberId: string, candidate: RTCIceCandidate) => void): void {
+    this.onIceCandidate = handler;
+  }
+}