@stream-io/video-client 0.6.4 → 0.6.5

package/dist/index.cjs.js

@@ -6607,6 +6607,14 @@ exports.CallingState = void 0;
      */
     CallingState["OFFLINE"] = "offline";
 })(exports.CallingState || (exports.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.
@@ -6921,19 +6929,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: {
@@ -7375,7 +7383,9 @@ class StreamVideoWriteableStateStore {
                     if (call.state.callingState === exports.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);
                     });
                 }
@@ -8627,10 +8637,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);
@@ -8879,13 +8889,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' });
             }
         }
     };
@@ -8899,7 +8909,7 @@ const watchCallEnded = (call) => {
         if (callingState === exports.CallingState.RINGING ||
             callingState === exports.CallingState.JOINED ||
             callingState === exports.CallingState.JOINING) {
-            await call.leave();
+            await call.leave({ reason: 'call.ended event received' });
         }
     };
 };
@@ -8975,7 +8985,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);
             });
         }
@@ -10621,13 +10631,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) => {
@@ -11453,7 +11464,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 === exports.CallingState.LEFT) {
                 throw new Error('Cannot leave call that has already been left.');
@@ -11482,7 +11493,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(exports.CallingState.LEFT);
@@ -11657,7 +11668,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 === exports.CallingState.MIGRATING ||
                     currentState === exports.CallingState.RECONNECTING) {
@@ -11679,7 +11690,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
@@ -11695,7 +11706,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,
@@ -11703,7 +11714,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
@@ -11742,7 +11753,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);
                     });
                 });
@@ -11772,7 +11783,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(exports.CallingState.RECONNECTING_FAILED);
                         });
@@ -11800,7 +11811,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) {
@@ -11909,7 +11920,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);
                         });
                     }
@@ -11962,7 +11973,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 {
@@ -12481,7 +12492,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);
@@ -12700,7 +12711,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(
@@ -14382,7 +14393,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}`);
         };
@@ -14845,7 +14856,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,