mediasfu-shared 1.2.2 → 1.2.4

package/dist/{updateParticipantAudioDecibels-C_MygF6q.js → updateParticipantAudioDecibels-DiJ_LFfH.js}

@@ -1,5 +1,5 @@
 import io from "socket.io-client";
-import { v as validateAlphanumeric } from "./validateAlphanumeric-Dk1JB80W.js";
+import { v as validateAlphanumeric, b as audioProcessingConstraints } from "./audioProcessing-0z5KlcmO.js";
 const createFrameworkConsumerContractError = (consumerName) => {
   return new Error(
     `${consumerName} is a render-coupled consumer helper and has no shared runtime implementation. Inject the framework-specific ${consumerName} implementation instead of calling the shared fallback export.`
@@ -765,6 +765,7 @@ async function validateApiKeyToken(value) {
   }
   return true;
 }
+const CONNECT_TIMEOUT_MS = 12e3;
 async function connectSocket({ apiUserName, apiKey, apiToken, link }) {
   if (!apiUserName) {
     throw new Error("API username required.");
@@ -808,7 +809,21 @@ async function connectSocket({ apiUserName, apiKey, apiToken, link }) {
         }
       });
     }
-    socket.on("connection-success", ({ socketId }) => {
+    let settled = false;
+    let timeoutHandle;
+    const cleanupHandshake = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      socket.off("connection-success", handleConnectionSuccess);
+      socket.off("connect_error", handleConnectError);
+      socket.off("disconnect", handleDisconnectBeforeReady);
+    };
+    const settle = (action) => {
+      if (settled) return;
+      settled = true;
+      cleanupHandshake();
+      action();
+    };
+    const handleConnectionSuccess = ({ socketId }) => {
       let conn = "media";
       try {
         if (link.includes("mediasfu.com") && (link.match(/c/g)?.length ?? 0) > 1) {
@@ -817,11 +832,35 @@ async function connectSocket({ apiUserName, apiKey, apiToken, link }) {
       } catch {
       }
       console.log(`Connected to ${conn} socket with ID: ${socketId}`);
-      resolve(socket);
-    });
-    socket.on("connect_error", (error) => {
-      reject(new Error("Error connecting to media socket: " + error.message));
-    });
+      settle(() => resolve(socket));
+    };
+    const handleConnectError = (error) => {
+      settle(() => {
+        socket.disconnect();
+        reject(new Error("Error connecting to media socket: " + error.message));
+      });
+    };
+    const handleDisconnectBeforeReady = (reason) => {
+      settle(
+        () => reject(
+          new Error(
+            "Media socket closed before the room was ready (" + reason + ")."
+          )
+        )
+      );
+    };
+    socket.on("connection-success", handleConnectionSuccess);
+    socket.on("connect_error", handleConnectError);
+    socket.on("disconnect", handleDisconnectBeforeReady);
+    timeoutHandle = setTimeout(() => {
+      settle(() => {
+        try {
+          socket.disconnect();
+        } catch {
+        }
+        reject(new Error("Timed out connecting to media socket."));
+      });
+    }, CONNECT_TIMEOUT_MS);
   });
 }
 async function connectLocalSocket({ link }) {
@@ -847,6 +886,184 @@ async function disconnectSocket({ socket }) {
   }
   return true;
 }
+function attachTransportRecovery(transport, socket, onFailure) {
+  let timer;
+  let disposed = false;
+  let recovering = false;
+  let attempts = 0;
+  const socketId = socket.id;
+  const listeners = [];
+  const report = (state) => {
+    transport.appData = { ...transport.appData, recoveryState: state };
+    transport.observer?.emit("recoverychange", state);
+  };
+  const clearTimer = () => {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+  };
+  const current = () => !disposed && !transport.closed && socket.connected !== false && socket.id === socketId;
+  const dispose = () => {
+    disposed = true;
+    clearTimer();
+    listeners.splice(0).forEach((cancel) => cancel());
+    socket.off?.("disconnect", dispose);
+    transport.off?.("connectionstatechange", changed);
+    transport.observer?.off?.("close", dispose);
+  };
+  const failed = () => {
+    if (disposed) return;
+    report("failed");
+    try {
+      onFailure();
+    } catch (_) {
+    }
+    try {
+      transport.close();
+    } finally {
+      dispose();
+    }
+  };
+  const waitConnected = () => new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      transport.off?.("connectionstatechange", connected);
+      const i = listeners.indexOf(cancel);
+      if (i >= 0) listeners.splice(i, 1);
+      error ? reject(error) : resolve();
+    };
+    const connected = (state) => {
+      if (state === "connected") finish();
+    };
+    const cancel = () => finish(new Error("Recovery cancelled"));
+    const deadline = setTimeout(() => finish(new Error("ICE recovery timed out")), 1e4);
+    listeners.push(cancel);
+    transport.on("connectionstatechange", connected);
+    if (transport.connectionState === "connected") finish();
+  });
+  const restart = async () => {
+    if (!current() || recovering) return;
+    recovering = true;
+    report("recovering");
+    try {
+      while (current() && attempts < 2) {
+        attempts++;
+        try {
+          const iceParameters = await new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error, value) => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(deadline);
+              const i = listeners.indexOf(cancel);
+              if (i >= 0) listeners.splice(i, 1);
+              error ? reject(error) : resolve(value);
+            };
+            const cancel = () => finish(new Error("Recovery cancelled"));
+            const deadline = setTimeout(() => finish(new Error("ICE restart acknowledgement timed out")), 8e3);
+            listeners.push(cancel);
+            socket.emit("transport-restart-ice", { transportId: transport.id }, (response) => {
+              if (!response?.iceParameters || response.error) finish(new Error(response?.error || "Invalid ICE response"));
+              else finish(void 0, response.iceParameters);
+            });
+          });
+          if (!current()) return;
+          await new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(deadline);
+              const i = listeners.indexOf(cancel);
+              if (i >= 0) listeners.splice(i, 1);
+              error ? reject(error) : resolve();
+            };
+            const cancel = () => finish(new Error("Recovery cancelled"));
+            const deadline = setTimeout(() => finish(new Error("Local ICE restart timed out")), 8e3);
+            listeners.push(cancel);
+            Promise.resolve().then(() => {
+              if (!current()) throw new Error("Recovery cancelled");
+              return transport.restartIce({ iceParameters });
+            }).then(() => finish(), (error) => finish(error));
+          });
+          if (!current()) return;
+          await waitConnected();
+          if (!current()) return;
+          attempts = 0;
+          report("connected");
+          return;
+        } catch (_) {
+          if (!current()) return;
+          if (transport.connectionState === "connected") {
+            attempts = 0;
+            report("connected");
+            return;
+          }
+          if (attempts < 2) {
+            await new Promise((resolve) => {
+              const cancel = () => {
+                clearTimeout(delay);
+                const i = listeners.indexOf(cancel);
+                if (i >= 0) listeners.splice(i, 1);
+                resolve();
+              };
+              const delay = setTimeout(cancel, 2100);
+              listeners.push(cancel);
+            });
+          }
+        }
+      }
+      if (current()) failed();
+    } finally {
+      recovering = false;
+    }
+  };
+  const changed = (state) => {
+    if (disposed) return;
+    if (state === "connected") {
+      clearTimer();
+      if (!recovering) {
+        attempts = 0;
+        report("connected");
+      }
+    } else if (state === "disconnected") {
+      if (recovering || timer) return;
+      report("waiting");
+      timer = setTimeout(() => {
+        timer = void 0;
+        void restart();
+      }, 3e3);
+    } else if (state === "failed") {
+      clearTimer();
+      void restart();
+    } else if (state === "closed") dispose();
+  };
+  socket.on?.("disconnect", dispose);
+  transport.on("connectionstatechange", changed);
+  transport.observer?.once("close", dispose);
+  return dispose;
+}
+function clearFailedSendState(parameters, transport, local = false) {
+  const live = parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters;
+  if ((local ? live.localProducerTransport : live.producerTransport) !== transport) return;
+  if (local) {
+    live.updateLocalProducerTransport?.(null);
+    live.updateLocalTransportCreated?.(false);
+    return;
+  }
+  for (const kind of ["Audio", "Video", "Screen"]) {
+    const key = kind.toLowerCase();
+    live["update" + kind + "Producer"]?.(null);
+    live["updateTransportCreated" + kind]?.(false);
+    live["update" + kind + "AlreadyOn"]?.(false);
+    live.socket?.emit("pauseProducerMedia", { mediaTag: key, roomName: live.roomName });
+  }
+  live.updateProducerTransport?.(null);
+  live.updateTransportCreated?.(false);
+  live.showAlert?.({ message: "Media connection could not recover. Rejoin the room to restore audio and video.", type: "danger", duration: 1e4 });
+}
 const signalNewConsumerTransport = async ({
   remoteProducerId,
   islevel,
@@ -893,23 +1110,13 @@ const signalNewConsumerTransport = async ({
               }
             }
           );
-          consumerTransport.on("connectionstatechange", async (state) => {
-            switch (state) {
-              case "connecting":
-                break;
-              case "connected":
-                break;
-              case "failed":
-                consumerTransport.close();
-                if (lock_screen) {
-                  await reorderStreams2({ add: true, parameters });
-                } else {
-                  await reorderStreams2({ add: false, parameters });
-                }
-                break;
-              default:
-                break;
-            }
+          attachTransportRecovery(consumerTransport, nsock, () => {
+            const live = parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters;
+            live.updateConsumingTransports?.((live.consumingTransports || []).filter((id) => id !== remoteProducerId));
+            live.updateConsumerTransports?.((live.consumerTransports || []).filter((entry) => entry.consumerTransport !== consumerTransport));
+            live.showAlert?.({ message: "A remote media connection could not recover. Rejoin to restore it.", type: "danger", duration: 1e4 });
+            void Promise.resolve(reorderStreams2({ add: Boolean(lock_screen), parameters })).catch(() => {
+            });
           });
           await connectRecvTransport2({
             consumerTransport,
@@ -1193,10 +1400,19 @@ const joinConsumeRoom = async ({
 };
 const pendingConsumeConnections = /* @__PURE__ */ new WeakMap();
 const normalizeConsumeEndpoint = (ip) => ip.trim().toLowerCase().replace(/\.$/, "");
-const hasConsumeEndpoint = (consumeSockets, endpoint) => consumeSockets.some((socketObj) => {
-  const ip = Object.keys(socketObj)[0];
-  return Boolean(ip) && normalizeConsumeEndpoint(ip) === endpoint;
-});
+const hasConsumeEndpoint = (consumeSockets, endpoint) => {
+  for (let index = consumeSockets.length - 1; index >= 0; index -= 1) {
+    const socketObj = consumeSockets[index];
+    const ip = Object.keys(socketObj)[0];
+    if (!ip || normalizeConsumeEndpoint(ip) !== endpoint) continue;
+    const socket = socketObj[ip];
+    if (socket?.connected && socket.id) return true;
+    socket?.removeAllListeners?.();
+    socket?.disconnect?.();
+    consumeSockets.splice(index, 1);
+  }
+  return false;
+};
 async function reserveConsumeEndpoint(consumeSockets, ip, reservationOwner = consumeSockets) {
   const endpoint = normalizeConsumeEndpoint(ip);
   if (!endpoint || endpoint === "none") return null;
@@ -1220,6 +1436,9 @@ async function reserveConsumeEndpoint(consumeSockets, ip, reservationOwner = con
     return (didConnect = false) => {
       if (pendingForSockets?.get(endpoint) === reservation) {
         pendingForSockets.delete(endpoint);
+        if (pendingForSockets.size === 0) {
+          pendingConsumeConnections.delete(reservationOwner);
+        }
       }
       resolvePending(didConnect === true);
     };
@@ -1256,8 +1475,9 @@ const connectIps = async ({
       );
       if (!releaseReservation) continue;
       let connected = false;
+      let remote_sock = null;
       try {
-        const remote_sock = await connectSocket({ apiUserName, apiKey, apiToken, link: `https://${ip}.mediasfu.com` });
+        remote_sock = await connectSocket({ apiUserName, apiKey, apiToken, link: `https://${ip}.mediasfu.com` });
         if (remote_sock.id) {
           if (!roomRecvIPs.includes(ip)) {
             roomRecvIPs.push(ip);
@@ -1288,16 +1508,36 @@ const connectIps = async ({
               parameters
             });
             if (!data.rtpCapabilities) {
-              return [consume_sockets, roomRecvIPs];
+              throw new Error(`Consume room ${ip} did not return RTP capabilities.`);
             }
           }
           consume_sockets.push({ [ip]: remote_sock });
           updateConsume_sockets(consume_sockets);
           connected = true;
+          remote_sock.on("disconnect", () => {
+            const socketIndex = consume_sockets.findIndex(
+              (socketObj) => socketObj[ip] === remote_sock
+            );
+            if (socketIndex >= 0) {
+              consume_sockets.splice(socketIndex, 1);
+              updateConsume_sockets(consume_sockets);
+            }
+            const recvIndex = roomRecvIPs.indexOf(ip);
+            if (recvIndex >= 0) {
+              roomRecvIPs.splice(recvIndex, 1);
+              updateRoomRecvIPs(roomRecvIPs);
+            }
+            remote_sock?.removeAllListeners?.();
+            remote_sock?.disconnect();
+          });
         }
       } catch (error) {
         console.log("connectIps error", error);
       } finally {
+        if (!connected && remote_sock) {
+          remote_sock.removeAllListeners?.();
+          remote_sock.disconnect();
+        }
         releaseReservation(connected);
       }
     }
@@ -1813,12 +2053,7 @@ const createLocalSendTransport = async ({
             }
           }
         );
-        createdLocalTransport.on("connectionstatechange", (state) => {
-          if (state === "failed") {
-            console.error("Local transport connection failed.");
-            createdLocalTransport.close();
-          }
-        });
+        attachTransportRecovery(createdLocalTransport, localSocket, () => clearFailedSendState(parameters, createdLocalTransport, true));
         localTransportCreated = true;
         updateLocalTransportCreated?.(localTransportCreated);
         await connectSendTransport2({
@@ -1909,20 +2144,7 @@ const createSendTransport = async ({
             }
           }
         );
-        createdProducerTransport.on("connectionstatechange", async (state) => {
-          switch (state) {
-            case "connecting":
-              break;
-            case "connected":
-              break;
-            case "failed":
-              console.log("Transport connection failed.");
-              createdProducerTransport.close();
-              break;
-            default:
-              break;
-          }
-        });
+        attachTransportRecovery(createdProducerTransport, socket, () => clearFailedSendState(parameters, createdProducerTransport));
         transportCreated = true;
         parameters = parameters.getCurrentParams?.() ?? parameters;
         await connectSendTransport2({
@@ -4138,7 +4360,7 @@ const streamSuccessVideo = async ({
     }
   }
 };
-async function switchUserAudio({ audioPreference, parameters }) {
+async function switchUserAudio({ audioPreference, parameters, audioProcessing }) {
   const {
     mediaDevices,
     prevAudioInputDevice,
@@ -4164,12 +4386,19 @@ async function switchUserAudio({ audioPreference, parameters }) {
         }
       }
     }
+    const track = parameters.localStreamAudio?.getAudioTracks?.()[0] ?? parameters.localStream?.getAudioTracks?.()[0] ?? parameters.audioProducer?.track;
+    const previousConstraints = track?.getConstraints?.() ?? {};
+    const previousSettings = track?.getSettings?.() ?? {};
+    const processing = {};
+    for (const key of ["echoCancellation", "noiseSuppression", "autoGainControl"]) {
+      const value = previousConstraints[key] ?? previousSettings[key];
+      if (value !== void 0) processing[key] = value;
+    }
     const mediaConstraints = {
       audio: {
         deviceId: { exact: audioPreference },
-        echoCancellation: false,
-        noiseSuppression: false,
-        autoGainControl: false
+        ...processing,
+        ...audioProcessingConstraints(audioProcessing)
       },
       video: false
     };
@@ -5429,4 +5658,4 @@ export {
   processConsumerTransportsAudio as y,
   readjust as z
 };
-//# sourceMappingURL=updateParticipantAudioDecibels-C_MygF6q.js.map
+//# sourceMappingURL=updateParticipantAudioDecibels-DiJ_LFfH.js.map