@stream-io/video-client 1.28.0 → 1.29.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.29.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.28.1...@stream-io/video-client-1.29.0) (2025-09-09)
+
+### Features
+
+- opt-out from optimistic updates ([#1904](https://github.com/GetStream/stream-video-js/issues/1904)) ([45dba34](https://github.com/GetStream/stream-video-js/commit/45dba34d38dc64f456e37b593e38e420426529f5))
+
+### Bug Fixes
+
+- capabilities and call grants ([#1899](https://github.com/GetStream/stream-video-js/issues/1899)) ([5725dfa](https://github.com/GetStream/stream-video-js/commit/5725dfa29b1e5fdb6fe4e26825ce7b268664d2fa))
+- graceful Axios request config overrides ([#1913](https://github.com/GetStream/stream-video-js/issues/1913)) ([a124099](https://github.com/GetStream/stream-video-js/commit/a124099f984a592750d66ac440ef6c27ae7a02d9))
+
+## [1.28.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.28.0...@stream-io/video-client-1.28.1) (2025-08-22)
+
+### Bug Fixes
+
+- handle pre ended calls on ringing push arrival ([#1897](https://github.com/GetStream/stream-video-js/issues/1897)) ([935e375](https://github.com/GetStream/stream-video-js/commit/935e3756035639c651b3ac4469321a64b8576a0e))
+
 ## [1.28.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.27.5...@stream-io/video-client-1.28.0) (2025-08-21)
 
 ### Features

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, shareReplay, map, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, fromEventPattern, startWith, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, of } from 'rxjs';
+import { ReplaySubject, combineLatest, BehaviorSubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, of } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
 import { parse, write } from 'sdp-transform';
 
@@ -4649,6 +4649,7 @@ class CallState {
         // This happens when the participantJoined event hasn't been received yet.
         // We keep these tracks around until we can associate them with a participant.
         this.orphanedTracks = [];
+        this.callGrantsSubject = new ReplaySubject(1);
         this.logger = getLogger(['CallState']);
         /**
          * A list of comparators that are used to sort the participants.
@@ -4776,6 +4777,15 @@ class CallState {
         this.setOwnCapabilities = (capabilities) => {
             return this.setCurrentValue(this.ownCapabilitiesSubject, capabilities);
         };
+        /**
+         * Sets the call grants (used for own capabilities).
+         *
+         * @internal
+         * @param grants the grants to set.
+         */
+        this.setCallGrants = (grants) => {
+            return this.setCurrentValue(this.callGrantsSubject, grants);
+        };
         /**
          * Sets the backstage state.
          * @param backstage the backstage state.
@@ -5207,7 +5217,7 @@ class CallState {
         };
         this.updateOwnCapabilities = (event) => {
             if (event.user.id === this.localParticipant?.userId) {
-                this.setCurrentValue(this.ownCapabilitiesSubject, event.own_capabilities);
+                this.setOwnCapabilities(event.own_capabilities);
             }
         };
         this.updateFromClosedCaptions = (event) => {
@@ -5276,25 +5286,53 @@ class CallState {
         const isShallowEqual = (a, b) => {
             if (a.length !== b.length)
                 return false;
-            for (const item of a)
+            for (const item of a) {
                 if (!b.includes(item))
                     return false;
-            for (const item of b)
+            }
+            for (const item of b) {
                 if (!a.includes(item))
                     return false;
+            }
             return true;
         };
         /**
          * Creates an Observable from the given subject by piping to the
          * `distinctUntilChanged()` operator.
          */
-        const duc = (subject, comparator) => subject.asObservable().pipe(distinctUntilChanged(comparator));
+        const duc = (subject, comparator) => subject.pipe(distinctUntilChanged(comparator));
         // primitive values should only emit once the value they hold changes
         this.anonymousParticipantCount$ = duc(this.anonymousParticipantCountSubject);
         this.blockedUserIds$ = duc(this.blockedUserIdsSubject, isShallowEqual);
         this.backstage$ = duc(this.backstageSubject);
         this.callingState$ = duc(this.callingStateSubject);
-        this.ownCapabilities$ = duc(this.ownCapabilitiesSubject, isShallowEqual);
+        this.ownCapabilities$ = combineLatest([
+            this.ownCapabilitiesSubject,
+            this.callGrantsSubject.pipe(startWith(undefined)),
+        ]).pipe(map(([capabilities, grants]) => {
+            if (!grants)
+                return capabilities;
+            const { canPublishAudio, canPublishVideo, canScreenshare } = grants;
+            const update = {
+                [OwnCapability.SEND_AUDIO]: canPublishAudio,
+                [OwnCapability.SEND_VIDEO]: canPublishVideo,
+                [OwnCapability.SCREENSHARE]: canScreenshare,
+            };
+            const nextCapabilities = [...capabilities];
+            for (const _capability in update) {
+                const capability = _capability;
+                const allowed = update[capability];
+                // grants take precedence over capabilities, reconstruct the capabilities
+                if (allowed && !nextCapabilities.includes(capability)) {
+                    nextCapabilities.push(capability);
+                }
+                else if (!allowed && nextCapabilities.includes(capability)) {
+                    const index = nextCapabilities.indexOf(capability);
+                    nextCapabilities.splice(index, 1);
+                }
+            }
+            return nextCapabilities;
+        }), distinctUntilChanged(isShallowEqual), shareReplay({ bufferSize: 1, refCount: true }));
         this.participantCount$ = duc(this.participantCountSubject);
         this.recording$ = duc(this.recordingSubject);
         this.transcribing$ = duc(this.transcribingSubject);
@@ -5653,7 +5691,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.28.0";
+const version = "1.29.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8387,21 +8425,9 @@ const watchSfuCallEnded = (call) => {
 const watchCallGrantsUpdated = (state) => {
     return function onCallGrantsUpdated(event) {
         const { currentGrants } = event;
-        if (currentGrants) {
-            const { canPublishAudio, canPublishVideo, canScreenshare } = currentGrants;
-            const update = {
-                [OwnCapability.SEND_AUDIO]: canPublishAudio,
-                [OwnCapability.SEND_VIDEO]: canPublishVideo,
-                [OwnCapability.SCREENSHARE]: canScreenshare,
-            };
-            const nextCapabilities = state.ownCapabilities.filter((capability) => update[capability] !== false);
-            Object.entries(update).forEach(([capability, value]) => {
-                if (value && !nextCapabilities.includes(capability)) {
-                    nextCapabilities.push(capability);
-                }
-            });
-            state.setOwnCapabilities(nextCapabilities);
-        }
+        if (!currentGrants)
+            return;
+        state.setCallGrants(currentGrants);
     };
 };
 
@@ -8743,10 +8769,6 @@ const registerEventHandlers = (call, dispatcher) => {
         call.on('inboundStateNotification', watchInboundStateNotification(state)),
         handleRemoteSoftMute(call),
     ];
-    if (call.ringing) {
-        // these events are only relevant when the call is ringing
-        eventHandlers.push(registerRingingCallEventHandlers(call));
-    }
     return () => {
         eventHandlers.forEach((unsubscribe) => unsubscribe());
     };
@@ -10000,11 +10022,10 @@ class InputMediaDeviceManager {
             }
         });
     }
-    /**
-     * Stops or pauses the stream based on state.disableMode
-     * @param {boolean} [forceStop=false] when true, stops the tracks regardless of the state.disableMode
-     */
-    async disable(forceStop = false) {
+    async disable(forceStopOrOptions) {
+        const forceStop = typeof forceStopOrOptions === 'boolean'
+            ? forceStopOrOptions
+            : (forceStopOrOptions?.forceStop ?? false);
         this.state.prevStatus = this.state.optimisticStatus;
         if (!forceStop && this.state.optimisticStatus === 'disabled') {
             return;
@@ -11538,6 +11559,21 @@ class Call {
                     });
                 }
             }));
+            if (this.ringing) {
+                // if the call is ringing, we need to register the ringing call effects
+                this.handleRingingCall();
+            }
+            else {
+                // if the call is not ringing, we need to register the ringing call subscriptions
+                // to handle the case when the call gets ringing flag after creation event
+                this.leaveCallHooks.add(
+                // "ringing" mode effects and event handlers
+                createSubscription(this.ringingSubject, (isRinging) => {
+                    if (!isRinging)
+                        return;
+                    this.handleRingingCall();
+                }));
+            }
             this.leaveCallHooks.add(
             // cancel auto-drop when call is accepted or rejected
             createSubscription(this.state.session$, (session) => {
@@ -11559,53 +11595,49 @@ class Call {
                     });
                 }
             }));
-            this.leaveCallHooks.add(
-            // "ringing" mode effects and event handlers
-            createSubscription(this.ringingSubject, (isRinging) => {
-                if (!isRinging)
-                    return;
-                const callSession = this.state.session;
-                const receiver_id = this.clientStore.connectedUser?.id;
-                const ended_at = callSession?.ended_at;
-                const created_by_id = this.state.createdBy?.id;
-                const rejected_by = callSession?.rejected_by;
-                const accepted_by = callSession?.accepted_by;
-                let leaveCallIdle = false;
-                if (ended_at) {
-                    // call was ended before it was accepted or rejected so we should leave it to idle
+        };
+        this.handleRingingCall = () => {
+            const callSession = this.state.session;
+            const receiver_id = this.clientStore.connectedUser?.id;
+            const ended_at = callSession?.ended_at;
+            const created_by_id = this.state.createdBy?.id;
+            const rejected_by = callSession?.rejected_by;
+            const accepted_by = callSession?.accepted_by;
+            let leaveCallIdle = false;
+            if (ended_at) {
+                // call was ended before it was accepted or rejected so we should leave it to idle
+                leaveCallIdle = true;
+            }
+            else if (created_by_id && rejected_by) {
+                if (rejected_by[created_by_id]) {
+                    // call was cancelled by the caller
                     leaveCallIdle = true;
                 }
-                else if (created_by_id && rejected_by) {
-                    if (rejected_by[created_by_id]) {
-                        // call was cancelled by the caller
-                        leaveCallIdle = true;
-                    }
-                }
-                else if (receiver_id && rejected_by) {
-                    if (rejected_by[receiver_id]) {
-                        // call was rejected by the receiver in some other device
-                        leaveCallIdle = true;
-                    }
+            }
+            else if (receiver_id && rejected_by) {
+                if (rejected_by[receiver_id]) {
+                    // call was rejected by the receiver in some other device
+                    leaveCallIdle = true;
                 }
-                else if (receiver_id && accepted_by) {
-                    if (accepted_by[receiver_id]) {
-                        // call was accepted by the receiver in some other device
-                        leaveCallIdle = true;
-                    }
+            }
+            else if (receiver_id && accepted_by) {
+                if (accepted_by[receiver_id]) {
+                    // call was accepted by the receiver in some other device
+                    leaveCallIdle = true;
                 }
-                if (leaveCallIdle) {
-                    if (this.state.callingState !== CallingState.IDLE) {
-                        this.state.setCallingState(CallingState.IDLE);
-                    }
+            }
+            if (leaveCallIdle) {
+                if (this.state.callingState !== CallingState.IDLE) {
+                    this.state.setCallingState(CallingState.IDLE);
                 }
-                else {
-                    if (this.state.callingState === CallingState.IDLE) {
-                        this.state.setCallingState(CallingState.RINGING);
-                    }
-                    this.scheduleAutoDrop();
-                    this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
+            }
+            else {
+                if (this.state.callingState === CallingState.IDLE) {
+                    this.state.setCallingState(CallingState.RINGING);
                 }
-            }));
+                this.scheduleAutoDrop();
+                this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
+            }
         };
         this.handleOwnCapabilitiesUpdated = async (ownCapabilities) => {
             // update the permission context.
@@ -14562,7 +14594,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.28.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.29.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -14584,12 +14616,14 @@ class StreamClient {
                     'x-client-request-id': generateUUIDv4(),
                 };
             }
+            const { params: axiosConfigParams, headers: axiosConfigHeaders, ...axiosRequestConfig } = this.options.axiosRequestConfig || {};
             return {
                 params: {
                     user_id: this.userID,
                     connection_id: this._getConnectionID(),
                     api_key: this.key,
                     ...options.params,
+                    ...axiosConfigParams,
                 },
                 headers: {
                     ...authorization,
@@ -14598,9 +14632,10 @@ class StreamClient {
                         : this.getAuthType(),
                     'X-Stream-Client': this.getUserAgent(),
                     ...options.headers,
+                    ...axiosConfigHeaders,
                 },
                 ...options.config,
-                ...this.options.axiosRequestConfig,
+                ...axiosRequestConfig,
             };
         };
         this._getToken = () => {