@stream-io/video-client 1.38.2 → 1.39.2

package/dist/index.es.js

@@ -3731,22 +3731,23 @@ const withRequestLogger = (logger, level) => {
     };
 };
 const withRequestTracer = (trace) => {
+    const exclusions = new Set(['SendStats']);
+    const responseInclusions = new Set(['SetPublisher']);
     const traceError = (name, input, err) => trace(`${name}OnFailure`, [err, input]);
-    const exclusions = {
-        SendStats: true,
-    };
     return {
         interceptUnary(next, method, input, options) {
-            if (exclusions[method.name]) {
+            const name = method.name;
+            if (exclusions.has(name))
                 return next(method, input, options);
-            }
-            trace(method.name, input);
+            trace(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));
+                const response = invocation.response;
+                if (response.error)
+                    traceError(name, input, response.error);
+                if (responseInclusions.has(name))
+                    trace(`${name}Response`, response);
+            }, (error) => traceError(name, input, error));
             return unaryCall;
         },
     };
@@ -3948,6 +3949,37 @@ const extractMid = (transceiver, transceiverInitIndex, sdp) => {
         return '';
     return String(transceiverInitIndex);
 };
+/*
+ * Sets the start bitrate for the VP9 and H264 codecs in the SDP.
+ *
+ * @param offerSdp the offer SDP to modify.
+ * @param startBitrate the start bitrate in kbps to set. Default is 1000 kbps.
+ */
+const setStartBitrate = (offerSdp, maxBitrateKbps, startBitrateFactor, targetMid) => {
+    // start bitrate should be between 300kbps and max-bitrate-kbps
+    const startBitrate = Math.max(Math.min(maxBitrateKbps, startBitrateFactor * maxBitrateKbps), 300);
+    const parsedSdp = parse(offerSdp);
+    const targetCodecs = new Set(['av1', 'vp9', 'h264']);
+    for (const media of parsedSdp.media) {
+        if (media.type !== 'video')
+            continue;
+        if (String(media.mid) !== targetMid)
+            continue;
+        for (const rtp of media.rtp) {
+            if (!targetCodecs.has(rtp.codec.toLowerCase()))
+                continue;
+            for (const fmtp of media.fmtp) {
+                if (fmtp.payload === rtp.payload) {
+                    if (!fmtp.config.includes('x-google-start-bitrate')) {
+                        fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return write(parsedSdp);
+};
 /**
  * Enables stereo in the answer SDP based on the offered stereo in the offer SDP.
  *
@@ -5994,7 +6026,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.38.2";
+const version = "1.39.2";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7822,10 +7854,25 @@ class Publisher extends BasePeerConnection {
                     this.isIceRestarting = options?.iceRestart ?? false;
                     await this.pc.setLocalDescription(offer);
                     const { sdp: baseSdp = '' } = offer;
-                    const { dangerouslyForceCodec, fmtpLine } = this.clientPublishOptions || {};
-                    const sdp = dangerouslyForceCodec
+                    const { dangerouslyForceCodec, dangerouslySetStartBitrateFactor, fmtpLine, } = this.clientPublishOptions || {};
+                    let sdp = dangerouslyForceCodec
                         ? removeCodecsExcept(baseSdp, dangerouslyForceCodec, fmtpLine)
                         : baseSdp;
+                    if (dangerouslySetStartBitrateFactor) {
+                        this.transceiverCache.items().forEach((t) => {
+                            if (t.publishOption.trackType !== TrackType.VIDEO)
+                                return;
+                            const maxBitrateBps = t.publishOption.bitrate;
+                            const trackId = t.transceiver.sender.track?.id;
+                            if (!trackId)
+                                return;
+                            const mid = tracks.find((x) => x.trackId === trackId)?.mid;
+                            if (!mid)
+                                return;
+                            sdp = setStartBitrate(sdp, maxBitrateBps / 1000, // convert to kbps
+                            dangerouslySetStartBitrateFactor, mid);
+                        });
+                    }
                     const { response } = await this.sfuClient.setPublisher({ sdp, tracks });
                     if (response.error)
                         throw new NegotiationError(response.error);
@@ -9931,6 +9978,9 @@ const getDevices = (permission, kind, tracer) => {
 const checkIfAudioOutputChangeSupported = () => {
     if (typeof document === 'undefined')
         return false;
+    // Safari uses WebAudio API for playing audio, so we check the AudioContext prototype
+    if (isSafari())
+        return 'setSinkId' in AudioContext.prototype;
     const element = document.createElement('audio');
     return 'setSinkId' in element;
 };
@@ -14991,7 +15041,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.38.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.39.2", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15195,12 +15245,7 @@ class StreamVideoClient {
                     .map((call) => call.cid);
                 if (callsToReWatch.length <= 0)
                     return;
-                this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')}`);
-                this.queryCalls({
-                    watch: true,
-                    filter_conditions: { cid: { $in: callsToReWatch } },
-                    sort: [{ field: 'cid', direction: 1 }],
-                }).catch((err) => {
+                this.rewatchCalls(callsToReWatch).catch((err) => {
                     this.logger.error('Failed to re-watch calls', err);
                 });
             }));
@@ -15264,6 +15309,34 @@ class StreamVideoClient {
                 this.logger.error(`Failed to init call from event ${e.type}`, err);
             }
         };
+        /**
+         * Rewatches the given calls with retry logic.
+         * @param callsToReWatch array of call IDs to rewatch
+         */
+        this.rewatchCalls = async (callsToReWatch) => {
+            this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')}`);
+            const maxRetries = 3;
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                try {
+                    this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')} attempt ${attempt + 1}`);
+                    await this.queryCalls({
+                        watch: true,
+                        filter_conditions: { cid: { $in: callsToReWatch } },
+                    });
+                    return;
+                }
+                catch (err) {
+                    if (err instanceof ErrorFromResponse && err.unrecoverable) {
+                        throw err;
+                    }
+                    this.logger.warn(`Failed to re-watch calls (attempt ${attempt + 1}/${maxRetries}), retrying.`, err);
+                    if (attempt === maxRetries - 1) {
+                        throw err;
+                    }
+                }
+                await sleep(retryInterval(attempt));
+            }
+        };
         /**
          * Connects the given user to the client.
          * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.