@stream-io/video-client 1.23.1 → 1.23.3

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.23.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.23.2...@stream-io/video-client-1.23.3) (2025-06-02)
+
+- remove TODO ([9cfea4b](https://github.com/GetStream/stream-video-js/commit/9cfea4b54284cdd680a6d666436dedc5fd8956c3))
+
+### Bug Fixes
+
+- inconsistent device state if applySettingsToStream fails ([#1808](https://github.com/GetStream/stream-video-js/issues/1808)) ([73d66c2](https://github.com/GetStream/stream-video-js/commit/73d66c2eaa7eca52b9d41b39f8f9fd0a0ce240ef))
+- test ([e0b93aa](https://github.com/GetStream/stream-video-js/commit/e0b93aaa13f22f0db30b61e6230aff40ba8fd92a))
+- use AudioContext for Safari ([#1810](https://github.com/GetStream/stream-video-js/issues/1810)) ([63542f4](https://github.com/GetStream/stream-video-js/commit/63542f419efa475c7acf50f053621ace74a1eff4))
+
+## [1.23.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.23.1...@stream-io/video-client-1.23.2) (2025-05-22)
+
+### Bug Fixes
+
+- rpc error tracing ([#1801](https://github.com/GetStream/stream-video-js/issues/1801)) ([a9e86d5](https://github.com/GetStream/stream-video-js/commit/a9e86d5e51e72b15d044e012f5fcc5a44907c325))
+
 ## [1.23.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.23.0...@stream-io/video-client-1.23.1) (2025-05-21)
 
 ### Bug Fixes

package/dist/index.browser.es.js

@@ -4,7 +4,7 @@ import { ServiceType, stackIntercept, RpcError } from '@protobuf-ts/runtime-rpc'
 import axios from 'axios';
 export { AxiosError } from 'axios';
 import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transport';
-import { ReplaySubject, combineLatest, BehaviorSubject, map, shareReplay, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, fromEventPattern, startWith, concatMap, merge, from, fromEvent, debounceTime, pairwise, of } from 'rxjs';
+import { ReplaySubject, combineLatest, BehaviorSubject, shareReplay, map, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, fromEventPattern, startWith, concatMap, merge, from, fromEvent, debounceTime, pairwise, of } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
 import { parse } from 'sdp-transform';
 
@@ -3411,22 +3411,18 @@ const withHeaders = (headers) => {
 const withRequestLogger = (logger, level) => {
     return {
         interceptUnary: (next, method, input, options) => {
-            let invocation;
-            try {
-                invocation = next(method, input, options);
-            }
-            finally {
-                logger(level, `Invoked SFU RPC method ${method.name}`, {
-                    request: invocation?.request,
-                    headers: invocation?.requestHeaders,
-                    response: invocation?.response,
-                });
-            }
+            const invocation = next(method, input, options);
+            logger(level, `Invoked SFU RPC method ${method.name}`, {
+                request: invocation.request,
+                headers: invocation.requestHeaders,
+                response: invocation.response,
+            });
             return invocation;
         },
     };
 };
 const withRequestTracer = (trace) => {
+    const traceError = (name, input, err) => trace(`${name}OnFailure`, [err, input]);
     const exclusions = {
         SendStats: true,
     };
@@ -3435,14 +3431,14 @@ const withRequestTracer = (trace) => {
             if (exclusions[method.name]) {
                 return next(method, input, options);
             }
-            try {
-                trace(method.name, input);
-                return next(method, input, options);
-            }
-            catch (err) {
-                trace(`${method.name}OnFailure`, [input, err]);
-                throw err;
-            }
+            trace(method.name, input);
+            const unaryCall = next(method, input, options);
+            unaryCall.then((invocation) => {
+                const err = invocation.response?.error;
+                if (err)
+                    traceError(method.name, input, err);
+            }, (err) => traceError(method.name, input, err));
+            return unaryCall;
         },
     };
 };
@@ -5035,6 +5031,9 @@ class CallState {
                 return nextQueue.slice(-maxVisibleCaptions);
             });
         };
+        this.rawParticipants$ = this.participantsSubject
+            .asObservable()
+            .pipe(shareReplay({ bufferSize: 1, refCount: true }));
         this.participants$ = this.participantsSubject.asObservable().pipe(
         // maintain stable-sort by mutating the participants stored
         // in the original subject
@@ -5208,6 +5207,12 @@ class CallState {
     get participants() {
         return this.getCurrentValue(this.participants$);
     }
+    /**
+     * The stable list of participants in the current call, unsorted.
+     */
+    get rawParticipants() {
+        return this.getCurrentValue(this.rawParticipants$);
+    }
     /**
      * The local participant in the current call.
      */
@@ -5680,7 +5685,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.23.1";
+const version = "1.23.3";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8437,6 +8442,20 @@ class DynascaleManager {
                     true,
             };
         }), shareReplay(1));
+        /**
+         * Disposes the allocated resources and closes the audio context if it was created.
+         */
+        this.dispose = async () => {
+            if (this.pendingSubscriptionsUpdate) {
+                clearTimeout(this.pendingSubscriptionsUpdate);
+            }
+            const context = this.getOrCreateAudioContext();
+            if (context && context.state !== 'closed') {
+                document.removeEventListener('click', this.resumeAudioContext);
+                await context.close();
+                this.audioContext = undefined;
+            }
+        };
         this.setVideoTrackSubscriptionOverrides = (override, sessionIds) => {
             if (!sessionIds) {
                 return setCurrentValue(this.videoTrackSubscriptionOverridesSubject, override ? { [globalOverrideKey]: override } : {});
@@ -8552,7 +8571,7 @@ class DynascaleManager {
                 });
                 this.applyTrackSubscriptions(debounceType);
             };
-            const participant$ = this.callState.participants$.pipe(map((participants) => participants.find((participant) => participant.sessionId === sessionId)), takeWhile((participant) => !!participant), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+            const participant$ = this.callState.participants$.pipe(map((ps) => ps.find((p) => p.sessionId === sessionId)), takeWhile((participant) => !!participant), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
             /**
              * Since the video elements are now being removed from the DOM (React SDK) upon
              * visibility change, this subscription is not in use an stays here only for the
@@ -8680,7 +8699,24 @@ class DynascaleManager {
             const participant = this.callState.findParticipantBySessionId(sessionId);
             if (!participant || participant.isLocalParticipant)
                 return;
-            const participant$ = this.callState.participants$.pipe(map((participants) => participants.find((p) => p.sessionId === sessionId)), takeWhile((p) => !!p), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+            const participant$ = this.callState.participants$.pipe(map((ps) => ps.find((p) => p.sessionId === sessionId)), takeWhile((p) => !!p), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+            const updateSinkId = (deviceId, audioContext) => {
+                if (!deviceId)
+                    return;
+                if ('setSinkId' in audioElement) {
+                    audioElement.setSinkId(deviceId).catch((e) => {
+                        this.logger('warn', `Can't to set AudioElement sinkId`, e);
+                    });
+                }
+                if (audioContext && 'setSinkId' in audioContext) {
+                    // @ts-expect-error setSinkId is not available in all browsers
+                    audioContext.setSinkId(deviceId).catch((e) => {
+                        this.logger('warn', `Can't to set AudioContext sinkId`, e);
+                    });
+                }
+            };
+            let sourceNode = undefined;
+            let gainNode = undefined;
             const updateMediaStreamSubscription = participant$
                 .pipe(distinctUntilKeyChanged(trackType === 'screenShareAudioTrack'
                 ? 'screenShareAudioStream'
@@ -8693,40 +8729,82 @@ class DynascaleManager {
                     return;
                 setTimeout(() => {
                     audioElement.srcObject = source ?? null;
-                    if (audioElement.srcObject) {
+                    if (!source)
+                        return;
+                    // Safari has a special quirk that prevents playing audio until the user
+                    // interacts with the page or focuses on the tab where the call happens.
+                    // This is a workaround for the issue where:
+                    // - A and B are in a call
+                    // - A switches to another tab
+                    // - B mutes their microphone and unmutes it
+                    // - A does not hear B's unmuted audio until they focus the tab
+                    const audioContext = this.getOrCreateAudioContext();
+                    if (audioContext) {
+                        // we will play audio through the audio context in Safari
+                        audioElement.muted = true;
+                        sourceNode?.disconnect();
+                        sourceNode = audioContext.createMediaStreamSource(source);
+                        gainNode ?? (gainNode = audioContext.createGain());
+                        gainNode.gain.value = p.audioVolume ?? this.speaker.state.volume;
+                        sourceNode.connect(gainNode).connect(audioContext.destination);
+                        this.resumeAudioContext();
+                    }
+                    else {
+                        // we will play audio directly through the audio element in other browsers
+                        audioElement.muted = false;
                         audioElement.play().catch((e) => {
-                            this.logger('warn', `Failed to play stream`, e);
+                            this.logger('warn', `Failed to play audio stream`, e);
                         });
-                        // audio output device shall be set after the audio element is played
-                        // otherwise, the browser will not pick it up, and will always
-                        // play audio through the system's default device
-                        const { selectedDevice } = this.speaker.state;
-                        if (selectedDevice && 'setSinkId' in audioElement) {
-                            audioElement.setSinkId(selectedDevice);
-                        }
                     }
+                    const { selectedDevice } = this.speaker.state;
+                    if (selectedDevice)
+                        updateSinkId(selectedDevice, audioContext);
                 });
             });
             const sinkIdSubscription = !('setSinkId' in audioElement)
                 ? null
                 : this.speaker.state.selectedDevice$.subscribe((deviceId) => {
-                    if (deviceId) {
-                        audioElement.setSinkId(deviceId);
-                    }
+                    const audioContext = this.getOrCreateAudioContext();
+                    updateSinkId(deviceId, audioContext);
                 });
             const volumeSubscription = combineLatest([
                 this.speaker.state.volume$,
                 participant$.pipe(distinctUntilKeyChanged('audioVolume')),
             ]).subscribe(([volume, p]) => {
-                audioElement.volume = p.audioVolume ?? volume;
+                const participantVolume = p.audioVolume ?? volume;
+                audioElement.volume = participantVolume;
+                if (gainNode)
+                    gainNode.gain.value = participantVolume;
             });
             audioElement.autoplay = true;
             return () => {
                 sinkIdSubscription?.unsubscribe();
                 volumeSubscription.unsubscribe();
                 updateMediaStreamSubscription.unsubscribe();
+                audioElement.srcObject = null;
+                sourceNode?.disconnect();
+                gainNode?.disconnect();
             };
         };
+        this.getOrCreateAudioContext = () => {
+            if (this.audioContext || !isSafari())
+                return this.audioContext;
+            const context = new AudioContext();
+            if (context.state === 'suspended') {
+                document.addEventListener('click', this.resumeAudioContext);
+            }
+            return (this.audioContext = context);
+        };
+        this.resumeAudioContext = () => {
+            if (this.audioContext?.state === 'suspended') {
+                this.audioContext
+                    .resume()
+                    .catch((err) => this.logger('warn', `Can't resume audio context`, err))
+                    .then(() => {
+                    document.removeEventListener('click', this.resumeAudioContext);
+                });
+            }
+        };
         this.callState = callState;
         this.speaker = speaker;
     }
@@ -9509,10 +9587,22 @@ class InputMediaDeviceManager {
         }
     }
     async applySettingsToStream() {
-        await withCancellation(this.statusChangeConcurrencyTag, async () => {
+        await withCancellation(this.statusChangeConcurrencyTag, async (signal) => {
             if (this.enabled) {
-                await this.muteStream();
-                await this.unmuteStream();
+                try {
+                    await this.muteStream();
+                    this.state.setStatus('disabled');
+                    if (signal.aborted) {
+                        return;
+                    }
+                    await this.unmuteStream();
+                    this.state.setStatus('enabled');
+                }
+                finally {
+                    if (!signal.aborted) {
+                        this.state.setPendingStatus(this.state.status);
+                    }
+                }
             }
         });
     }
@@ -9578,130 +9668,122 @@ class InputMediaDeviceManager {
         this.logger('debug', 'Starting stream');
         let stream;
         let rootStream;
-        try {
-            if (this.state.mediaStream &&
-                this.getTracks().every((t) => t.readyState === 'live')) {
-                stream = this.state.mediaStream;
-                this.enableTracks();
-            }
-            else {
-                const defaultConstraints = this.state.defaultConstraints;
-                const constraints = {
-                    ...defaultConstraints,
-                    deviceId: this.state.selectedDevice
-                        ? { exact: this.state.selectedDevice }
-                        : undefined,
-                };
-                /**
-                 * Chains two media streams together.
-                 *
-                 * In our case, filters MediaStreams are derived from their parent MediaStream.
-                 * However, once a child filter's track is stopped,
-                 * the tracks of the parent MediaStream aren't automatically stopped.
-                 * This leads to a situation where the camera indicator light is still on
-                 * even though the user stopped publishing video.
-                 *
-                 * This function works around this issue by stopping the parent MediaStream's tracks
-                 * as well once the child filter's tracks are stopped.
-                 *
-                 * It works by patching the stop() method of the child filter's tracks to also stop
-                 * the parent MediaStream's tracks of the same type. Here we assume that
-                 * the parent MediaStream has only one track of each type.
-                 *
-                 * @param parentStream the parent MediaStream. Omit for the root stream.
-                 */
-                const chainWith = (parentStream) => async (filterStream) => {
-                    if (!parentStream)
-                        return filterStream;
-                    // TODO OL: take care of track.enabled property as well
-                    const parent = await parentStream;
-                    filterStream.getTracks().forEach((track) => {
-                        const originalStop = track.stop;
-                        track.stop = function stop() {
-                            originalStop.call(track);
-                            parent.getTracks().forEach((parentTrack) => {
-                                if (parentTrack.kind === track.kind) {
-                                    parentTrack.stop();
-                                }
-                            });
-                        };
-                    });
-                    parent.getTracks().forEach((parentTrack) => {
-                        // When the parent stream abruptly ends, we propagate the event
-                        // to the filter stream.
-                        // This usually happens when the camera/microphone permissions
-                        // are revoked or when the device is disconnected.
-                        const handleParentTrackEnded = () => {
-                            filterStream.getTracks().forEach((track) => {
-                                if (parentTrack.kind !== track.kind)
-                                    return;
-                                track.stop();
-                                track.dispatchEvent(new Event('ended')); // propagate the event
-                            });
-                        };
-                        parentTrack.addEventListener('ended', handleParentTrackEnded);
-                        this.subscriptions.push(() => {
-                            parentTrack.removeEventListener('ended', handleParentTrackEnded);
-                        });
-                    });
+        if (this.state.mediaStream &&
+            this.getTracks().every((t) => t.readyState === 'live')) {
+            stream = this.state.mediaStream;
+            this.enableTracks();
+        }
+        else {
+            const defaultConstraints = this.state.defaultConstraints;
+            const constraints = {
+                ...defaultConstraints,
+                deviceId: this.state.selectedDevice
+                    ? { exact: this.state.selectedDevice }
+                    : undefined,
+            };
+            /**
+             * Chains two media streams together.
+             *
+             * In our case, filters MediaStreams are derived from their parent MediaStream.
+             * However, once a child filter's track is stopped,
+             * the tracks of the parent MediaStream aren't automatically stopped.
+             * This leads to a situation where the camera indicator light is still on
+             * even though the user stopped publishing video.
+             *
+             * This function works around this issue by stopping the parent MediaStream's tracks
+             * as well once the child filter's tracks are stopped.
+             *
+             * It works by patching the stop() method of the child filter's tracks to also stop
+             * the parent MediaStream's tracks of the same type. Here we assume that
+             * the parent MediaStream has only one track of each type.
+             *
+             * @param parentStream the parent MediaStream. Omit for the root stream.
+             */
+            const chainWith = (parentStream) => async (filterStream) => {
+                if (!parentStream)
                     return filterStream;
-                };
-                // the rootStream represents the stream coming from the actual device
-                // e.g. camera or microphone stream
-                rootStream = this.getStream(constraints);
-                // we publish the last MediaStream of the chain
-                stream = await this.filters.reduce((parent, entry) => parent
-                    .then((inputStream) => {
-                    const { stop, output } = entry.start(inputStream);
-                    entry.stop = stop;
-                    return output;
-                })
-                    .then(chainWith(parent), (error) => {
-                    this.logger('warn', 'Filter failed to start and will be ignored', error);
-                    return parent;
-                }), rootStream);
-            }
-            if (this.call.state.callingState === CallingState.JOINED) {
-                await this.publishStream(stream);
-            }
-            if (this.state.mediaStream !== stream) {
-                this.state.setMediaStream(stream, await rootStream);
-                const handleTrackEnded = async () => {
-                    await this.statusChangeSettled();
-                    if (this.enabled) {
-                        this.isTrackStoppedDueToTrackEnd = true;
-                        setTimeout(() => {
-                            this.isTrackStoppedDueToTrackEnd = false;
-                        }, 2000);
-                        await this.disable();
-                    }
-                };
-                const createTrackMuteHandler = (muted) => () => {
-                    if (!isMobile() || this.trackType !== TrackType.VIDEO)
-                        return;
-                    this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
-                        this.logger('warn', 'Error while notifying track mute state', err);
-                    });
-                };
-                stream.getTracks().forEach((track) => {
-                    const muteHandler = createTrackMuteHandler(true);
-                    const unmuteHandler = createTrackMuteHandler(false);
-                    track.addEventListener('mute', muteHandler);
-                    track.addEventListener('unmute', unmuteHandler);
-                    track.addEventListener('ended', handleTrackEnded);
+                // TODO OL: take care of track.enabled property as well
+                const parent = await parentStream;
+                filterStream.getTracks().forEach((track) => {
+                    const originalStop = track.stop;
+                    track.stop = function stop() {
+                        originalStop.call(track);
+                        parent.getTracks().forEach((parentTrack) => {
+                            if (parentTrack.kind === track.kind) {
+                                parentTrack.stop();
+                            }
+                        });
+                    };
+                });
+                parent.getTracks().forEach((parentTrack) => {
+                    // When the parent stream abruptly ends, we propagate the event
+                    // to the filter stream.
+                    // This usually happens when the camera/microphone permissions
+                    // are revoked or when the device is disconnected.
+                    const handleParentTrackEnded = () => {
+                        filterStream.getTracks().forEach((track) => {
+                            if (parentTrack.kind !== track.kind)
+                                return;
+                            track.stop();
+                            track.dispatchEvent(new Event('ended')); // propagate the event
+                        });
+                    };
+                    parentTrack.addEventListener('ended', handleParentTrackEnded);
                     this.subscriptions.push(() => {
-                        track.removeEventListener('mute', muteHandler);
-                        track.removeEventListener('unmute', unmuteHandler);
-                        track.removeEventListener('ended', handleTrackEnded);
+                        parentTrack.removeEventListener('ended', handleParentTrackEnded);
                     });
                 });
-            }
+                return filterStream;
+            };
+            // the rootStream represents the stream coming from the actual device
+            // e.g. camera or microphone stream
+            rootStream = this.getStream(constraints);
+            // we publish the last MediaStream of the chain
+            stream = await this.filters.reduce((parent, entry) => parent
+                .then((inputStream) => {
+                const { stop, output } = entry.start(inputStream);
+                entry.stop = stop;
+                return output;
+            })
+                .then(chainWith(parent), (error) => {
+                this.logger('warn', 'Filter failed to start and will be ignored', error);
+                return parent;
+            }), rootStream);
         }
-        catch (err) {
-            if (rootStream) {
-                disposeOfMediaStream(await rootStream);
-            }
-            throw err;
+        if (this.call.state.callingState === CallingState.JOINED) {
+            await this.publishStream(stream);
+        }
+        if (this.state.mediaStream !== stream) {
+            this.state.setMediaStream(stream, await rootStream);
+            const handleTrackEnded = async () => {
+                await this.statusChangeSettled();
+                if (this.enabled) {
+                    this.isTrackStoppedDueToTrackEnd = true;
+                    setTimeout(() => {
+                        this.isTrackStoppedDueToTrackEnd = false;
+                    }, 2000);
+                    await this.disable();
+                }
+            };
+            const createTrackMuteHandler = (muted) => () => {
+                if (!isMobile() || this.trackType !== TrackType.VIDEO)
+                    return;
+                this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
+                    this.logger('warn', 'Error while notifying track mute state', err);
+                });
+            };
+            stream.getTracks().forEach((track) => {
+                const muteHandler = createTrackMuteHandler(true);
+                const unmuteHandler = createTrackMuteHandler(false);
+                track.addEventListener('mute', muteHandler);
+                track.addEventListener('unmute', unmuteHandler);
+                track.addEventListener('ended', handleTrackEnded);
+                this.subscriptions.push(() => {
+                    track.removeEventListener('mute', muteHandler);
+                    track.removeEventListener('unmute', unmuteHandler);
+                    track.removeEventListener('ended', handleTrackEnded);
+                });
+            });
         }
     }
     get mediaDeviceKind() {
@@ -10428,6 +10510,7 @@ class MicrophoneManager extends InputMediaDeviceManager {
             await this.disableNoiseCancellation().catch((err) => {
                 this.logger('warn', 'Failed to disable noise cancellation', err);
             });
+            throw e;
         }
     }
     /**
@@ -11064,6 +11147,7 @@ class Call {
                 await this.sfuClient?.leaveAndClose(message ?? reason ?? 'user is leaving the call');
                 this.sfuClient = undefined;
                 this.dynascaleManager.setSfuClient(undefined);
+                await this.dynascaleManager.dispose();
                 this.state.setCallingState(CallingState.LEFT);
                 this.state.setParticipants([]);
                 this.state.dispose();
@@ -13787,7 +13871,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.23.1", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.23.3", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),