@stream-io/video-client 1.11.3 → 1.11.5

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.11.5](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.4...@stream-io/video-client-1.11.5) (2024-11-22)
+
+
+### Bug Fixes
+
+* unhandled promise rejections during reconnect ([#1585](https://github.com/GetStream/stream-video-js/issues/1585)) ([920c4ea](https://github.com/GetStream/stream-video-js/commit/920c4ea3b3f622430b35ac1bade74a6206ee17e5)), closes [/github.com/GetStream/stream-video-js/pull/1585/files#diff-420f6ddab47c1be72fd9ce8c99e1fa2b9f5f0495b7c367546ee0ff634beaed81](https://github.com/GetStream//github.com/GetStream/stream-video-js/pull/1585/files/issues/diff-420f6ddab47c1be72fd9ce8c99e1fa2b9f5f0495b7c367546ee0ff634beaed81)
+
+## [1.11.4](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.3...@stream-io/video-client-1.11.4) (2024-11-21)
+
+
+### Bug Fixes
+
+* experimental option to force single codec preference in the SDP ([#1581](https://github.com/GetStream/stream-video-js/issues/1581)) ([894a86e](https://github.com/GetStream/stream-video-js/commit/894a86e407dc0dd36b7463bb964c86da0c3055d1))
+
 ## [1.11.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.11.2...@stream-io/video-client-1.11.3) (2024-11-20)
 
 

package/dist/index.browser.es.js

@@ -3190,13 +3190,6 @@ 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
@@ -3335,7 +3328,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.11.3";
+const version = "1.11.5";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -3470,7 +3463,7 @@ const getPreferredCodecs = (kind, preferredCodec, codecToRemove) => {
             continue;
         }
         const sdpFmtpLine = codec.sdpFmtpLine;
-        if (!sdpFmtpLine || !sdpFmtpLine.includes('profile-level-id=42e01f')) {
+        if (!sdpFmtpLine || !sdpFmtpLine.includes('profile-level-id=42')) {
             // this is not the baseline h264 codec, prioritize it lower
             partiallyPreferred.push(codec);
             continue;
@@ -5497,6 +5490,50 @@ const toggleDtx = (sdp, enable) => {
         : `${opusFmtp.original};${requiredDtxConfig}`;
     return sdp.replace(opusFmtp.original, newFmtp);
 };
+/**
+ * Returns and SDP with all the codecs except the given codec removed.
+ */
+const preserveCodec = (sdp, mid, codec) => {
+    const [kind, codecName] = codec.mimeType.toLowerCase().split('/');
+    const toSet = (fmtpLine) => new Set(fmtpLine.split(';').map((f) => f.trim().toLowerCase()));
+    const equal = (a, b) => {
+        if (a.size !== b.size)
+            return false;
+        for (const item of a)
+            if (!b.has(item))
+                return false;
+        return true;
+    };
+    const codecFmtp = toSet(codec.sdpFmtpLine || '');
+    const parsedSdp = SDP.parse(sdp);
+    for (const media of parsedSdp.media) {
+        if (media.type !== kind || String(media.mid) !== mid)
+            continue;
+        // find the payload id of the desired codec
+        const payloads = new Set();
+        for (const rtp of media.rtp) {
+            if (rtp.codec.toLowerCase() === codecName &&
+                media.fmtp.some((f) => f.payload === rtp.payload && equal(toSet(f.config), codecFmtp))) {
+                payloads.add(rtp.payload);
+            }
+        }
+        // find the corresponding rtx codec by matching apt=<preserved-codec-payload>
+        for (const fmtp of media.fmtp) {
+            const match = fmtp.config.match(/(apt)=(\d+)/);
+            if (!match)
+                continue;
+            const [, , preservedCodecPayload] = match;
+            if (payloads.has(Number(preservedCodecPayload))) {
+                payloads.add(fmtp.payload);
+            }
+        }
+        media.rtp = media.rtp.filter((r) => payloads.has(r.payload));
+        media.fmtp = media.fmtp.filter((f) => payloads.has(f.payload));
+        media.rtcpFb = media.rtcpFb?.filter((f) => payloads.has(f.payload));
+        media.payloads = Array.from(payloads).join(' ');
+    }
+    return SDP.write(parsedSdp);
+};
 /**
  * Enables high-quality audio through SDP munging for the given trackMid.
  *
@@ -5900,6 +5937,12 @@ class Publisher {
                 if (this.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
                     offer.sdp = this.enableHighQualityAudio(offer.sdp);
                 }
+                if (this.isPublishing(TrackType.VIDEO)) {
+                    // Hotfix for platforms that don't respect the ordered codec list
+                    // (Firefox, Android, Linux, etc...).
+                    // We remove all the codecs from the SDP except the one we want to use.
+                    offer.sdp = this.removeUnpreferredCodecs(offer.sdp, TrackType.VIDEO);
+                }
             }
             const trackInfos = this.getAnnouncedTracks(offer.sdp);
             if (trackInfos.length === 0) {
@@ -6061,6 +6104,22 @@ class Publisher {
             });
         });
     }
+    removeUnpreferredCodecs(sdp, trackType) {
+        const opts = this.publishOptsForTrack.get(trackType);
+        if (!opts || !opts.forceSingleCodec)
+            return sdp;
+        const codec = opts.forceCodec || opts.preferredCodec;
+        const orderedCodecs = this.getCodecPreferences(trackType, codec);
+        if (!orderedCodecs || orderedCodecs.length === 0)
+            return sdp;
+        const transceiver = this.transceiverCache.get(trackType);
+        if (!transceiver)
+            return sdp;
+        const index = this.transceiverInitOrder.indexOf(trackType);
+        const mid = extractMid(transceiver, index, sdp);
+        const [codecToPreserve] = orderedCodecs;
+        return preserveCodec(sdp, mid, codecToPreserve);
+    }
 }
 
 /**
@@ -11503,6 +11562,33 @@ function buildWsSuccessAfterFailureInsight(connection) {
     return buildWsBaseInsight(connection);
 }
 
+/**
+ * Saving a long-lived reference to a promise that can reject can be unsafe,
+ * since rejecting the promise causes an unhandled rejection error (even if the
+ * rejection is handled everywhere promise result is expected).
+ *
+ * To avoid that, we add both resolution and rejection handlers to the promise.
+ * That way, the saved promise never rejects. A callback is provided as return
+ * value to build a *new* promise, that resolves and rejects along with
+ * the original promise.
+ * @param promise Promise to wrap, which possibly rejects
+ * @returns Callback to build a new promise, which resolves and rejects along
+ * with the original promise
+ */
+function makeSafePromise(promise) {
+    let isPending = true;
+    const safePromise = promise
+        .then((result) => ({ status: 'resolved', result }), (error) => ({ status: 'rejected', error }))
+        .finally(() => (isPending = false));
+    const unwrapPromise = () => safePromise.then((fulfillment) => {
+        if (fulfillment.status === 'rejected')
+            throw fulfillment.error;
+        return fulfillment.result;
+    });
+    unwrapPromise.checkPending = () => isPending;
+    return unwrapPromise;
+}
+
 // Type guards to check WebSocket error type
 const isCloseEvent = (res) => res.code !== undefined;
 const isErrorEvent = (res) => res.error !== undefined;
@@ -11751,10 +11837,10 @@ class StableWSConnection {
         this._setupConnectionPromise = () => {
             this.isResolved = false;
             /** a promise that is resolved once ws.open is called */
-            this.connectionOpen = new Promise((resolve, reject) => {
+            this.connectionOpenSafe = makeSafePromise(new Promise((resolve, reject) => {
                 this.resolvePromise = resolve;
                 this.rejectPromise = reject;
-            });
+            }));
         };
         /**
          * Schedules a next health check ping for websocket.
@@ -11975,13 +12061,7 @@ 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) {
+            if (!this.client.isConnectionIsPromisePending) {
                 this.client._setupConnectionIdPromise();
             }
             this._setupConnectionPromise();
@@ -12101,6 +12181,9 @@ class StableWSConnection {
             // we don't care
         }
     }
+    get connectionOpen() {
+        return this.connectionOpenSafe?.();
+    }
 }
 
 function isString(arrayOrString) {
@@ -12664,19 +12747,21 @@ class StreamClient {
             if (!this.userID) {
                 throw Error('UserWithId is not set on client, use client.connectUser or client.connectAnonymousUser instead');
             }
-            if (this.wsConnection?.isConnecting && this.wsPromise) {
+            const wsPromise = this.wsPromiseSafe?.();
+            if (this.wsConnection?.isConnecting && wsPromise) {
                 this.logger('info', 'client:openConnection() - connection already in progress');
-                return this.wsPromise;
+                return await wsPromise;
             }
             if ((this.wsConnection?.isHealthy || this.wsFallback?.isHealthy()) &&
                 this._hasConnectionID()) {
                 this.logger('info', 'client:openConnection() - openConnection called twice, healthy connection already exists');
-                return Promise.resolve();
+                return;
             }
             this._setupConnectionIdPromise();
             this.clientID = `${this.userID}--${randomId()}`;
-            this.wsPromise = this.connect();
-            return this.wsPromise;
+            const newWsPromise = this.connect();
+            this.wsPromiseSafe = makeSafePromise(newWsPromise);
+            return await newWsPromise;
         };
         /**
          * Disconnects the websocket and removes the user from client.
@@ -12694,7 +12779,7 @@ class StreamClient {
             await this.closeConnection(timeout);
             removeConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.tokenManager.reset();
-            this.connectionIdPromise = undefined;
+            this.connectionIdPromiseSafe = undefined;
             this.rejectConnectionId = undefined;
             this.resolveConnectionId = undefined;
         };
@@ -12755,12 +12840,12 @@ class StreamClient {
         /**
          * sets up the this.connectionIdPromise
          */
-        this._setupConnectionIdPromise = async () => {
+        this._setupConnectionIdPromise = () => {
             /** a promise that is resolved once connection id is set */
-            this.connectionIdPromise = new Promise((resolve, reject) => {
+            this.connectionIdPromiseSafe = makeSafePromise(new Promise((resolve, reject) => {
                 this.resolveConnectionId = resolve;
                 this.rejectConnectionId = reject;
-            });
+            }));
         };
         this._logApiRequest = (type, url, data, config) => {
             this.logger('trace', `client: ${type} - Request - ${url}`, {
@@ -12978,7 +13063,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.11.3";
+            const version = "1.11.5";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -13092,7 +13177,7 @@ class StreamClient {
         });
         // WS connection is initialized when setUser is called
         this.wsConnection = null;
-        this.wsPromise = null;
+        this.wsPromiseSafe = null;
         this.setUserPromise = null;
         // mapping between channel groups and configs
         this.anonymous = false;
@@ -13109,6 +13194,15 @@ class StreamClient {
             ? inputOptions.logger
             : () => null;
     }
+    get connectionIdPromise() {
+        return this.connectionIdPromiseSafe?.();
+    }
+    get isConnectionIsPromisePending() {
+        return this.connectionIdPromiseSafe?.checkPending() ?? false;
+    }
+    get wsPromise() {
+        return this.wsPromiseSafe?.();
+    }
 }
 
 /**
@@ -13118,6 +13212,7 @@ class StreamVideoClient {
     constructor(apiKeyOrArgs, opts) {
         this.logLevel = 'warn';
         this.eventHandlersToUnregister = [];
+        this.connectionConcurrencyTag = Symbol('connectionConcurrencyTag');
         /**
          * 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.
@@ -13139,11 +13234,7 @@ class StreamVideoClient {
                     return this.streamClient.connectGuestUser(user);
                 };
             }
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectUser())
-                : connectUser();
-            this.connectionPromise?.finally(() => (this.connectionPromise = undefined));
-            const connectUserResponse = await this.connectionPromise;
+            const connectUserResponse = await withoutConcurrency(this.connectionConcurrencyTag, () => connectUser());
             // connectUserResponse will be void if connectUser called twice for the same user
             if (connectUserResponse?.me) {
                 this.writeableStateStore.setConnectedUser(connectUserResponse.me);
@@ -13220,17 +13311,13 @@ class StreamVideoClient {
          *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
          */
         this.disconnectUser = async (timeout) => {
-            if (!this.streamClient.user && !this.connectionPromise) {
+            if (!this.streamClient.user) {
                 return;
             }
             const userId = this.streamClient.user?.id;
             const apiKey = this.streamClient.key;
             const disconnectUser = () => this.streamClient.disconnectUser(timeout);
-            this.disconnectionPromise = this.connectionPromise
-                ? this.connectionPromise.then(() => disconnectUser())
-                : disconnectUser();
-            this.disconnectionPromise.finally(() => (this.disconnectionPromise = undefined));
-            await this.disconnectionPromise;
+            await withoutConcurrency(this.connectionConcurrencyTag, () => disconnectUser());
             if (userId) {
                 StreamVideoClient._instanceMap.delete(apiKey + userId);
             }
@@ -13405,11 +13492,7 @@ class StreamVideoClient {
          */
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
             const connectAnonymousUser = () => this.streamClient.connectAnonymousUser(user, tokenOrProvider);
-            this.connectionPromise = this.disconnectionPromise
-                ? this.disconnectionPromise.then(() => connectAnonymousUser())
-                : connectAnonymousUser();
-            this.connectionPromise.finally(() => (this.connectionPromise = undefined));
-            return this.connectionPromise;
+            return await withoutConcurrency(this.connectionConcurrencyTag, () => connectAnonymousUser());
         };
         let logger = logToConsole;
         let logLevel = 'warn';