@fishjam-cloud/webrtc-client 0.26.0-rc.1 → 0.26.1-rc.1

package/dist/index.d.mts

@@ -501,6 +501,8 @@ declare class ConnectionManager {
     isConnectionUnstable: () => boolean;
     getConnection: () => RTCPeerConnection;
     addTransceiversIfNeeded: (serverTracks: MediaEvent_OfferData_TrackTypes) => void;
+    private static isLiveRecvTransceiver;
+    private stopExcessRecvTransceivers;
     addTransceiver: (track: MediaStreamTrack, transceiverConfig: RTCRtpTransceiverInit) => void;
     setOnTrackReady: (onTrackReady: (event: RTCTrackEvent) => void) => void;
     setRemoteDescription: (data: RTCSessionDescriptionInit) => Promise<void>;
@@ -597,7 +599,9 @@ declare class WebRTCEndpoint extends WebRTCEndpoint_base {
      * webrtcChannel.on("mediaEvent", (event) => webrtc.receiveMediaEvent(event.data));
      * ```
      */
+    private mediaEventQueue;
     receiveMediaEvent: (mediaEvent: SerializedMediaEvent) => Promise<void>;
+    private handleConnected;
     private getEndpointId;
     private onTrackReady;
     /**

package/dist/index.mjs

@@ -1484,7 +1484,7 @@ var CommandsQueue = class {
 };
 
 // src/ConnectionManager.ts
-var ConnectionManager = class {
+var ConnectionManager = class _ConnectionManager {
   connection;
   constructor(iceServers) {
     this.connection = new RTCPeerConnection({
@@ -1504,15 +1504,29 @@ var ConnectionManager = class {
     return this.connection;
   };
   addTransceiversIfNeeded = (serverTracks) => {
-    const recvTransceivers = this.connection.getTransceivers().filter((elem) => elem.direction === "recvonly");
+    const recvTransceivers = this.connection.getTransceivers().filter(_ConnectionManager.isLiveRecvTransceiver);
     const videoTransceiversAmount = recvTransceivers.filter((elem) => elem.receiver.track.kind === "video").length;
     const audioTransceiversAmount = recvTransceivers.filter((elem) => elem.receiver.track.kind === "audio").length;
-    const videoNeededTypes = Array(serverTracks.video - videoTransceiversAmount).fill("video");
-    const audioNeededTypes = Array(serverTracks.audio - audioTransceiversAmount).fill("audio");
+    const videoDelta = serverTracks.video - videoTransceiversAmount;
+    const audioDelta = serverTracks.audio - audioTransceiversAmount;
+    this.stopExcessRecvTransceivers("video", -videoDelta);
+    this.stopExcessRecvTransceivers("audio", -audioDelta);
+    const videoNeededTypes = Array(Math.max(0, videoDelta)).fill("video");
+    const audioNeededTypes = Array(Math.max(0, audioDelta)).fill("audio");
     [...videoNeededTypes, ...audioNeededTypes].forEach(
       (kind) => this.connection.addTransceiver(kind, { direction: "recvonly" })
     );
   };
+  static isLiveRecvTransceiver = (t) => t.direction === "recvonly" && t.currentDirection !== "stopped";
+  stopExcessRecvTransceivers = (kind, excess) => {
+    if (excess <= 0) return;
+    const candidates = this.connection.getTransceivers().filter((t) => _ConnectionManager.isLiveRecvTransceiver(t) && t.receiver.track?.kind === kind).sort((a, b) => {
+      const aOrphan = a.mid === null ? 0 : 1;
+      const bOrphan = b.mid === null ? 0 : 1;
+      return aOrphan - bOrphan;
+    });
+    candidates.slice(0, excess).forEach((transceiver) => transceiver.stop());
+  };
   addTransceiver = (track, transceiverConfig) => {
     this.connection.addTransceiver(track, transceiverConfig);
   };
@@ -4072,7 +4086,8 @@ var createSimulcastTransceiverConfig = (trackContext, maxBandwidth) => {
     // keep this array from low resolution to high resolution
     // in other case lower resolution encoding can get
     // higher max_bitrate
-    sendEncodings: calculateSimulcastEncodings(encodings, maxBandwidth)
+    sendEncodings: calculateSimulcastEncodings(encodings, maxBandwidth),
+    streams: trackContext.stream ? [trackContext.stream] : []
   };
 };
 var calculateSimulcastEncodings = (encodings, maxBandwidth) => {
@@ -4834,29 +4849,25 @@ var WebRTCEndpoint = class extends EventEmitter3 {
    * webrtcChannel.on("mediaEvent", (event) => webrtc.receiveMediaEvent(event.data));
    * ```
    */
-  receiveMediaEvent = async (mediaEvent) => {
+  mediaEventQueue = Promise.resolve();
+  receiveMediaEvent = (mediaEvent) => {
     const deserializedMediaEvent = deserializeServerMediaEvent(mediaEvent);
-    if (deserializedMediaEvent.connected) {
-      const connectedEvent = deserializedMediaEvent.connected;
-      this.proposedIceServers = connectedEvent.iceServers;
-      this.local.setLocalEndpointId(connectedEvent.endpointId);
-      const localEndpointMetadataJson = connectedEvent.endpointIdToEndpoint[connectedEvent.endpointId]?.metadataJson;
-      if (localEndpointMetadataJson) {
-        this.local.setEndpointMetadata(JSON.parse(localEndpointMetadataJson));
-      }
-      const connectedEndpoint = connectedEvent.endpointIdToEndpoint[connectedEvent.endpointId];
-      if (connectedEndpoint?.metadataJson) {
-        const parsedMetadata = JSON.parse(connectedEndpoint?.metadataJson);
-        this.local.setEndpointMetadata(parsedMetadata);
-      }
-      Object.entries(connectedEvent.endpointIdToEndpoint).filter(([endpointId]) => endpointId !== this.local.getEndpoint().id).forEach(([endpointId, endpoint]) => {
-        this.remote.addRemoteEndpoint(endpointId, endpoint.metadataJson, endpoint.trackIdToTrack);
-      });
-      const remoteEndpoints = Object.values(this.remote.getRemoteEndpoints());
-      this.emit("connected", this.local.getEndpoint().id, remoteEndpoints);
-      return;
-    }
-    if (this.getEndpointId()) await this.handleMediaEvent(deserializedMediaEvent);
+    const next = this.mediaEventQueue.then(() => this.handleMediaEvent(deserializedMediaEvent));
+    this.mediaEventQueue = next.catch(() => void 0);
+    return next;
+  };
+  handleConnected = (connectedEvent) => {
+    this.proposedIceServers = connectedEvent.iceServers;
+    this.local.setLocalEndpointId(connectedEvent.endpointId);
+    const localEndpoint = connectedEvent.endpointIdToEndpoint[connectedEvent.endpointId];
+    if (localEndpoint?.metadataJson) {
+      this.local.setEndpointMetadata(JSON.parse(localEndpoint.metadataJson));
+    }
+    Object.entries(connectedEvent.endpointIdToEndpoint).filter(([endpointId]) => endpointId !== this.local.getEndpoint().id).forEach(([endpointId, endpoint]) => {
+      this.remote.addRemoteEndpoint(endpointId, endpoint.metadataJson, endpoint.trackIdToTrack);
+    });
+    const remoteEndpoints = Object.values(this.remote.getRemoteEndpoints());
+    this.emit("connected", this.local.getEndpoint().id, remoteEndpoints);
   };
   getEndpointId = () => this.local.getEndpoint().id;
   onTrackReady = (event) => {
@@ -4905,6 +4916,11 @@ var WebRTCEndpoint = class extends EventEmitter3 {
     return this.dataChannelManager?.getChannelsReadiness() ?? false;
   }
   handleMediaEvent = async (event) => {
+    if (event.connected) {
+      this.handleConnected(event.connected);
+      return;
+    }
+    if (!this.getEndpointId()) return;
     if (event.offerData) {
       await this.onOfferData(event.offerData);
     } else if (event.tracksAdded) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/webrtc-client",
-  "version": "0.26.0-rc.1",
+  "version": "0.26.1-rc.1",
   "description": "Typescript client library for ExWebRTC/WebRTC endpoint in Membrane RTC Engine",
   "license": "Apache-2.0",
   "author": "Fishjam Team",