@stream-io/video-client 1.4.0 → 1.4.1

package/dist/index.cjs.js

@@ -8276,8 +8276,9 @@ class Publisher {
      * @param isDtxEnabled whether DTX is enabled.
      * @param isRedEnabled whether RED is enabled.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
+     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay = 2500, }) {
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay = 2500, onUnrecoverableError, }) {
         this.transceiverRegistry = {
             [TrackType.AUDIO]: undefined,
             [TrackType.VIDEO]: undefined,
@@ -8798,15 +8799,16 @@ class Publisher {
             logger$3('debug', `ICE Connection state changed to`, state);
             const hasNetworkConnection = this.state.callingState !== exports.CallingState.OFFLINE;
             if (state === 'failed') {
-                logger$3('warn', `Attempting to restart ICE`);
+                logger$3('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
                     logger$3('error', `ICE restart error`, e);
+                    this.onUnrecoverableError?.();
                 });
             }
             else if (state === 'disconnected' && hasNetworkConnection) {
                 // when in `disconnected` state, the browser may recover automatically,
                 // hence, we delay the ICE restart
-                logger$3('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+                logger$3('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
                 this.iceRestartTimeout = setTimeout(() => {
                     // check if the state is still `disconnected` or `failed`
                     // as the connection may have recovered (or failed) in the meantime
@@ -8814,6 +8816,7 @@ class Publisher {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$3('error', `ICE restart error`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
@@ -8841,11 +8844,13 @@ class Publisher {
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
         this.iceRestartDelay = iceRestartDelay;
+        this.onUnrecoverableError = onUnrecoverableError;
         this.unsubscribeOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
                 return;
             this.restartIce().catch((err) => {
                 logger$3('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -8875,8 +8880,9 @@ class Subscriber {
      * @param state the state of the call.
      * @param connectionConfig the connection configuration to use.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
+     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay = 2500, }) {
+    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay = 2500, onUnrecoverableError, }) {
         this.isIceRestarting = false;
         /**
          * Creates a new `RTCPeerConnection` instance with the given configuration.
@@ -8986,6 +8992,10 @@ class Subscriber {
                 logger$2('debug', 'ICE restart is already in progress');
                 return;
             }
+            if (this.pc.connectionState === 'new') {
+                logger$2('debug', `ICE connection is not yet established, skipping restart.`);
+                return;
+            }
             const previousIsIceRestarting = this.isIceRestarting;
             try {
                 this.isIceRestarting = true;
@@ -9006,17 +9016,18 @@ class Subscriber {
             const participantToUpdate = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
             logger$2('debug', `[onTrack]: Got remote ${trackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
             if (!participantToUpdate) {
-                logger$2('error', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
+                logger$2('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
                 return;
             }
+            const trackDebugInfo = `${participantToUpdate.userId} ${trackType}:${trackId}`;
             e.track.addEventListener('mute', () => {
-                logger$2('info', `[onTrack]: Track muted: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('unmute', () => {
-                logger$2('info', `[onTrack]: Track unmuted: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('ended', () => {
-                logger$2('info', `[onTrack]: Track ended: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
             });
             const streamKindProp = {
                 TRACK_TYPE_AUDIO: 'audioStream',
@@ -9086,15 +9097,16 @@ class Subscriber {
                 return;
             const hasNetworkConnection = this.state.callingState !== exports.CallingState.OFFLINE;
             if (state === 'failed') {
-                logger$2('warn', `Attempting to restart ICE`);
+                logger$2('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
                     logger$2('error', `ICE restart failed`, e);
+                    this.onUnrecoverableError?.();
                 });
             }
             else if (state === 'disconnected' && hasNetworkConnection) {
                 // when in `disconnected` state, the browser may recover automatically,
                 // hence, we delay the ICE restart
-                logger$2('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+                logger$2('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
                 this.iceRestartTimeout = setTimeout(() => {
                     // check if the state is still `disconnected` or `failed`
                     // as the connection may have recovered (or failed) in the meantime
@@ -9102,12 +9114,13 @@ class Subscriber {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$2('error', `ICE restart failed`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
                         logger$2('debug', `Scheduled ICE restart: connection recovered, canceled.`);
                     }
-                }, 5000);
+                }, this.iceRestartDelay);
             }
         };
         this.onIceGatheringStateChange = () => {
@@ -9123,6 +9136,7 @@ class Subscriber {
         this.sfuClient = sfuClient;
         this.state = state;
         this.iceRestartDelay = iceRestartDelay;
+        this.onUnrecoverableError = onUnrecoverableError;
         this.pc = this.createPeerConnection(connectionConfig);
         this.unregisterOnSubscriberOffer = dispatcher.on('subscriberOffer', (subscriberOffer) => {
             this.negotiate(subscriberOffer).catch((err) => {
@@ -9134,6 +9148,7 @@ class Subscriber {
                 return;
             this.restartIce().catch((err) => {
                 logger$2('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -12816,6 +12831,11 @@ class Call {
                     dispatcher: this.dispatcher,
                     state: this.state,
                     connectionConfig,
+                    onUnrecoverableError: () => {
+                        reconnect('full', 'unrecoverable subscriber error').catch((err) => {
+                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        });
+                    },
                 });
             }
             // anonymous users can't publish anything hence, there is no need
@@ -12832,6 +12852,11 @@ class Call {
                     connectionConfig,
                     isDtxEnabled,
                     isRedEnabled,
+                    onUnrecoverableError: () => {
+                        reconnect('full', 'unrecoverable publisher error').catch((err) => {
+                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        });
+                    },
                 });
             }
             if (!this.statsReporter) {
@@ -15403,7 +15428,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.4.0" ;
+            const version = "1.4.1" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };