@stream-io/video-client 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [1.0.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.0.2...@stream-io/video-client-1.0.3) (2024-05-13)
+
+
+### Bug Fixes
+
+* improve error handling across the SDK ([#1350](https://github.com/GetStream/stream-video-js/issues/1350)) ([ac0ae3b](https://github.com/GetStream/stream-video-js/commit/ac0ae3b7d5da91152d0f41a203b73e6c99c42ff9))
+
+### [1.0.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.0.1...@stream-io/video-client-1.0.2) (2024-05-13)
+
+
+### Bug Fixes
+
+* optimistically toggle device status ([#1342](https://github.com/GetStream/stream-video-js/issues/1342)) ([2e4e470](https://github.com/GetStream/stream-video-js/commit/2e4e470347fce7c7499dd21a931e5dec74bf9618))
+
 ### [1.0.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.0.0...@stream-io/video-client-1.0.1) (2024-05-07)
 
 

package/dist/index.browser.es.js

@@ -8399,15 +8399,19 @@ class Publisher {
                 return getPreferredCodecs('audio', preferredCodec ?? defaultAudioCodec, codecToRemove);
             }
         };
-        this.onIceCandidate = async (e) => {
+        this.onIceCandidate = (e) => {
             const { candidate } = e;
             if (!candidate) {
                 logger$3('debug', 'null ice candidate');
                 return;
             }
-            await this.sfuClient.iceTrickle({
+            this.sfuClient
+                .iceTrickle({
                 iceCandidate: getIceCandidate(candidate),
                 peerType: PeerType.PUBLISHER_UNSPECIFIED,
+            })
+                .catch((err) => {
+                logger$3('warn', `ICETrickle failed`, err);
             });
         };
         /**
@@ -8448,8 +8452,8 @@ class Publisher {
             }
             await this.negotiate({ iceRestart: true });
         };
-        this.onNegotiationNeeded = async () => {
-            await this.negotiate();
+        this.onNegotiationNeeded = () => {
+            this.negotiate().catch((err) => logger$3('warn', `Negotiation failed.`, err));
         };
         /**
          * Initiates a new offer/answer exchange with the currently connected SFU.
@@ -8639,10 +8643,12 @@ class Publisher {
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
         this.iceRestartDelay = iceRestartDelay;
-        this.unsubscribeOnIceRestart = dispatcher.on('iceRestart', async (iceRestart) => {
+        this.unsubscribeOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
                 return;
-            await this.restartIce();
+            this.restartIce().catch((err) => {
+                logger$3('warn', `ICERestart failed`, err);
+            });
         });
     }
 }
@@ -8836,15 +8842,19 @@ class Subscriber {
                 [streamKindProp]: primaryStream,
             });
         };
-        this.onIceCandidate = async (e) => {
+        this.onIceCandidate = (e) => {
             const { candidate } = e;
             if (!candidate) {
                 logger$2('debug', 'null ice candidate');
                 return;
             }
-            await this.sfuClient.iceTrickle({
+            this.sfuClient
+                .iceTrickle({
                 iceCandidate: getIceCandidate(candidate),
                 peerType: PeerType.SUBSCRIBER,
+            })
+                .catch((err) => {
+                logger$2('warn', `ICETrickle failed`, err);
             });
         };
         this.negotiate = async (subscriberOffer) => {
@@ -8916,13 +8926,17 @@ class Subscriber {
         this.state = state;
         this.iceRestartDelay = iceRestartDelay;
         this.pc = this.createPeerConnection(connectionConfig);
-        this.unregisterOnSubscriberOffer = dispatcher.on('subscriberOffer', async (subscriberOffer) => {
-            await this.negotiate(subscriberOffer);
+        this.unregisterOnSubscriberOffer = dispatcher.on('subscriberOffer', (subscriberOffer) => {
+            this.negotiate(subscriberOffer).catch((err) => {
+                logger$2('warn', `Negotiation failed.`, err);
+            });
         });
-        this.unregisterOnIceRestart = dispatcher.on('iceRestart', async (iceRestart) => {
+        this.unregisterOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.SUBSCRIBER)
                 return;
-            await this.restartIce();
+            this.restartIce().catch((err) => {
+                logger$2('warn', `ICERestart failed`, err);
+            });
         });
     }
 }
@@ -10869,18 +10883,27 @@ class InputMediaDeviceManager {
      * Starts stream.
      */
     async enable() {
-        if (this.state.status === 'enabled')
+        if (this.state.optimisticStatus === 'enabled') {
+            await this.statusChangePromise;
             return;
-        this.enablePromise = this.unmuteStream();
-        try {
-            await this.enablePromise;
-            this.state.setStatus('enabled');
-            this.enablePromise = undefined;
-        }
-        catch (error) {
-            this.enablePromise = undefined;
-            throw error;
         }
+        const signal = this.nextAbortableStatusChangeRequest('enabled');
+        const doEnable = async () => {
+            if (signal.aborted)
+                return;
+            try {
+                await this.unmuteStream();
+                this.state.setStatus('enabled');
+            }
+            finally {
+                if (!signal.aborted)
+                    this.resetStatusChangeRequest();
+            }
+        };
+        this.statusChangePromise = this.statusChangePromise
+            ? this.statusChangePromise.then(doEnable)
+            : doEnable();
+        await this.statusChangePromise;
     }
     /**
      * Stops or pauses the stream based on state.disableMode
@@ -10888,19 +10911,28 @@ class InputMediaDeviceManager {
      */
     async disable(forceStop = false) {
         this.state.prevStatus = this.state.status;
-        if (!forceStop && this.state.status === 'disabled')
+        if (!forceStop && this.state.optimisticStatus === 'disabled') {
+            await this.statusChangePromise;
             return;
-        const stopTracks = forceStop || this.state.disableMode === 'stop-tracks';
-        this.disablePromise = this.muteStream(stopTracks);
-        try {
-            await this.disablePromise;
-            this.state.setStatus('disabled');
-            this.disablePromise = undefined;
-        }
-        catch (error) {
-            this.disablePromise = undefined;
-            throw error;
         }
+        const stopTracks = forceStop || this.state.disableMode === 'stop-tracks';
+        const signal = this.nextAbortableStatusChangeRequest('disabled');
+        const doDisable = async () => {
+            if (signal.aborted)
+                return;
+            try {
+                await this.muteStream(stopTracks);
+                this.state.setStatus('disabled');
+            }
+            finally {
+                if (!signal.aborted)
+                    this.resetStatusChangeRequest();
+            }
+        };
+        this.statusChangePromise = this.statusChangePromise
+            ? this.statusChangePromise.then(doDisable)
+            : doDisable();
+        await this.statusChangePromise;
     }
     /**
      * If status was previously enabled, it will re-enable the device.
@@ -10916,7 +10948,7 @@ class InputMediaDeviceManager {
      * else it will disable it.
      */
     async toggle() {
-        if (this.state.status === 'enabled') {
+        if (this.state.optimisticStatus === 'enabled') {
             return this.disable();
         }
         else {
@@ -11103,11 +11135,8 @@ class InputMediaDeviceManager {
             this.state.setMediaStream(stream, await rootStream);
             this.getTracks().forEach((track) => {
                 track.addEventListener('ended', async () => {
-                    if (this.enablePromise) {
-                        await this.enablePromise;
-                    }
-                    if (this.disablePromise) {
-                        await this.disablePromise;
+                    if (this.statusChangePromise) {
+                        await this.statusChangePromise;
                     }
                     if (this.state.status === 'enabled') {
                         this.isTrackStoppedDueToTrackEnd = true;
@@ -11137,11 +11166,8 @@ class InputMediaDeviceManager {
             if (!deviceId) {
                 return;
             }
-            if (this.enablePromise) {
-                await this.enablePromise;
-            }
-            if (this.disablePromise) {
-                await this.disablePromise;
+            if (this.statusChangePromise) {
+                await this.statusChangePromise;
             }
             let isDeviceDisconnected = false;
             let isDeviceReplaced = false;
@@ -11175,6 +11201,16 @@ class InputMediaDeviceManager {
     findDeviceInList(devices, deviceId) {
         return devices.find((d) => d.deviceId === deviceId && d.kind === this.mediaDeviceKind);
     }
+    nextAbortableStatusChangeRequest(status) {
+        this.statusChangeAbortController?.abort();
+        this.statusChangeAbortController = new AbortController();
+        this.state.setPendingStatus(status);
+        return this.statusChangeAbortController.signal;
+    }
+    resetStatusChangeRequest() {
+        this.statusChangePromise = undefined;
+        this.statusChangeAbortController = undefined;
+    }
 }
 
 class InputMediaDeviceManagerState {
@@ -11189,6 +11225,7 @@ class InputMediaDeviceManagerState {
         this.disableMode = disableMode;
         this.permissionName = permissionName;
         this.statusSubject = new BehaviorSubject(undefined);
+        this.optimisticStatusSubject = new BehaviorSubject(undefined);
         this.mediaStreamSubject = new BehaviorSubject(undefined);
         this.selectedDeviceSubject = new BehaviorSubject(undefined);
         this.defaultConstraintsSubject = new BehaviorSubject(undefined);
@@ -11207,6 +11244,12 @@ class InputMediaDeviceManagerState {
          * An Observable that emits the device status
          */
         this.status$ = this.statusSubject.asObservable().pipe(distinctUntilChanged());
+        /**
+         * An Observable the reflects the requested device status. Useful for optimistic UIs
+         */
+        this.optimisticStatus$ = this.optimisticStatusSubject
+            .asObservable()
+            .pipe(distinctUntilChanged());
         /**
          * The default constraints for the device.
          */
@@ -11274,6 +11317,12 @@ class InputMediaDeviceManagerState {
     get status() {
         return this.getCurrentValue(this.status$);
     }
+    /**
+     * The requested device status. Useful for optimistic UIs
+     */
+    get optimisticStatus() {
+        return this.getCurrentValue(this.optimisticStatus$);
+    }
     /**
      * The currently selected device
      */
@@ -11293,6 +11342,13 @@ class InputMediaDeviceManagerState {
     setStatus(status) {
         this.setCurrentValue(this.statusSubject, status);
     }
+    /**
+     * @internal
+     * @param pendingStatus
+     */
+    setPendingStatus(pendingStatus) {
+        this.setCurrentValue(this.optimisticStatusSubject, pendingStatus);
+    }
     /**
      * Updates the `mediaStream` state variable.
      *
@@ -11412,9 +11468,9 @@ class CameraManager extends InputMediaDeviceManager {
     async selectTargetResolution(resolution) {
         this.targetResolution.height = resolution.height;
         this.targetResolution.width = resolution.width;
-        if (this.enablePromise) {
+        if (this.statusChangePromise && this.state.optimisticStatus === 'enabled') {
             try {
-                await this.enablePromise;
+                await this.statusChangePromise;
             }
             catch (error) {
                 // couldn't enable device, target resolution will be applied the next time user attempts to start the device
@@ -13446,7 +13502,9 @@ class Call {
         });
         this.leaveCallHooks.add(registerEventHandlers(this, this.state, this.dispatcher));
         this.registerEffects();
-        this.leaveCallHooks.add(createSubscription(this.trackSubscriptionsSubject.pipe(debounce((v) => timer(v.type)), map$1((v) => v.data)), (subscriptions) => this.sfuClient?.updateSubscriptions(subscriptions)));
+        this.leaveCallHooks.add(createSubscription(this.trackSubscriptionsSubject.pipe(debounce((v) => timer(v.type)), map$1((v) => v.data)), (subscriptions) => this.sfuClient?.updateSubscriptions(subscriptions).catch((err) => {
+            this.logger('debug', `Failed to update track subscriptions`, err);
+        })));
         this.camera = new CameraManager(this);
         this.microphone = new MicrophoneManager(this);
         this.speaker = new SpeakerManager(this);
@@ -13555,12 +13613,7 @@ class Call {
     }
     async initCamera(options) {
         // Wait for any in progress camera operation
-        if (this.camera.enablePromise) {
-            await this.camera.enablePromise;
-        }
-        if (this.camera.disablePromise) {
-            await this.camera.disablePromise;
-        }
+        await this.camera.statusChangePromise;
         if (this.state.localParticipant?.videoStream ||
             !this.permissionsContext.hasPermission('send-video')) {
             return;
@@ -13597,12 +13650,7 @@ class Call {
     }
     async initMic(options) {
         // Wait for any in progress mic operation
-        if (this.microphone.enablePromise) {
-            await this.microphone.enablePromise;
-        }
-        if (this.microphone.disablePromise) {
-            await this.microphone.disablePromise;
-        }
+        await this.microphone.statusChangePromise;
         if (this.state.localParticipant?.audioStream ||
             !this.permissionsContext.hasPermission('send-audio')) {
             return;
@@ -15145,7 +15193,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.0.1" ;
+            const version = "1.0.3" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };