@stream-io/video-client 1.4.0 → 1.4.2

package/dist/index.es.js

@@ -123,6 +123,11 @@ const RecordSettingsRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
+    PORTRAIT_360X640: 'portrait-360x640',
+    PORTRAIT_480X854: 'portrait-480x854',
+    PORTRAIT_720X1280: 'portrait-720x1280',
+    PORTRAIT_1080X1920: 'portrait-1080x1920',
+    PORTRAIT_1440X2560: 'portrait-1440x2560',
 };
 /**
  * @export
@@ -8256,8 +8261,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,
@@ -8778,15 +8784,16 @@ class Publisher {
             logger$3('debug', `ICE Connection state changed to`, state);
             const hasNetworkConnection = this.state.callingState !== 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
@@ -8794,6 +8801,7 @@ class Publisher {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$3('error', `ICE restart error`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
@@ -8821,11 +8829,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?.();
             });
         });
     }
@@ -8855,8 +8865,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.
@@ -8966,6 +8977,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;
@@ -8986,17 +9001,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',
@@ -9066,15 +9082,16 @@ class Subscriber {
                 return;
             const hasNetworkConnection = this.state.callingState !== 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
@@ -9082,12 +9099,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 = () => {
@@ -9103,6 +9121,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) => {
@@ -9114,6 +9133,7 @@ class Subscriber {
                 return;
             this.restartIce().catch((err) => {
                 logger$2('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -12796,6 +12816,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
@@ -12812,6 +12837,11 @@ class Call {
                     connectionConfig,
                     isDtxEnabled,
                     isRedEnabled,
+                    onUnrecoverableError: () => {
+                        reconnect('full', 'unrecoverable publisher error').catch((err) => {
+                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        });
+                    },
                 });
             }
             if (!this.statsReporter) {
@@ -15383,7 +15413,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.4.0" ;
+            const version = "1.4.2" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };