@stream-io/video-client 1.33.1 → 1.34.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.33.1",
+  "version": "1.34.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -26,34 +26,33 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@protobuf-ts/runtime": "^2.9.4",
-    "@protobuf-ts/runtime-rpc": "^2.9.4",
-    "@protobuf-ts/twirp-transport": "^2.9.4",
+    "@protobuf-ts/runtime": "^2.11.1",
+    "@protobuf-ts/runtime-rpc": "^2.11.1",
+    "@protobuf-ts/twirp-transport": "^2.11.1",
     "@stream-io/worker-timer": "^1.2.4",
-    "axios": "^1.8.1",
-    "rxjs": "~7.8.1",
+    "axios": "^1.12.2",
+    "rxjs": "~7.8.2",
     "sdp-transform": "^2.15.0",
-    "ua-parser-js": "^1.0.40",
-    "webrtc-adapter": "^8.2.3"
+    "ua-parser-js": "^1.0.41",
+    "webrtc-adapter": "^8.2.4"
   },
   "devDependencies": {
-    "@openapitools/openapi-generator-cli": "^2.13.4",
+    "@openapitools/openapi-generator-cli": "^2.25.0",
     "@rollup/plugin-replace": "^6.0.2",
-    "@rollup/plugin-typescript": "^12.1.2",
-    "@stream-io/audio-filters-web": "^0.5.0",
-    "@stream-io/node-sdk": "^0.4.24",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@stream-io/audio-filters-web": "^0.6.0",
+    "@stream-io/node-sdk": "^0.7.9",
     "@total-typescript/shoehorn": "^0.1.2",
-    "@types/sdp-transform": "^2.4.9",
+    "@types/sdp-transform": "^2.15.0",
     "@types/ua-parser-js": "^0.7.39",
-    "@vitest/coverage-v8": "^3.1.3",
-    "dotenv": "^16.5.0",
-    "happy-dom": "^17.5.6",
-    "prettier": "^3.5.3",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^16.6.1",
+    "happy-dom": "^20.0.0",
+    "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
-    "rollup": "^4.40.2",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5",
-    "vitest": "^3.1.3",
+    "rollup": "^4.52.4",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
     "vitest-mock-extended": "^3.1.0"
   }
 }

package/src/Call.ts

@@ -1288,6 +1288,7 @@ export class Call {
     }
 
     this.tracer.setEnabled(enableTracing);
+    this.sfuStatsReporter?.flush();
     this.sfuStatsReporter?.stop();
     if (statsOptions?.reporting_interval_ms > 0) {
       this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {

package/src/devices/CameraManager.ts

@@ -43,12 +43,13 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
       await videoTrack?.applyConstraints({
         facingMode: direction === 'front' ? 'user' : 'environment',
       });
-      this.state.setDirection(direction);
-      return;
     }
     // providing both device id and direction doesn't work, so we deselect the device
     this.state.setDirection(direction);
     this.state.setDevice(undefined);
+    if (isReactNative()) {
+      return;
+    }
     this.getTracks().forEach((track) => track.stop());
     try {
       await this.unmuteStream();

package/src/devices/SpeakerManager.ts

@@ -113,14 +113,17 @@ export class SpeakerManager {
    * @param volume a number between 0 and 1. Set it to `undefined` to use the default volume.
    */
   setParticipantVolume(sessionId: string, volume: number | undefined) {
-    if (isReactNative()) {
-      throw new Error(
-        'This feature is not supported in React Native. Please visit https://getstream.io/video/docs/reactnative/core/camera-and-microphone/#speaker-management for more details',
-      );
-    }
     if (volume && (volume < 0 || volume > 1)) {
       throw new Error('Volume must be between 0 and 1, or undefined');
     }
-    this.call.state.updateParticipant(sessionId, { audioVolume: volume });
+    this.call.state.updateParticipant(sessionId, (p) => {
+      if (isReactNative() && p.audioStream) {
+        for (const track of p.audioStream.getAudioTracks()) {
+          // @ts-expect-error track._setVolume is present in react-native-webrtc
+          track?._setVolume(volume);
+        }
+      }
+      return { audioVolume: volume };
+    });
   }
 }

package/src/devices/__tests__/SpeakerManager.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
 import {
   emitDeviceIds,
   mockAudioDevices,
@@ -80,11 +81,13 @@ describe('SpeakerManager.test', () => {
 
   it('set participant volume', () => {
     const call = manager['call'];
-    // @ts-expect-error - incomplete data
-    call.state.updateOrAddParticipant('session-id', {
-      audioVolume: undefined,
-      sessionId: 'session-id',
-    });
+    call.state.updateOrAddParticipant(
+      'session-id',
+      fromPartial({
+        audioVolume: undefined,
+        sessionId: 'session-id',
+      }),
+    );
 
     manager.setParticipantVolume('session-id', 0.5);
     let participant = call.state.findParticipantBySessionId('session-id');

package/src/rtc/__tests__/layers.test.ts

@@ -1,5 +1,6 @@
 import './mocks/webrtc.mocks';
 import { describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
 import {
   AudioBitrateProfile,
   PublishOption,
@@ -24,13 +25,12 @@ describe('videoLayers', () => {
     const targetBitrate = 3000000;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
 
-    const publishOption: PublishOption = {
+    const publishOption: PublishOption = fromPartial({
       bitrate: targetBitrate,
-      // @ts-expect-error - incomplete data
       codec: { name: 'vp8' },
       videoDimension: { width, height },
       fps: 30,
-    };
+    });
     const layers = computeVideoLayers(track, publishOption);
     expect(layers).toEqual([
       {
@@ -66,12 +66,13 @@ describe('videoLayers', () => {
   it('should return undefined for audio track', () => {
     const track = new MediaStreamTrack();
     expect(
-      // @ts-expect-error - incomplete data
-      computeVideoLayers(track, { trackType: TrackType.AUDIO }),
+      computeVideoLayers(track, fromPartial({ trackType: TrackType.AUDIO })),
     ).toBeUndefined();
     expect(
-      // @ts-expect-error - incomplete data
-      computeVideoLayers(track, { trackType: TrackType.SCREEN_SHARE_AUDIO }),
+      computeVideoLayers(
+        track,
+        fromPartial({ trackType: TrackType.SCREEN_SHARE_AUDIO }),
+      ),
     ).toBeUndefined();
   });
 
@@ -79,13 +80,15 @@ describe('videoLayers', () => {
     const bitrate = 3000000;
     const track = new MediaStreamTrack();
     vi.spyOn(track, 'getSettings').mockReturnValue({});
-    const layers = computeVideoLayers(track, {
-      bitrate,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp8' },
-      fps: 30,
-      videoDimension: { width: 320, height: 180 },
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        bitrate,
+        codec: { name: 'vp8' },
+        fps: 30,
+        videoDimension: { width: 320, height: 180 },
+      }),
+    );
     expect(layers).toEqual([
       {
         active: true,
@@ -104,13 +107,15 @@ describe('videoLayers', () => {
     const width = 320;
     const height = 240;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = computeVideoLayers(track, {
-      bitrate: 0,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp8' },
-      fps: 30,
-      videoDimension: { width, height },
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        bitrate: 0,
+        codec: { name: 'vp8' },
+        fps: 30,
+        videoDimension: { width, height },
+      }),
+    );
     expect(layers.length).toBe(1);
     const [q] = layers;
     expect(q.rid).toBe('q');
@@ -123,13 +128,15 @@ describe('videoLayers', () => {
     const width = 640;
     const height = 480;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = computeVideoLayers(track, {
-      bitrate: 0,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp8' },
-      fps: 30,
-      videoDimension: { width, height },
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        bitrate: 0,
+        codec: { name: 'vp8' },
+        fps: 30,
+        videoDimension: { width, height },
+      }),
+    );
     expect(layers.length).toBe(2);
     const [q, h] = layers;
     expect(q.rid).toBe('q');
@@ -145,13 +152,15 @@ describe('videoLayers', () => {
     const width = 1280;
     const height = 720;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = computeVideoLayers(track, {
-      bitrate: 0,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp8' },
-      fps: 30,
-      videoDimension: { width, height },
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        bitrate: 0,
+        codec: { name: 'vp8' },
+        fps: 30,
+        videoDimension: { width, height },
+      }),
+    );
     expect(layers.length).toBe(3);
     const [q, h, f] = layers;
     expect(q.rid).toBe('q');
@@ -171,13 +180,15 @@ describe('videoLayers', () => {
       width: 1280,
       height: 720,
     });
-    const layers = computeVideoLayers(track, {
-      maxTemporalLayers: 3,
-      maxSpatialLayers: 3,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp9' },
-      videoDimension: { width: 1280, height: 720 },
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        maxTemporalLayers: 3,
+        maxSpatialLayers: 3,
+        codec: { name: 'vp9' },
+        videoDimension: { width: 1280, height: 720 },
+      }),
+    );
     expect(layers.length).toBe(3);
     expect(layers[0].scalabilityMode).toBe('L3T3_KEY');
     expect(layers[0].rid).toBe('q');
@@ -187,8 +198,10 @@ describe('videoLayers', () => {
 
   it('should activate only a single layer when useSingleLayer is true', () => {
     const track = new MediaStreamTrack();
-    // @ts-expect-error - incomplete data
-    const layers = computeVideoLayers(track, { useSingleLayer: true });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({ useSingleLayer: true }),
+    );
     expect(layers.length).toBe(3);
     expect(layers[0].active).toBe(false);
     expect(layers[0].rid).toBe('q');
@@ -201,8 +214,10 @@ describe('videoLayers', () => {
   it('should activate only a single layer when useSingleLayer is true in single layer mode', () => {
     const track = new MediaStreamTrack();
     vi.spyOn(track, 'getSettings').mockReturnValue({ width: 320, height: 180 });
-    // @ts-expect-error - incomplete data
-    const layers = computeVideoLayers(track, { useSingleLayer: true });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({ useSingleLayer: true }),
+    );
     expect(layers.length).toBe(1);
     expect(layers[0].active).toBe(true);
     expect(layers[0].rid).toBe('q');
@@ -210,13 +225,15 @@ describe('videoLayers', () => {
 
   it('should activate only one temporal layer when useSingleLayer is true for SVC', () => {
     const track = new MediaStreamTrack();
-    const layers = computeVideoLayers(track, {
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp9' },
-      maxSpatialLayers: 3,
-      maxTemporalLayers: 3,
-      useSingleLayer: true,
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        codec: { name: 'vp9' },
+        maxSpatialLayers: 3,
+        maxTemporalLayers: 3,
+        useSingleLayer: true,
+      }),
+    );
     expect(layers.length).toBe(3);
     expect(layers[0].rid).toBe('q');
     expect(layers[0].active).toBe(false);
@@ -318,13 +335,15 @@ describe('videoLayers', () => {
 
   it('should use integer for maxBitrate', () => {
     const track = new MediaStreamTrack();
-    const layers = computeVideoLayers(track, {
-      bitrate: 2999777,
-      // @ts-expect-error - incomplete data
-      codec: { name: 'vp8' },
-      videoDimension: { width: 1920, height: 1080 },
-      fps: 30,
-    });
+    const layers = computeVideoLayers(
+      track,
+      fromPartial({
+        bitrate: 2999777,
+        codec: { name: 'vp8' },
+        videoDimension: { width: 1920, height: 1080 },
+        fps: 30,
+      }),
+    );
     expect(layers).toBeDefined();
     for (const layer of layers!) {
       expect(Number.isInteger(layer.width)).toBe(true);
@@ -422,22 +441,31 @@ describe('audioLayers', () => {
   it('should use predefined bitrates when publish options are missing', () => {
     expect(
       computeAudioLayers(
-        // @ts-expect-error - incomplete data
-        { trackType: TrackType.AUDIO, id: 1, audioBitrateProfiles: [] },
+        fromPartial({
+          trackType: TrackType.AUDIO,
+          id: 1,
+          audioBitrateProfiles: [],
+        }),
         { audioBitrateProfile: AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED },
       ),
     ).toEqual([{ maxBitrate: 64000 }]);
     expect(
       computeAudioLayers(
-        // @ts-expect-error - incomplete data
-        { trackType: TrackType.AUDIO, id: 1, audioBitrateProfiles: [] },
+        fromPartial({
+          trackType: TrackType.AUDIO,
+          id: 1,
+          audioBitrateProfiles: [],
+        }),
         { audioBitrateProfile: AudioBitrateProfile.VOICE_HIGH_QUALITY },
       ),
     ).toEqual([{ maxBitrate: 128000 }]);
     expect(
       computeAudioLayers(
-        // @ts-expect-error - incomplete data
-        { trackType: TrackType.AUDIO, id: 1, audioBitrateProfiles: [] },
+        fromPartial({
+          trackType: TrackType.AUDIO,
+          id: 1,
+          audioBitrateProfiles: [],
+        }),
         { audioBitrateProfile: AudioBitrateProfile.MUSIC_HIGH_QUALITY },
       ),
     ).toEqual([{ maxBitrate: 128000 }]);
@@ -445,17 +473,14 @@ describe('audioLayers', () => {
 
   it('should use the predefined bitrate when the SFU does not provide audioBitrateProfiles', () => {
     expect(
-      computeAudioLayers(
-        // @ts-expect-error - incomplete data
-        { trackType: TrackType.AUDIO, id: 1 },
-        { audioBitrateProfile: AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED },
-      ),
+      computeAudioLayers(fromPartial({ trackType: TrackType.AUDIO, id: 1 }), {
+        audioBitrateProfile: AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED,
+      }),
     ).toEqual([{ maxBitrate: 64000 }]);
   });
 
   it('should respect the bitrates provided in publish options', () => {
-    // @ts-expect-error - incomplete data
-    const config: PublishOption = {
+    const config: PublishOption = fromPartial({
       trackType: TrackType.AUDIO,
       id: 1,
       audioBitrateProfiles: [
@@ -472,7 +497,7 @@ describe('audioLayers', () => {
           bitrate: 192000,
         },
       ],
-    };
+    });
     expect(
       computeAudioLayers(config, {
         audioBitrateProfile: AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED,

package/src/store/__tests__/CallState.test.ts

@@ -1,6 +1,7 @@
 import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { describe, expect, it, vi } from 'vitest';
 import { anyNumber } from 'vitest-mock-extended';
+import { fromPartial } from '@total-typescript/shoehorn';
 import { StreamVideoParticipant, VisibilityState } from '../../types';
 import { CallingState } from '../CallingState';
 import { CallState } from '../CallState';
@@ -56,8 +57,7 @@ describe('CallState', () => {
     it(`shouldn't emit when primitive (backstage) values didn't change`, () => {
       const state = new CallState();
       const updateWith = (value: boolean) => {
-        // @ts-expect-error incomplete data
-        state.updateFromCallResponse({ backstage: value });
+        state.updateFromCallResponse(fromPartial({ backstage: value }));
       };
 
       updateWith(false);
@@ -138,8 +138,7 @@ describe('CallState', () => {
     it(`shouldn't emit when string arrays (blockedUserIds) value didn't change`, () => {
       const state = new CallState();
       const updateWith = (value: string[]) => {
-        // @ts-expect-error incomplete data
-        state.updateFromCallResponse({ blocked_user_ids: value });
+        state.updateFromCallResponse(fromPartial({ blocked_user_ids: value }));
       };
 
       updateWith(['a', 'b']);
@@ -640,25 +639,21 @@ describe('CallState', () => {
     describe('recording and broadcasting events', () => {
       it('handles call.recording_started events', () => {
         const state = new CallState();
-        // @ts-expect-error incomplete data
-        state.updateFromEvent({ type: 'call.recording_started' });
+        state.updateFromEvent(fromPartial({ type: 'call.recording_started' }));
         expect(state.recording).toBe(true);
       });
 
       it('handles call.recording_stopped events', () => {
         const state = new CallState();
-        // @ts-expect-error incomplete data
-        state.updateFromEvent({ type: 'call.recording_stopped' });
+        state.updateFromEvent(fromPartial({ type: 'call.recording_stopped' }));
         expect(state.recording).toBe(false);
       });
 
       it('handles call.recording_failed events', () => {
         const state = new CallState();
-        // @ts-expect-error incomplete data
-        state.updateFromEvent({ type: 'call.recording_started' });
+        state.updateFromEvent(fromPartial({ type: 'call.recording_started' }));
         expect(state.recording).toBe(true);
-        // @ts-expect-error incomplete data
-        state.updateFromEvent({ type: 'call.recording_failed' });
+        state.updateFromEvent(fromPartial({ type: 'call.recording_failed' }));
         expect(state.recording).toBe(false);
       });