mediasfu-shared 1.2.3 → 1.2.5

package/dist/{updateParticipantAudioDecibels-CnEXJBmc.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.`
@@ -886,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,
@@ -932,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,
@@ -1885,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({
@@ -1981,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({
@@ -4210,7 +4360,7 @@ const streamSuccessVideo = async ({
     }
   }
 };
-async function switchUserAudio({ audioPreference, parameters }) {
+async function switchUserAudio({ audioPreference, parameters, audioProcessing }) {
   const {
     mediaDevices,
     prevAudioInputDevice,
@@ -4236,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
     };
@@ -5501,4 +5658,4 @@ export {
   processConsumerTransportsAudio as y,
   readjust as z
 };
-//# sourceMappingURL=updateParticipantAudioDecibels-CnEXJBmc.js.map
+//# sourceMappingURL=updateParticipantAudioDecibels-DiJ_LFfH.js.map