@xtr-dev/rondevu-client 0.7.0 → 0.7.2

package/dist/peer/answering-state.js

@@ -16,25 +16,13 @@ export class AnsweringState extends PeerState {
                 type: 'offer',
                 sdp: offerSdp
             });
+            // Enable trickle ICE - set up handler before ICE gathering starts
+            this.setupIceCandidateHandler();
             // Create answer
             const answer = await this.peer.pc.createAnswer();
-            await this.peer.pc.setLocalDescription(answer);
+            await this.peer.pc.setLocalDescription(answer); // ICE gathering starts here
             // Send answer to server immediately (don't wait for ICE)
             await this.peer.offersApi.answer(offerId, answer.sdp);
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
             // Transition to exchanging ICE
             const { ExchangingIceState } = await import('./exchanging-ice-state.js');
             this.peer.setState(new ExchangingIceState(this.peer, offerId, options));

package/dist/peer/creating-offer-state.js

@@ -16,9 +16,12 @@ export class CreatingOfferState extends PeerState {
                 const channel = this.peer.pc.createDataChannel(options.dataChannelLabel || 'data');
                 this.peer.emitEvent('datachannel', channel);
             }
+            // Enable trickle ICE - set up handler before ICE gathering starts
+            // Handler will check this.peer.offerId before sending
+            this.setupIceCandidateHandler();
             // Create WebRTC offer
             const offer = await this.peer.pc.createOffer();
-            await this.peer.pc.setLocalDescription(offer);
+            await this.peer.pc.setLocalDescription(offer); // ICE gathering starts here
             // Send offer to server immediately (don't wait for ICE)
             const offers = await this.peer.offersApi.create([{
                     sdp: offer.sdp,
@@ -26,21 +29,7 @@ export class CreatingOfferState extends PeerState {
                     ttl: options.ttl || 300000
                 }]);
             const offerId = offers[0].id;
-            this.peer.offerId = offerId;
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
+            this.peer.offerId = offerId; // Now handler can send candidates
             // Transition to waiting for answer
             const { WaitingForAnswerState } = await import('./waiting-for-answer-state.js');
             this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));

package/dist/peer/index.d.ts

@@ -13,6 +13,10 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
     offerId?: string;
     role?: 'offerer' | 'answerer';
     private _state;
+    private connectionStateChangeHandler?;
+    private dataChannelHandler?;
+    private trackHandler?;
+    private iceCandidateErrorHandler?;
     /**
      * Current connection state name
      */

package/dist/peer/index.js

@@ -42,7 +42,7 @@ export default class RondevuPeer extends EventEmitter {
      * Set up peer connection event handlers
      */
     setupPeerConnection() {
-        this.pc.onconnectionstatechange = () => {
+        this.connectionStateChangeHandler = () => {
             switch (this.pc.connectionState) {
                 case 'connected':
                     this.setState(new ConnectedState(this));
@@ -60,15 +60,19 @@ export default class RondevuPeer extends EventEmitter {
                     break;
             }
         };
-        this.pc.ondatachannel = (event) => {
+        this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        this.dataChannelHandler = (event) => {
             this.emitEvent('datachannel', event.channel);
         };
-        this.pc.ontrack = (event) => {
+        this.pc.addEventListener('datachannel', this.dataChannelHandler);
+        this.trackHandler = (event) => {
             this.emitEvent('track', event);
         };
-        this.pc.onicecandidateerror = (event) => {
+        this.pc.addEventListener('track', this.trackHandler);
+        this.iceCandidateErrorHandler = (event) => {
             console.error('ICE candidate error:', event);
         };
+        this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
     }
     /**
      * Set new state and emit state change event
@@ -107,6 +111,19 @@ export default class RondevuPeer extends EventEmitter {
      * Close the connection and clean up
      */
     async close() {
+        // Remove RTCPeerConnection event listeners
+        if (this.connectionStateChangeHandler) {
+            this.pc.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        }
+        if (this.dataChannelHandler) {
+            this.pc.removeEventListener('datachannel', this.dataChannelHandler);
+        }
+        if (this.trackHandler) {
+            this.pc.removeEventListener('track', this.trackHandler);
+        }
+        if (this.iceCandidateErrorHandler) {
+            this.pc.removeEventListener('icecandidateerror', this.iceCandidateErrorHandler);
+        }
         await this._state.close();
         this.removeAllListeners();
     }

package/dist/peer/state.d.ts

@@ -6,12 +6,18 @@ import type RondevuPeer from './index.js';
  */
 export declare abstract class PeerState {
     protected peer: RondevuPeer;
+    protected iceCandidateHandler?: (event: RTCPeerConnectionIceEvent) => void;
     constructor(peer: RondevuPeer);
     abstract get name(): string;
     createOffer(options: PeerOptions): Promise<string>;
     answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
     handleAnswer(sdp: string): Promise<void>;
     handleIceCandidate(candidate: any): Promise<void>;
+    /**
+     * Setup trickle ICE candidate handler
+     * Sends local ICE candidates to server as they are discovered
+     */
+    protected setupIceCandidateHandler(): void;
     cleanup(): void;
     close(): Promise<void>;
 }

package/dist/peer/state.js

@@ -21,8 +21,31 @@ export class PeerState {
             await this.peer.pc.addIceCandidate(new RTCIceCandidate(candidate));
         }
     }
+    /**
+     * Setup trickle ICE candidate handler
+     * Sends local ICE candidates to server as they are discovered
+     */
+    setupIceCandidateHandler() {
+        this.iceCandidateHandler = async (event) => {
+            if (event.candidate && this.peer.offerId) {
+                const candidateData = event.candidate.toJSON();
+                if (candidateData.candidate && candidateData.candidate !== '') {
+                    try {
+                        await this.peer.offersApi.addIceCandidates(this.peer.offerId, [candidateData]);
+                    }
+                    catch (err) {
+                        console.error('Error sending ICE candidate:', err);
+                    }
+                }
+            }
+        };
+        this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
+    }
     cleanup() {
-        // Override in states that need cleanup
+        // Clean up ICE candidate handler if it exists
+        if (this.iceCandidateHandler) {
+            this.peer.pc.removeEventListener('icecandidate', this.iceCandidateHandler);
+        }
     }
     async close() {
         this.cleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
   "type": "module",
   "main": "dist/index.js",