@stream-io/video-client 0.6.4 → 0.6.5

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [0.6.5](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.6.4...@stream-io/video-client-0.6.5) (2024-03-29)
+
+
+### Bug Fixes
+
+* various bug fixes and improvements ([#1300](https://github.com/GetStream/stream-video-js/issues/1300)) ([a6186e2](https://github.com/GetStream/stream-video-js/commit/a6186e2406fd0b3e0aaa51a4222fa2e24e9dfac3))
+
 ### [0.6.4](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.6.3...@stream-io/video-client-0.6.4) (2024-03-28)
 
 

package/dist/index.browser.es.js

@@ -6584,6 +6584,14 @@ var CallingState;
      */
     CallingState["OFFLINE"] = "offline";
 })(CallingState || (CallingState = {}));
+/**
+ * Returns the default egress object - when no egress data is available.
+ */
+const defaultEgress = {
+    broadcasting: false,
+    hls: { playlist_url: '' },
+    rtmps: [],
+};
 /**
  * Holds the state of the current call.
  * @react You don't have to use this class directly, as we are exposing the state through Hooks.
@@ -6898,19 +6906,19 @@ class CallState {
             ]);
         };
         this.updateFromHLSBroadcastStopped = () => {
-            this.setCurrentValue(this.egressSubject, (egress) => ({
+            this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
                 ...egress,
                 broadcasting: false,
             }));
         };
         this.updateFromHLSBroadcastingFailed = () => {
-            this.setCurrentValue(this.egressSubject, (egress) => ({
+            this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
                 ...egress,
                 broadcasting: false,
             }));
         };
         this.updateFromHLSBroadcastStarted = (event) => {
-            this.setCurrentValue(this.egressSubject, (egress) => ({
+            this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
                 ...egress,
                 broadcasting: true,
                 hls: {
@@ -7352,7 +7360,9 @@ class StreamVideoWriteableStateStore {
                     if (call.state.callingState === CallingState.LEFT)
                         continue;
                     logger('info', `User disconnected, leaving call: ${call.cid}`);
-                    await call.leave().catch((err) => {
+                    await call
+                        .leave({ reason: 'client.disconnectUser() called' })
+                        .catch((err) => {
                         logger('error', `Error leaving call: ${call.cid}`, err);
                     });
                 }
@@ -8604,10 +8614,10 @@ class StreamSfuClient {
         this.isFastReconnecting = false;
         this.pingIntervalInMs = 10 * 1000;
         this.unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
-        this.close = (code = StreamSfuClient.NORMAL_CLOSURE, reason = 'js-client: requested signal connection close') => {
-            this.logger('debug', 'Closing SFU WS connection', code, reason);
+        this.close = (code, reason) => {
+            this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
             if (this.signalWs.readyState !== this.signalWs.CLOSED) {
-                this.signalWs.close(code, reason);
+                this.signalWs.close(code, `js-client: ${reason}`);
             }
             this.unsubscribeIceTrickle();
             clearInterval(this.keepAliveInterval);
@@ -8856,13 +8866,13 @@ const watchCallRejected = (call) => {
                 .every((m) => rejectedBy[m.user_id]);
             if (everyoneElseRejected) {
                 call.logger('info', 'everyone rejected, leaving the call');
-                await call.leave();
+                await call.leave({ reason: 'ring: everyone rejected' });
             }
         }
         else {
             if (rejectedBy[eventCall.created_by.id]) {
                 call.logger('info', 'call creator rejected, leaving call');
-                await call.leave();
+                await call.leave({ reason: 'ring: creator rejected' });
             }
         }
     };
@@ -8876,7 +8886,7 @@ const watchCallEnded = (call) => {
         if (callingState === CallingState.RINGING ||
             callingState === CallingState.JOINED ||
             callingState === CallingState.JOINING) {
-            await call.leave();
+            await call.leave({ reason: 'call.ended event received' });
         }
     };
 };
@@ -8952,7 +8962,7 @@ const watchLiveEnded = (dispatcher, call) => {
         if (e.error && e.error.code !== ErrorCode.LIVE_ENDED)
             return;
         if (!call.permissionsContext.hasPermission(OwnCapability.JOIN_BACKSTAGE)) {
-            call.leave().catch((err) => {
+            call.leave({ reason: 'live ended' }).catch((err) => {
                 logger$1('error', 'Failed to leave call after live ended', err);
             });
         }
@@ -10598,13 +10608,14 @@ class InputMediaDeviceManagerState {
                 return notifyGranted();
             }
             let permissionState;
-            const notify = () => subscriber.next(
-            // In Safari, the `change` event doesn't reliably emit and hence,
-            // permissionState stays in 'prompt' state forever.
-            // Instead of checking if a permission is granted, we check if it isn't denied
-            isSafari()
-                ? permissionState.state !== 'denied'
-                : permissionState.state === 'granted');
+            const notify = () => {
+                subscriber.next(
+                // In some browsers, the 'change' event doesn't reliably emit and hence,
+                // permissionState stays in 'prompt' state forever.
+                // Typically, this happens when a user grants one-time permission.
+                // Instead of checking if a permission is granted, we check if it isn't denied
+                permissionState.state !== 'denied');
+            };
             navigator.permissions
                 .query({ name: this.permissionName })
                 .then((permissionStatus) => {
@@ -11430,7 +11441,7 @@ class Call {
         /**
          * Leave the call and stop the media streams that were published by the call.
          */
-        this.leave = async ({ reject = false } = {}) => {
+        this.leave = async ({ reject = false, reason = 'user is leaving the call', } = {}) => {
             const callingState = this.state.callingState;
             if (callingState === CallingState.LEFT) {
                 throw new Error('Cannot leave call that has already been left.');
@@ -11459,7 +11470,7 @@ class Call {
             this.subscriber = undefined;
             this.publisher?.close();
             this.publisher = undefined;
-            this.sfuClient?.close();
+            this.sfuClient?.close(StreamSfuClient.NORMAL_CLOSURE, reason);
             this.sfuClient = undefined;
             this.dispatcher.offAll();
             this.state.setCallingState(CallingState.LEFT);
@@ -11634,7 +11645,7 @@ class Call {
             /**
              * A closure which hides away the re-connection logic.
              */
-            const reconnect = async (strategy = 'full') => {
+            const reconnect = async (strategy, reason) => {
                 const currentState = this.state.callingState;
                 if (currentState === CallingState.MIGRATING ||
                     currentState === CallingState.RECONNECTING) {
@@ -11656,7 +11667,7 @@ class Call {
                 // we'll need it for restoring the previous publishing state later
                 const localParticipant = this.state.localParticipant;
                 if (strategy === 'fast') {
-                    sfuClient.close(StreamSfuClient.ERROR_CONNECTION_BROKEN, 'js-client: attempting fast reconnect');
+                    sfuClient.close(StreamSfuClient.ERROR_CONNECTION_BROKEN, `attempting fast reconnect: ${reason}`);
                 }
                 else if (strategy === 'full') {
                     // in migration or recovery scenarios, we don't want to
@@ -11672,7 +11683,7 @@ class Call {
                     this.sfuStatsReporter?.stop();
                     this.sfuStatsReporter = undefined;
                     // clean up current connection
-                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'js-client: attempting full reconnect');
+                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, `attempting full reconnect: ${reason}`);
                 }
                 await this.join({
                     ...data,
@@ -11680,7 +11691,7 @@ class Call {
                 });
                 // clean up previous connection
                 if (strategy === 'migrate') {
-                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'js-client: attempting migration');
+                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'attempting migration');
                 }
                 this.logger('info', `[Rejoin]: Attempt ${this.reconnectAttempts} successful!`);
                 // we shouldn't be republishing the streams if we're migrating
@@ -11719,7 +11730,7 @@ class Call {
                 const unregisterGoAway = this.dispatcher.on('goAway', (event) => {
                     const { reason } = event;
                     this.logger('info', `[Migration]: Going away from SFU... Reason: ${GoAwayReason[reason]}`);
-                    reconnect('migrate').catch((err) => {
+                    reconnect('migrate', GoAwayReason[reason]).catch((err) => {
                         this.logger('warn', `[Migration]: Failed to migrate to another SFU.`, err);
                     });
                 });
@@ -11749,7 +11760,7 @@ class Call {
                     if (this.reconnectAttempts < this.maxReconnectAttempts) {
                         sfuClient.isFastReconnecting = this.reconnectAttempts === 0;
                         const strategy = sfuClient.isFastReconnecting ? 'fast' : 'full';
-                        reconnect(strategy).catch((err) => {
+                        reconnect(strategy, `SFU closed the WS with code: ${e.code}`).catch((err) => {
                             this.logger('error', `[Rejoin]: ${strategy} rejoin failed for ${this.reconnectAttempts} times. Giving up.`, err);
                             this.state.setCallingState(CallingState.RECONNECTING_FAILED);
                         });
@@ -11777,7 +11788,7 @@ class Call {
                 do {
                     try {
                         sfuClient.isFastReconnecting = isFirstReconnectAttempt;
-                        await reconnect(isFirstReconnectAttempt ? 'fast' : 'full');
+                        await reconnect(isFirstReconnectAttempt ? 'fast' : 'full', 'Network: online');
                         return; // break the loop if rejoin is successful
                     }
                     catch (err) {
@@ -11886,7 +11897,7 @@ class Call {
                     }
                     else if (previousSfuClient?.isFastReconnecting) {
                         // reconnection wasn't possible, so we need to do a full rejoin
-                        return await reconnect('full').catch((err) => {
+                        return await reconnect('full', 're-attempting').catch((err) => {
                             this.logger('error', `[Rejoin]: Rejoin failed forced full rejoin.`, err);
                         });
                     }
@@ -11939,7 +11950,7 @@ class Call {
                 // join failed, try to rejoin
                 if (this.reconnectAttempts < this.maxReconnectAttempts) {
                     this.logger('error', `[Rejoin]: Rejoin ${this.reconnectAttempts} failed.`, err);
-                    await reconnect();
+                    await reconnect('full', 'previous attempt failed');
                     this.logger('info', `[Rejoin]: Rejoin ${this.reconnectAttempts} successful!`);
                 }
                 else {
@@ -12458,7 +12469,7 @@ class Call {
                     return;
                 clearTimeout(this.dropTimeout);
                 this.dropTimeout = setTimeout(() => {
-                    this.leave().catch((err) => {
+                    this.leave({ reason: 'ring: timeout' }).catch((err) => {
                         this.logger('error', 'Failed to drop call', err);
                     });
                 }, timeoutInMs);
@@ -12677,7 +12688,7 @@ class Call {
             const currentUserId = this.currentUserId;
             if (currentUserId && blockedUserIds.includes(currentUserId)) {
                 this.logger('info', 'Leaving call because of being blocked');
-                await this.leave();
+                await this.leave({ reason: 'user blocked' });
             }
         }));
         this.leaveCallHooks.add(
@@ -14358,7 +14369,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.6.4" ;
+            const version = "0.6.5" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -14821,7 +14832,7 @@ class StreamVideoClient {
             // if `call.created` was received before `call.ring`.
             // In that case, we cleanup the already tracked call.
             const prevCall = this.writeableStateStore.findCall(call.type, call.id);
-            await prevCall?.leave();
+            await prevCall?.leave({ reason: 'cleaning-up in call.ring' });
             // we create a new call
             const theCall = new Call({
                 streamClient: this.streamClient,