@stream-io/video-client 1.40.0 → 1.40.2

package/dist/index.cjs.js

@@ -6080,7 +6080,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.40.0";
+const version = "1.40.2";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -8513,14 +8513,27 @@ class StreamSfuClient {
             // be replaced with a new one in case a second join request is made
             const current = this.joinResponseTask;
             let timeoutId = undefined;
+            const unsubscribeJoinErrorEvents = this.dispatcher.on('error', (event) => {
+                const { error, reconnectStrategy } = event;
+                if (!error)
+                    return;
+                if (reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT) {
+                    clearTimeout(timeoutId);
+                    unsubscribe?.();
+                    unsubscribeJoinErrorEvents();
+                    current.reject(new SfuJoinError(event));
+                }
+            });
             const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
                 clearTimeout(timeoutId);
                 unsubscribe();
+                unsubscribeJoinErrorEvents();
                 this.keepAlive();
                 current.resolve(joinResponse);
             });
             timeoutId = setTimeout(() => {
                 unsubscribe();
+                unsubscribeJoinErrorEvents();
                 const message = `Waiting for "joinResponse" has timed out after ${this.joinResponseTimeout}ms`;
                 this.tracer?.trace('joinRequestTimeout', message);
                 current.reject(new Error(message));
@@ -8665,6 +8678,14 @@ StreamSfuClient.DISPOSE_OLD_SOCKET = 4100;
  * The close code used when the client fails to join the call (on the SFU).
  */
 StreamSfuClient.JOIN_FAILED = 4101;
+class SfuJoinError extends Error {
+    constructor(event) {
+        super(event.error?.message || 'Join Error');
+        this.errorEvent = event;
+        this.unrecoverable =
+            event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
+    }
+}
 
 /**
  * Event handler that watched the delivery of `call.accepted`.
@@ -10318,6 +10339,19 @@ class DeviceManager {
          * if true, stops the media stream when call is left
          */
         this.stopOnLeave = true;
+        /**
+         * When `true`, the `apply()` method will skip automatically enabling/disabling
+         * the device based on server defaults (`mic_default_on`, `camera_default_on`).
+         *
+         * This is useful when application code wants to handle device preferences
+         * (e.g., persisted user preferences) and prevent server defaults from
+         * overriding them.
+         *
+         * @default false
+         *
+         * @internal
+         */
+        this.deferServerDefaults = false;
         this.subscriptions = [];
         this.areSubscriptionsSetUp = false;
         this.isTrackStoppedDueToTrackEnd = false;
@@ -10996,8 +11030,15 @@ class CameraManager extends DeviceManager {
      * @internal
      */
     async selectTargetResolution(resolution) {
-        this.targetResolution.height = resolution.height;
-        this.targetResolution.width = resolution.width;
+        // normalize target resolution to landscape format.
+        // on mobile devices, the device itself adjusts the resolution to portrait or landscape
+        // depending on the orientation of the device. using portrait resolution
+        // will result in falling back to the default resolution (640x480).
+        let { width, height } = resolution;
+        if (width < height)
+            [width, height] = [height, width];
+        this.targetResolution.height = height;
+        this.targetResolution.width = width;
         if (this.state.optimisticStatus === 'enabled') {
             try {
                 await this.statusChangeSettled();
@@ -11011,9 +11052,8 @@ class CameraManager extends DeviceManager {
             const [videoTrack] = this.state.mediaStream.getVideoTracks();
             if (!videoTrack)
                 return;
-            const { width, height } = videoTrack.getSettings();
-            if (width !== this.targetResolution.width ||
-                height !== this.targetResolution.height) {
+            const { width: w, height: h } = videoTrack.getSettings();
+            if (w !== width || h !== height) {
                 await this.applySettingsToStream();
                 this.logger.debug(`${width}x${height} target resolution applied to media stream`);
             }
@@ -11026,38 +11066,25 @@ class CameraManager extends DeviceManager {
      * @param publish whether to publish the stream after applying the settings.
      */
     async apply(settings, publish) {
-        const hasPublishedVideo = !!this.call.state.localParticipant?.videoStream;
-        const hasPermission = this.call.permissionsContext.hasPermission(OwnCapability.SEND_AUDIO);
-        if (hasPublishedVideo || !hasPermission)
-            return;
         // Wait for any in progress camera operation
         await this.statusChangeSettled();
-        const { target_resolution, camera_facing, camera_default_on, enabled } = settings;
-        // normalize target resolution to landscape format.
-        // on mobile devices, the device itself adjusts the resolution to portrait or landscape
-        // depending on the orientation of the device. using portrait resolution
-        // will result in falling back to the default resolution (640x480).
-        let { width, height } = target_resolution;
-        if (width < height)
-            [width, height] = [height, width];
-        await this.selectTargetResolution({ width, height });
-        // Set camera direction if it's not yet set
-        if (!this.state.direction && !this.state.selectedDevice) {
-            this.state.setDirection(camera_facing === 'front' ? 'front' : 'back');
+        await this.selectTargetResolution(settings.target_resolution);
+        // apply a direction and enable the camera only if in "pristine" state
+        // and server defaults are not deferred to application code
+        const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+        if (this.state.status === undefined && !this.deferServerDefaults) {
+            if (!this.state.direction && !this.state.selectedDevice) {
+                const direction = settings.camera_facing === 'front' ? 'front' : 'back';
+                await this.selectDirection(direction);
+            }
+            if (canPublish && settings.camera_default_on && settings.enabled) {
+                await this.enable();
+            }
         }
-        if (!publish)
-            return;
         const { mediaStream } = this.state;
-        if (this.enabled && mediaStream) {
-            // The camera is already enabled (e.g. lobby screen). Publish the stream
+        if (canPublish && publish && this.enabled && mediaStream) {
             await this.publishStream(mediaStream);
         }
-        else if (this.state.status === undefined &&
-            camera_default_on &&
-            enabled) {
-            // Start camera if backend config specifies, and there is no local setting
-            await this.enable();
-        }
     }
     getDevices() {
         return getVideoDevices(this.call.tracer);
@@ -11565,24 +11592,20 @@ class MicrophoneManager extends AudioDeviceManager {
      * @param publish whether to publish the stream after applying the settings.
      */
     async apply(settings, publish) {
-        if (!publish)
-            return;
-        const hasPublishedAudio = !!this.call.state.localParticipant?.audioStream;
-        const hasPermission = this.call.permissionsContext.hasPermission(OwnCapability.SEND_AUDIO);
-        if (hasPublishedAudio || !hasPermission)
-            return;
         // Wait for any in progress mic operation
         await this.statusChangeSettled();
-        // Publish media stream that was set before we joined
+        const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+        // apply server-side settings only when the device state is pristine
+        // and server defaults are not deferred to application code
+        if (this.state.status === undefined && !this.deferServerDefaults) {
+            if (canPublish && settings.mic_default_on) {
+                await this.enable();
+            }
+        }
         const { mediaStream } = this.state;
-        if (this.enabled && mediaStream) {
-            // The mic is already enabled (e.g. lobby screen). Publish the stream
+        if (canPublish && publish && this.enabled && mediaStream) {
             await this.publishStream(mediaStream);
         }
-        else if (this.state.status === undefined && settings.mic_default_on) {
-            // Start mic if backend config specifies, and there is no local setting
-            await this.enable();
-        }
     }
     getDevices() {
         return getAudioDevices(this.call.tracer);
@@ -12439,7 +12462,8 @@ class Call {
                 }
                 catch (err) {
                     this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-                    if (err instanceof ErrorFromResponse && err.unrecoverable) {
+                    if ((err instanceof ErrorFromResponse && err.unrecoverable) ||
+                        (err instanceof SfuJoinError && err.unrecoverable)) {
                         // if the error is unrecoverable, we should not retry as that signals
                         // that connectivity is good, but the coordinator doesn't allow the user
                         // to join the call due to some reason (e.g., ended call, expired token...)
@@ -15108,7 +15132,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.40.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.40.2", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15786,6 +15810,7 @@ exports.RxUtils = rxUtils;
 exports.ScreenShareManager = ScreenShareManager;
 exports.ScreenShareState = ScreenShareState;
 exports.SfuEvents = events;
+exports.SfuJoinError = SfuJoinError;
 exports.SfuModels = models;
 exports.SpeakerManager = SpeakerManager;
 exports.SpeakerState = SpeakerState;