react-jssip-kit 0.7.8 → 0.7.9

package/dist/index.cjs

@@ -473,6 +473,175 @@ function removeSessionState(state, sessionId) {
   });
 }
 
+// src/jssip-lib/sip/debugLogging.ts
+var describePc = (pc) => ({
+  connectionState: pc?.connectionState,
+  signalingState: pc?.signalingState,
+  iceConnectionState: pc?.iceConnectionState
+});
+var SipDebugLogger = class {
+  constructor() {
+    this.enabled = false;
+    this.statsStops = /* @__PURE__ */ new Map();
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    if (!enabled) {
+      this.statsStops.forEach((stop) => stop());
+      this.statsStops.clear();
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  logLocalAudioError(sessionId, message, pc, extra) {
+    if (!this.enabled)
+      return;
+    console.error(message, {
+      sessionId,
+      pc: describePc(pc),
+      ...extra
+    });
+    void this.logOutboundStats(sessionId, pc, message);
+  }
+  logRemoteAudioError(sessionId, message, pc, extra) {
+    if (!this.enabled)
+      return;
+    console.error(message, {
+      sessionId,
+      pc: describePc(pc),
+      ...extra
+    });
+    void this.logInboundStats(sessionId, pc, message);
+  }
+  logMicRecoveryDrop(payload) {
+    if (!this.enabled)
+      return;
+    console.error("[sip] microphone dropped", payload);
+  }
+  logIceReady(sessionId, payload) {
+    if (!this.enabled)
+      return;
+    console.info("[sip] ice ready", { sessionId, ...payload });
+  }
+  logIceReadyConfig(sessionId, delayMs) {
+    if (!this.enabled)
+      return;
+    console.info("[sip] ice ready config", { sessionId, delayMs });
+  }
+  startCallStatsLogging(sessionId, session) {
+    if (!this.enabled || this.statsStops.has(sessionId))
+      return;
+    let pc = session?.connection ?? null;
+    const onPeer = (data) => {
+      pc = data.peerconnection;
+    };
+    session.on?.("peerconnection", onPeer);
+    const intervalMs = 3e3;
+    const logStats = async () => {
+      if (!this.enabled || !pc?.getStats)
+        return;
+      try {
+        const report = await pc.getStats();
+        const { outboundAudio, inboundAudio } = collectAudioStats(report);
+        console.info("[sip] call stats", {
+          sessionId,
+          pc: describePc(pc),
+          outboundAudio,
+          inboundAudio
+        });
+      } catch (err) {
+        console.error("[sip] call stats failed", { sessionId, error: err });
+      }
+    };
+    const timer = setInterval(() => {
+      void logStats();
+    }, intervalMs);
+    void logStats();
+    const stop = () => {
+      clearInterval(timer);
+      session.off?.("peerconnection", onPeer);
+      this.statsStops.delete(sessionId);
+    };
+    this.statsStops.set(sessionId, stop);
+  }
+  stopCallStatsLogging(sessionId) {
+    const stop = this.statsStops.get(sessionId);
+    if (stop)
+      stop();
+  }
+  async logOutboundStats(sessionId, pc, context) {
+    if (!pc?.getStats)
+      return;
+    try {
+      const report = await pc.getStats();
+      const { outboundAudio } = collectAudioStats(report);
+      if (outboundAudio.length) {
+        console.info("[sip] outgoing audio stats", {
+          sessionId,
+          context,
+          outboundAudio
+        });
+      }
+    } catch (err) {
+      console.error("[sip] outgoing audio stats failed", {
+        sessionId,
+        context,
+        error: err
+      });
+    }
+  }
+  async logInboundStats(sessionId, pc, context) {
+    if (!pc?.getStats)
+      return;
+    try {
+      const report = await pc.getStats();
+      const { inboundAudio } = collectAudioStats(report);
+      if (inboundAudio.length) {
+        console.error("[sip] incoming audio stats", {
+          sessionId,
+          context,
+          inboundAudio
+        });
+      }
+    } catch (err) {
+      console.error("[sip] incoming audio stats failed", {
+        sessionId,
+        context,
+        error: err
+      });
+    }
+  }
+};
+var sipDebugLogger = new SipDebugLogger();
+function collectAudioStats(report) {
+  const outboundAudio = [];
+  const inboundAudio = [];
+  report.forEach((stat) => {
+    const kind = stat.kind ?? stat.mediaType;
+    if (stat.type === "outbound-rtp" && kind === "audio") {
+      outboundAudio.push({
+        id: stat.id,
+        packetsSent: stat.packetsSent,
+        bytesSent: stat.bytesSent,
+        jitter: stat.jitter,
+        roundTripTime: stat.roundTripTime
+      });
+    }
+    if (stat.type === "inbound-rtp" && kind === "audio") {
+      inboundAudio.push({
+        id: stat.id,
+        packetsReceived: stat.packetsReceived,
+        packetsLost: stat.packetsLost,
+        bytesReceived: stat.bytesReceived,
+        jitter: stat.jitter,
+        roundTripTime: stat.roundTripTime
+      });
+    }
+  });
+  return { outboundAudio, inboundAudio };
+}
+
 // src/jssip-lib/sip/handlers/sessionHandlers.ts
 function createSessionHandlers(deps) {
   const {
@@ -481,8 +650,20 @@ function createSessionHandlers(deps) {
     rtc,
     detachSessionHandlers,
     onSessionFailed,
-    sessionId
+    sessionId,
+    iceCandidateReadyDelayMs
   } = deps;
+  let iceReadyCalled = false;
+  let iceReadyTimer = null;
+  const clearIceReadyTimer = () => {
+    if (!iceReadyTimer)
+      return;
+    clearTimeout(iceReadyTimer);
+    iceReadyTimer = null;
+  };
+  if (typeof iceCandidateReadyDelayMs === "number") {
+    sipDebugLogger.logIceReadyConfig(sessionId, iceCandidateReadyDelayMs);
+  }
   return {
     progress: (e) => {
       emitter.emit("progress", e);
@@ -505,6 +686,7 @@ function createSessionHandlers(deps) {
     },
     ended: (e) => {
       emitter.emit("ended", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       const nextSessions = state.getState().sessions.filter((s) => s.id !== sessionId);
@@ -514,6 +696,7 @@ function createSessionHandlers(deps) {
     },
     failed: (e) => {
       emitter.emit("failed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       const cause = e?.cause || "call failed";
@@ -542,13 +725,55 @@ function createSessionHandlers(deps) {
     reinvite: (e) => emitter.emit("reinvite", e),
     update: (e) => emitter.emit("update", e),
     sdp: (e) => emitter.emit("sdp", e),
-    icecandidate: (e) => emitter.emit("icecandidate", e),
+    icecandidate: (e) => {
+      const candidate = e?.candidate;
+      const ready = typeof e?.ready === "function" ? e.ready : null;
+      const delayMs = typeof iceCandidateReadyDelayMs === "number" ? iceCandidateReadyDelayMs : null;
+      if (!iceReadyCalled && ready && delayMs != null) {
+        if (candidate?.type === "srflx" && candidate?.relatedAddress != null && candidate?.relatedPort != null) {
+          iceReadyCalled = true;
+          if (iceReadyTimer) {
+            clearTimeout(iceReadyTimer);
+            iceReadyTimer = null;
+          }
+          sipDebugLogger.logIceReady(sessionId, {
+            source: "srflx",
+            delayMs,
+            candidateType: candidate?.type
+          });
+          ready();
+        } else if (!iceReadyTimer && delayMs > 0) {
+          iceReadyTimer = setTimeout(() => {
+            iceReadyTimer = null;
+            if (iceReadyCalled)
+              return;
+            iceReadyCalled = true;
+            sipDebugLogger.logIceReady(sessionId, {
+              source: "timer",
+              delayMs,
+              candidateType: candidate?.type
+            });
+            ready();
+          }, delayMs);
+        } else if (delayMs === 0) {
+          iceReadyCalled = true;
+          sipDebugLogger.logIceReady(sessionId, {
+            source: "immediate",
+            delayMs,
+            candidateType: candidate?.type
+          });
+          ready();
+        }
+      }
+      emitter.emit("icecandidate", e);
+    },
     refer: (e) => emitter.emit("refer", e),
     replaces: (e) => emitter.emit("replaces", e),
     newDTMF: (e) => emitter.emit("newDTMF", e),
     newInfo: (e) => emitter.emit("newInfo", e),
     getusermediafailed: (e) => {
       emitter.emit("getusermediafailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("getUserMedia failed", e);
@@ -558,6 +783,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:createofferfailed": (e) => {
       emitter.emit("peerconnection:createofferfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection createOffer failed", e);
@@ -567,6 +793,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:createanswerfailed": (e) => {
       emitter.emit("peerconnection:createanswerfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection createAnswer failed", e);
@@ -576,6 +803,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:setlocaldescriptionfailed": (e) => {
       emitter.emit("peerconnection:setlocaldescriptionfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection setLocalDescription failed", e);
@@ -585,6 +813,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:setremotedescriptionfailed": (e) => {
       emitter.emit("peerconnection:setremotedescriptionfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection setRemoteDescription failed", e);
@@ -837,165 +1066,6 @@ var SessionManager = class {
   }
 };
 
-// src/jssip-lib/sip/debugLogging.ts
-var describePc = (pc) => ({
-  connectionState: pc?.connectionState,
-  signalingState: pc?.signalingState,
-  iceConnectionState: pc?.iceConnectionState
-});
-var SipDebugLogger = class {
-  constructor() {
-    this.enabled = false;
-    this.statsStops = /* @__PURE__ */ new Map();
-  }
-  setEnabled(enabled) {
-    this.enabled = enabled;
-    if (!enabled) {
-      this.statsStops.forEach((stop) => stop());
-      this.statsStops.clear();
-    }
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  logLocalAudioError(sessionId, message, pc, extra) {
-    if (!this.enabled)
-      return;
-    console.error(message, {
-      sessionId,
-      pc: describePc(pc),
-      ...extra
-    });
-    void this.logOutboundStats(sessionId, pc, message);
-  }
-  logRemoteAudioError(sessionId, message, pc, extra) {
-    if (!this.enabled)
-      return;
-    console.error(message, {
-      sessionId,
-      pc: describePc(pc),
-      ...extra
-    });
-    void this.logInboundStats(sessionId, pc, message);
-  }
-  logMicRecoveryDrop(payload) {
-    if (!this.enabled)
-      return;
-    console.error("[sip] microphone dropped", payload);
-  }
-  startCallStatsLogging(sessionId, session) {
-    if (!this.enabled || this.statsStops.has(sessionId))
-      return;
-    let pc = session?.connection ?? null;
-    const onPeer = (data) => {
-      pc = data.peerconnection;
-    };
-    session.on?.("peerconnection", onPeer);
-    const intervalMs = 3e3;
-    const logStats = async () => {
-      if (!this.enabled || !pc?.getStats)
-        return;
-      try {
-        const report = await pc.getStats();
-        const { outboundAudio, inboundAudio } = collectAudioStats(report);
-        console.info("[sip] call stats", {
-          sessionId,
-          pc: describePc(pc),
-          outboundAudio,
-          inboundAudio
-        });
-      } catch (err) {
-        console.error("[sip] call stats failed", { sessionId, error: err });
-      }
-    };
-    const timer = setInterval(() => {
-      void logStats();
-    }, intervalMs);
-    void logStats();
-    const stop = () => {
-      clearInterval(timer);
-      session.off?.("peerconnection", onPeer);
-      this.statsStops.delete(sessionId);
-    };
-    this.statsStops.set(sessionId, stop);
-  }
-  stopCallStatsLogging(sessionId) {
-    const stop = this.statsStops.get(sessionId);
-    if (stop)
-      stop();
-  }
-  async logOutboundStats(sessionId, pc, context) {
-    if (!pc?.getStats)
-      return;
-    try {
-      const report = await pc.getStats();
-      const { outboundAudio } = collectAudioStats(report);
-      if (outboundAudio.length) {
-        console.info("[sip] outgoing audio stats", {
-          sessionId,
-          context,
-          outboundAudio
-        });
-      }
-    } catch (err) {
-      console.error("[sip] outgoing audio stats failed", {
-        sessionId,
-        context,
-        error: err
-      });
-    }
-  }
-  async logInboundStats(sessionId, pc, context) {
-    if (!pc?.getStats)
-      return;
-    try {
-      const report = await pc.getStats();
-      const { inboundAudio } = collectAudioStats(report);
-      if (inboundAudio.length) {
-        console.error("[sip] incoming audio stats", {
-          sessionId,
-          context,
-          inboundAudio
-        });
-      }
-    } catch (err) {
-      console.error("[sip] incoming audio stats failed", {
-        sessionId,
-        context,
-        error: err
-      });
-    }
-  }
-};
-var sipDebugLogger = new SipDebugLogger();
-function collectAudioStats(report) {
-  const outboundAudio = [];
-  const inboundAudio = [];
-  report.forEach((stat) => {
-    const kind = stat.kind ?? stat.mediaType;
-    if (stat.type === "outbound-rtp" && kind === "audio") {
-      outboundAudio.push({
-        id: stat.id,
-        packetsSent: stat.packetsSent,
-        bytesSent: stat.bytesSent,
-        jitter: stat.jitter,
-        roundTripTime: stat.roundTripTime
-      });
-    }
-    if (stat.type === "inbound-rtp" && kind === "audio") {
-      inboundAudio.push({
-        id: stat.id,
-        packetsReceived: stat.packetsReceived,
-        packetsLost: stat.packetsLost,
-        bytesReceived: stat.bytesReceived,
-        jitter: stat.jitter,
-        roundTripTime: stat.roundTripTime
-      });
-    }
-  });
-  return { outboundAudio, inboundAudio };
-}
-
 // src/jssip-lib/sip/sessionLifecycle.ts
 var SessionLifecycle = class {
   constructor(deps) {
@@ -1640,9 +1710,11 @@ var SipClient = class extends EventTargetEmitter {
       micRecoveryIntervalMs,
       micRecoveryMaxRetries,
       maxSessionCount,
+      iceCandidateReadyDelayMs,
       ...uaCfg
     } = config;
     this.maxSessionCount = typeof maxSessionCount === "number" ? maxSessionCount : Infinity;
+    this.iceCandidateReadyDelayMs = typeof iceCandidateReadyDelayMs === "number" ? iceCandidateReadyDelayMs : void 0;
     this.micRecovery.configure({
       enabled: Boolean(enableMicRecovery),
       intervalMs: micRecoveryIntervalMs,
@@ -1790,6 +1862,7 @@ var SipClient = class extends EventTargetEmitter {
       emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
       onSessionFailed: (err, event) => this.onSessionFailed(err, event),
       enableMicrophoneRecovery: (confirmedSessionId) => this.micRecovery.enable(confirmedSessionId),
+      iceCandidateReadyDelayMs: this.iceCandidateReadyDelayMs,
       sessionId
     });
   }