@stream-io/video-client 1.7.1 → 1.7.3

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.7.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.7.2...@stream-io/video-client-1.7.3) (2024-09-24)
+
+
+### Bug Fixes
+
+* do not always error out api calls when web socket initially failed ([#1495](https://github.com/GetStream/stream-video-js/issues/1495)) ([7cdb62e](https://github.com/GetStream/stream-video-js/commit/7cdb62e75cad56098ee81eabbcc63382f93fd218))
+
+## [1.7.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.7.1...@stream-io/video-client-1.7.2) (2024-09-20)
+
+
+### Bug Fixes
+
+* overridable bitrate and bitrate downscale factor ([#1493](https://github.com/GetStream/stream-video-js/issues/1493)) ([cce5d8e](https://github.com/GetStream/stream-video-js/commit/cce5d8e641a9182a1779952e4e62aa16ec21ab92))
+
 ## [1.7.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.7.0...@stream-io/video-client-1.7.1) (2024-09-20)
 
 

package/dist/index.browser.es.js

@@ -2875,6 +2875,13 @@ function convertErrorToJson(err) {
     }
     return jsonObj;
 }
+/**
+ * Informs if a promise is yet to be resolved or rejected
+ */
+async function isPromisePending(promise) {
+    const emptyObj = {};
+    return Promise.race([promise, emptyObj]).then((value) => (value === emptyObj ? true : false), () => false);
+}
 /**
  * isOnline safely return the navigator.online value for browser env
  * if navigator is not in global object, it always return true
@@ -3013,7 +3020,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.7.1";
+const version = "1.7.3";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -3290,14 +3297,16 @@ const defaultBitratePerRid = {
  *
  * @param videoTrack the video track to find optimal layers for.
  * @param targetResolution the expected target resolution.
- * @param preferredBitrate the preferred bitrate for the video track.
+ * @param publishOptions the publish options for the track.
  */
-const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetResolution, preferredBitrate) => {
+const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetResolution, publishOptions) => {
     const optimalVideoLayers = [];
     const settings = videoTrack.getSettings();
     const { width: w = 0, height: h = 0 } = settings;
+    const { preferredBitrate, bitrateDownscaleFactor = 2 } = publishOptions || {};
     const maxBitrate = getComputedMaxBitrate(targetResolution, w, h, preferredBitrate);
     let downscaleFactor = 1;
+    let bitrateFactor = 1;
     ['f', 'h', 'q'].forEach((rid) => {
         // Reversing the order [f, h, q] to [q, h, f] as Chrome uses encoding index
         // when deciding which layer to disable when CPU or bandwidth is constrained.
@@ -3307,11 +3316,12 @@ const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetReso
             rid,
             width: Math.round(w / downscaleFactor),
             height: Math.round(h / downscaleFactor),
-            maxBitrate: Math.round(maxBitrate / downscaleFactor) || defaultBitratePerRid[rid],
+            maxBitrate: Math.round(maxBitrate / bitrateFactor) || defaultBitratePerRid[rid],
             scaleResolutionDownBy: downscaleFactor,
             maxFramerate: 30,
         });
         downscaleFactor *= 2;
+        bitrateFactor *= bitrateDownscaleFactor;
     });
     // for simplicity, we start with all layers enabled, then this function
     // will clear/reassign the layers that are not needed
@@ -3371,7 +3381,8 @@ const withSimulcastConstraints = (settings, optimalVideoLayers) => {
         rid: ridMapping[index], // reassign rid
     }));
 };
-const findOptimalScreenSharingLayers = (videoTrack, preferences, defaultMaxBitrate = 3000000) => {
+const findOptimalScreenSharingLayers = (videoTrack, publishOptions, defaultMaxBitrate = 3000000) => {
+    const { screenShareSettings: preferences } = publishOptions || {};
     const settings = videoTrack.getSettings();
     return [
         {
@@ -5152,11 +5163,10 @@ class Publisher {
                 const targetResolution = settings?.video
                     .target_resolution;
                 const screenShareBitrate = settings?.screensharing.target_resolution?.bitrate;
-                const { preferredBitrate, preferredCodec, screenShareSettings } = opts;
                 const videoEncodings = trackType === TrackType.VIDEO
-                    ? findOptimalVideoLayers(track, targetResolution, preferredBitrate)
+                    ? findOptimalVideoLayers(track, targetResolution, opts)
                     : trackType === TrackType.SCREEN_SHARE
-                        ? findOptimalScreenSharingLayers(track, screenShareSettings, screenShareBitrate)
+                        ? findOptimalScreenSharingLayers(track, opts, screenShareBitrate)
                         : undefined;
                 // listen for 'ended' event on the track as it might be ended abruptly
                 // by an external factor as permission revokes, device disconnected, etc.
@@ -5176,6 +5186,7 @@ class Publisher {
                 this.transceiverInitOrder.push(trackType);
                 this.transceiverRegistry[trackType] = transceiver;
                 this.publishOptionsPerTrackType.set(trackType, opts);
+                const { preferredCodec } = opts;
                 const codec = isReactNative() && trackType === TrackType.VIDEO && !preferredCodec
                     ? getRNOptimalCodec()
                     : preferredCodec;
@@ -5494,9 +5505,9 @@ class Publisher {
                     const publishOpts = this.publishOptionsPerTrackType.get(trackType);
                     optimalLayers =
                         trackType === TrackType.VIDEO
-                            ? findOptimalVideoLayers(track, targetResolution, publishOpts?.preferredBitrate)
+                            ? findOptimalVideoLayers(track, targetResolution, publishOpts)
                             : trackType === TrackType.SCREEN_SHARE
-                                ? findOptimalScreenSharingLayers(track, publishOpts?.screenShareSettings)
+                                ? findOptimalScreenSharingLayers(track, publishOpts)
                                 : [];
                     this.trackLayersCache[trackType] = optimalLayers;
                 }
@@ -8380,6 +8391,11 @@ class CameraManagerState extends InputMediaDeviceManagerState {
 }
 
 class CameraManager extends InputMediaDeviceManager {
+    /**
+     * Constructs a new CameraManager.
+     *
+     * @param call the call instance.
+     */
     constructor(call) {
         super(call, new CameraManagerState(), TrackType.VIDEO);
         this.targetResolution = {
@@ -8387,17 +8403,6 @@ class CameraManager extends InputMediaDeviceManager {
             height: 720,
         };
     }
-    /**
-     * The publish options for the camera.
-     *
-     * @internal internal use only, not part of the public API.
-     */
-    get publishOptions() {
-        return {
-            preferredCodec: this.preferredCodec,
-            preferredBitrate: this.preferredBitrate,
-        };
-    }
     /**
      * Select the camera direction.
      *
@@ -8452,16 +8457,33 @@ class CameraManager extends InputMediaDeviceManager {
      * @param codec the codec to use for encoding the video.
      */
     setPreferredCodec(codec) {
-        this.preferredCodec = codec;
+        this.updatePublishOptions({ preferredCodec: codec });
     }
     /**
-     * Sets the preferred bitrate for encoding the video.
+     * Updates the preferred publish options for the video stream.
      *
-     * @internal internal use only, not part of the public API.
-     * @param bitrate the bitrate to use for encoding the video.
+     * @internal
+     * @param options the options to use.
      */
-    setPreferredBitrate(bitrate) {
-        this.preferredBitrate = bitrate;
+    updatePublishOptions(options) {
+        this.publishOptions = { ...this.publishOptions, ...options };
+    }
+    /**
+     * Returns the capture resolution of the camera.
+     */
+    getCaptureResolution() {
+        const { mediaStream } = this.state;
+        if (!mediaStream)
+            return;
+        const [videoTrack] = mediaStream.getVideoTracks();
+        if (!videoTrack)
+            return;
+        const settings = videoTrack.getSettings();
+        return {
+            width: settings.width,
+            height: settings.height,
+            frameRate: settings.frameRate,
+        };
     }
     getDevices() {
         return getVideoDevices();
@@ -11350,6 +11372,15 @@ class StableWSConnection {
                 this._log(`_connect() - tokenProvider failed before, so going to retry`);
                 await this.client.tokenManager.loadToken();
             }
+            let mustSetupConnectionIdPromise = true;
+            if (this.client.connectionIdPromise) {
+                if (await isPromisePending(this.client.connectionIdPromise)) {
+                    mustSetupConnectionIdPromise = false;
+                }
+            }
+            if (mustSetupConnectionIdPromise) {
+                this.client._setupConnectionIdPromise();
+            }
             this._setupConnectionPromise();
             const wsURL = this._buildUrl();
             this._log(`_connect() - Connecting to ${wsURL}`, {
@@ -11375,6 +11406,7 @@ class StableWSConnection {
             }
         }
         catch (err) {
+            await this.client._setupConnectionIdPromise();
             this.isConnecting = false;
             // @ts-ignore
             this._log(`_connect() - Error - `, err);
@@ -12032,10 +12064,7 @@ class StreamClient {
                 this.logger('info', 'client:openConnection() - openConnection called twice, healthy connection already exists');
                 return Promise.resolve();
             }
-            this.connectionIdPromise = new Promise((resolve, reject) => {
-                this.resolveConnectionId = resolve;
-                this.rejectConnectionId = reject;
-            });
+            this._setupConnectionIdPromise();
             this.clientID = `${this.userID}--${randomId()}`;
             this.wsPromise = this.connect();
             return this.wsPromise;
@@ -12075,10 +12104,7 @@ class StreamClient {
          */
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             addConnectionEventListeners(this.updateNetworkConnectionStatus);
-            this.connectionIdPromise = new Promise((resolve, reject) => {
-                this.resolveConnectionId = resolve;
-                this.rejectConnectionId = reject;
-            });
+            this._setupConnectionIdPromise();
             this.anonymous = true;
             await this._setToken(user, tokenOrProvider, this.anonymous);
             this._setUser(user);
@@ -12117,6 +12143,16 @@ class StreamClient {
             this.logger('debug', `Removing listener for ${eventName} event`);
             this.listeners[eventName] = this.listeners[eventName]?.filter((value) => value !== callback);
         };
+        /**
+         * sets up the this.connectionIdPromise
+         */
+        this._setupConnectionIdPromise = async () => {
+            /** a promise that is resolved once connection id is set */
+            this.connectionIdPromise = new Promise((resolve, reject) => {
+                this.resolveConnectionId = resolve;
+                this.rejectConnectionId = reject;
+            });
+        };
         this._logApiRequest = (type, url, data, config) => {
             this.logger('trace', `client: ${type} - Request - ${url}`, {
                 payload: data,
@@ -12139,8 +12175,18 @@ class StreamClient {
                 await Promise.all([
                     this.tokenManager.tokenReady(),
                     this.guestUserCreatePromise,
-                    this.connectionIdPromise,
                 ]);
+                // we need to wait for presence of connection id before making requests
+                try {
+                    await this.connectionIdPromise;
+                }
+                catch (e) {
+                    // in case connection id was rejected
+                    // reconnection maybe in progress
+                    // we can wait for healthy connection to resolve, which rejects when 15s timeout is reached
+                    await this.wsConnection?._waitForHealthy();
+                    await this.connectionIdPromise;
+                }
             }
             const requestConfig = this._enrichAxiosOptions(options);
             try {
@@ -12323,7 +12369,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.7.1";
+            const version = "1.7.3";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };