react-jssip-kit 1.0.0 → 1.0.1

package/README.md

@@ -110,6 +110,9 @@ const { remoteStream, audioTracks } = useSessionMedia(sessionId);
 - Hooks: `useSipKernel`, `useSipState`, `useSipSelector`, `useSipActions`, `useSipEvent`, `useSipSessionEvent`, `useSipSessions`, `useSipSession`, `useActiveSipSession`, `useSessionMedia`.
 - Components: `CallPlayer` (basic remote audio element).
 - Kernel utilities: `createSipKernel`, `createSipClientInstance`, `createSipEventManager`.
+- Kernel commands include:
+  - Call/session: `call`, `answer`, `hangup`, `hangupAll`, `toggleMute`, `toggleHold`, `sendDTMF`, `transfer`, `sendInfo`, `update`, `reinvite`.
+  - UA-level: `sendMessage`, `sendOptions`.
 - JsSIP utility: `WebSocketInterface`.
 
 ## Public API Contract (1.0.0)
@@ -125,15 +128,26 @@ Public and supported:
 - `createSipEventManager()`
 - `SipStatus`, `CallStatus`, `CallDirection`
 - Public types exported from root (`SipKernel`, `SipState`, event/call option types)
+- Public state shape: `SipState = { sipStatus, error, sessions }`
 
 Internal (not part of public contract):
 - Direct imports from `src/core/*`
 - `SipContext` object
+- Internal normalized fields (`sessionsById`, `sessionIds`)
 - Any file not re-exported from package root
 
-## Architecture notes
+## Architecture and Lifecycle
 
-- Module map: `docs/MODULES.md`
+Runtime flow (short):
+1. App creates kernel with `createSipKernel()`.
+2. `SipProvider` injects kernel into React tree.
+3. `commands.connect(...)` starts UA and state transitions.
+4. Session events are projected into public `SipState.sessions`.
+5. Media hooks (`useSessionMedia`) observe peer connection/remote tracks.
+6. `commands.disconnect()` stops UA and performs full cleanup.
+
+Detailed module map and full lifecycle:
+- `docs/MODULES.md`
 
 ## Build
 

package/dist/index.cjs

@@ -295,19 +295,35 @@ var SipStateStore = class {
   constructor() {
     this.state = getInitialSipState();
     this.lastState = getInitialSipState();
+    this.publicState = {
+      sipStatus: this.state.sipStatus,
+      error: this.state.error,
+      sessions: this.state.sessions
+    };
     this.listeners = /* @__PURE__ */ new Set();
+    this.publicListeners = /* @__PURE__ */ new Set();
     this.pendingState = null;
     this.updateScheduled = false;
   }
   getState() {
     return this.state;
   }
+  getPublicState() {
+    return this.publicState;
+  }
   onChange(fn) {
     this.listeners.add(fn);
     fn(this.state);
     return () => this.listeners.delete(fn);
   }
+  onPublicChange(fn) {
+    this.publicListeners.add(fn);
+    return () => this.publicListeners.delete(fn);
+  }
   subscribe(fn) {
+    return this.onPublicChange(fn);
+  }
+  subscribeInternal(fn) {
     return this.onChange(fn);
   }
   setState(partial) {
@@ -319,6 +335,11 @@ var SipStateStore = class {
     }
     this.state = next;
     this.lastState = next;
+    this.publicState = {
+      sipStatus: next.sipStatus,
+      error: next.error,
+      sessions: next.sessions
+    };
     this.emit();
   }
   batchSet(partial) {
@@ -339,6 +360,8 @@ var SipStateStore = class {
   emit() {
     for (const fn of this.listeners)
       fn(this.state);
+    for (const fn of this.publicListeners)
+      fn(this.publicState);
   }
 };
 
@@ -400,18 +423,52 @@ var SipDebugRuntime = class {
 };
 
 // src/core/modules/event/sip-event-manager.adapter.ts
+function getSessionFromPayload(payload) {
+  return payload?.session ?? null;
+}
+function getSessionId(session) {
+  return String(session.id ?? "");
+}
 function createSipEventManager(client) {
   return {
     onUA(event, handler) {
       return client.on(event, handler);
     },
     onSession(sessionId, event, handler) {
-      const session = client.getSession(sessionId);
-      if (!session)
-        return () => {
-        };
-      session.on(event, handler);
-      return () => session.off(event, handler);
+      const wrapped = (payload) => {
+        handler(payload);
+      };
+      let attachedSession = null;
+      const detach = () => {
+        if (!attachedSession)
+          return;
+        attachedSession.off(event, wrapped);
+        attachedSession = null;
+      };
+      const attach = (session) => {
+        if (!session)
+          return;
+        const id = getSessionId(session);
+        if (!id || id !== sessionId)
+          return;
+        if (attachedSession === session)
+          return;
+        detach();
+        attachedSession = session;
+        attachedSession.on(event, wrapped);
+      };
+      const offNewSession = client.on("newRTCSession", (payload) => {
+        attach(getSessionFromPayload(payload));
+      });
+      attach(client.getSession(sessionId) ?? null);
+      const offDisconnected = client.on("disconnected", () => {
+        detach();
+      });
+      return () => {
+        offNewSession();
+        offDisconnected();
+        detach();
+      };
     }
   };
 }
@@ -926,15 +983,6 @@ var SessionManager = class {
 };
 
 // src/core/modules/session/session.state.projector.ts
-function toSessionMaps(sessions) {
-  const sessionsById = {};
-  const sessionIds = [];
-  for (const session of sessions) {
-    sessionsById[session.id] = session;
-    sessionIds.push(session.id);
-  }
-  return { sessionsById, sessionIds };
-}
 function holdOtherSessions(state, sessionId, holdFn) {
   const current = state.getState();
   current.sessionIds.forEach((id) => {
@@ -959,19 +1007,26 @@ function upsertSessionState(state, sessionId, partial) {
     acceptedAt: null
   };
   const nextSession = { ...base, ...partial };
-  const sessions = current.sessionIds.map(
-    (id) => id === sessionId ? nextSession : current.sessionsById[id]
-  );
-  if (!existing) {
-    sessions.push(nextSession);
-  }
-  const { sessionsById, sessionIds } = toSessionMaps(sessions);
-  state.setState({ sessions, sessionsById, sessionIds });
+  const sessionsById = {
+    ...current.sessionsById,
+    [sessionId]: nextSession
+  };
+  const sessionIds = existing ? current.sessionIds : [...current.sessionIds, sessionId];
+  const sessions = existing ? current.sessions.map(
+    (session) => session.id === sessionId ? nextSession : session
+  ) : [...current.sessions, nextSession];
+  state.setState({ sessionsById, sessionIds, sessions });
 }
 function removeSessionState(state, sessionId) {
   const current = state.getState();
-  const sessions = current.sessionIds.filter((id) => id !== sessionId).map((id) => current.sessionsById[id]);
-  const { sessionsById, sessionIds } = toSessionMaps(sessions);
+  if (!current.sessionsById[sessionId])
+    return;
+  const sessionsById = { ...current.sessionsById };
+  delete sessionsById[sessionId];
+  const sessionIds = current.sessionIds.filter((id) => id !== sessionId);
+  const sessions = current.sessions.filter(
+    (session) => session.id !== sessionId
+  );
   state.setState({
     sessions,
     sessionsById,
@@ -1149,18 +1204,18 @@ var SessionLifecycle = class {
   }
   handleNewRTCSession(e) {
     const session = e.session;
-    const sessionId = String(
-      session?.id ?? crypto.randomUUID?.() ?? Date.now()
-    );
+    const sessionId = String(session.id ?? crypto.randomUUID?.() ?? Date.now());
     const currentSessions = this.state.getState().sessions;
     if (currentSessions.length >= this.getMaxSessionCount()) {
       try {
-        session.terminate?.({
+        const terminateOptions = {
           status_code: 486,
           reason_phrase: "Busy Here"
-        });
+        };
+        session.terminate(terminateOptions);
       } catch {
       }
+      return;
     }
     const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
     this.sessionManager.setSession(sessionId, session);
@@ -1259,7 +1314,7 @@ var SessionLifecycle = class {
       clearTimeout(retryTimer);
       retryTimer = null;
     };
-    const stopRetry = (opts = {}) => {
+    const stopRetry = () => {
       if (stopped)
         return;
       stopped = true;
@@ -1360,8 +1415,8 @@ var SessionLifecycle = class {
       session.on?.("peerconnection", onPeer);
     }
     session.on?.("confirmed", onConfirmed);
-    session.on?.("ended", (e) => stopRetry());
-    session.on?.("failed", (e) => stopRetry());
+    session.on?.("ended", () => stopRetry());
+    session.on?.("failed", () => stopRetry());
   }
   bindRemoteIncomingAudio(sessionId, session) {
     const maxAttempts = 50;
@@ -1637,8 +1692,9 @@ var SessionModule = class {
   }
   hangupAll(options) {
     const ids = this.getSessionIds();
-    ids.forEach((id) => this.hangupSession(id, options));
-    return ids.length > 0;
+    if (ids.length === 0)
+      return false;
+    return ids.every((id) => this.hangupSession(id, options));
   }
   toggleMuteSession(sessionId) {
     const resolved = this.resolveExistingSessionId(sessionId);
@@ -1667,7 +1723,7 @@ var SessionModule = class {
       this.deps.sessionManager.hold(resolved);
       return true;
     }
-    return true;
+    return false;
   }
   sendDTMFSession(sessionId, tones, options) {
     const resolved = this.resolveExistingSessionId(sessionId);
@@ -1676,8 +1732,9 @@ var SessionModule = class {
     const sessionState = this.deps.state.getState().sessionsById[resolved];
     if (sessionState?.status === CallStatus.Active) {
       this.deps.sessionManager.sendDTMF(resolved, tones, options);
+      return true;
     }
-    return true;
+    return false;
   }
   transferSession(sessionId, target, options) {
     const resolved = this.resolveExistingSessionId(sessionId);
@@ -1686,9 +1743,37 @@ var SessionModule = class {
     const sessionState = this.deps.state.getState().sessionsById[resolved];
     if (sessionState?.status === CallStatus.Active) {
       this.deps.sessionManager.transfer(resolved, target, options);
+      return true;
     }
+    return false;
+  }
+  sendInfoSession(sessionId, contentType, body, options) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    if (sessionState?.status !== CallStatus.Active && sessionState?.status !== CallStatus.Hold) {
+      return false;
+    }
+    const session = this.deps.sessionManager.getSession(resolved);
+    if (!session)
+      return false;
+    session.sendInfo(contentType, body, options);
     return true;
   }
+  updateSession(sessionId, options) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    if (sessionState?.status !== CallStatus.Active && sessionState?.status !== CallStatus.Hold) {
+      return false;
+    }
+    const session = this.deps.sessionManager.getSession(resolved);
+    if (!session)
+      return false;
+    return session.renegotiate(options);
+  }
   getSession(sessionId) {
     return this.deps.sessionManager.getSession(sessionId);
   }
@@ -1731,7 +1816,9 @@ var SessionModule = class {
   }
   cleanupSession(sessionId, session) {
     const targetSession = session ?? this.deps.sessionManager.getSession(sessionId) ?? this.deps.sessionManager.getRtc(sessionId)?.currentSession;
-    this.detachSessionHandlers(sessionId, targetSession);
+    if (targetSession) {
+      this.detachSessionHandlers(sessionId, targetSession);
+    }
     this.deps.micRecovery.disable(sessionId);
     this.deps.sessionManager.cleanupSession(sessionId);
     removeSessionState(this.deps.state, sessionId);
@@ -1886,8 +1973,8 @@ var SipClient = class extends EventTargetEmitter {
       getIceCandidateReadyDelayMs: () => this.iceCandidateReadyDelayMs
     });
     this.debugRuntime = new SipDebugRuntime({
-      getState: () => this.stateStore.getState(),
-      onChange: (listener) => this.stateStore.onChange(listener),
+      getState: () => this.stateStore.getPublicState(),
+      onChange: (listener) => this.stateStore.onPublicChange(listener),
       getSessions: () => this.getSessions(),
       setDebugEnabled: (enabled) => this.sessionModule.setDebugEnabled(enabled)
     });
@@ -1896,7 +1983,7 @@ var SipClient = class extends EventTargetEmitter {
     );
   }
   get state() {
-    return this.stateStore.getState();
+    return this.stateStore.getPublicState();
   }
   connect(uri, password, config) {
     this.disconnect();
@@ -1941,9 +2028,12 @@ var SipClient = class extends EventTargetEmitter {
       const ua = this.userAgent.getUA();
       const session = ua?.call(target, callOptions);
       if (session && callOptions.mediaStream) {
-        const sessionId = String(session?.id ?? "");
+        const sessionId = String(session.id ?? "");
         if (sessionId) {
-          this.sessionModule.setSessionMedia(sessionId, callOptions.mediaStream);
+          this.sessionModule.setSessionMedia(
+            sessionId,
+            callOptions.mediaStream
+          );
           this.sessionModule.setSession(sessionId, session);
         }
       }
@@ -1952,13 +2042,40 @@ var SipClient = class extends EventTargetEmitter {
       this.cleanupAllSessions();
     }
   }
+  sendMessage(target, body, options) {
+    try {
+      const ua = this.userAgent.getUA();
+      if (!ua)
+        return false;
+      ua.sendMessage(target, body, options);
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+  sendOptions(target, body, options) {
+    try {
+      const ua = this.userAgent.getUA();
+      if (!ua)
+        return false;
+      const optionsUa = ua;
+      if (typeof optionsUa.sendOptions !== "function")
+        return false;
+      optionsUa.sendOptions(target, body, options);
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
   hangupAll(options) {
     const ids = this.getSessionIds();
     ids.forEach((id) => this.hangupSession(id, options));
     return ids.length > 0;
   }
   onChange(fn) {
-    return this.stateStore.onChange(fn);
+    return this.stateStore.onPublicChange(fn);
   }
   setDebug(debug) {
     this.debugPattern = debug;
@@ -1994,6 +2111,20 @@ var SipClient = class extends EventTargetEmitter {
   transferSession(sessionId, target, options) {
     return this.sessionModule.transferSession(sessionId, target, options);
   }
+  sendInfoSession(sessionId, contentType, body, options) {
+    return this.sessionModule.sendInfoSession(
+      sessionId,
+      contentType,
+      body,
+      options
+    );
+  }
+  updateSession(sessionId, options) {
+    return this.sessionModule.updateSession(sessionId, options);
+  }
+  reinviteSession(sessionId, options) {
+    return this.sessionModule.updateSession(sessionId, options);
+  }
   setSessionMedia(sessionId, stream) {
     this.sessionModule.setSessionMedia(sessionId, stream);
   }
@@ -2061,6 +2192,8 @@ function createSipKernel() {
       register: () => client.registerUA(),
       setDebug: (debug) => client.setDebug(debug),
       call: (target, options) => client.call(target, options),
+      sendMessage: (target, body, options) => client.sendMessage(target, body, options),
+      sendOptions: (target, body, options) => client.sendOptions(target, body, options),
       answer: (sessionId, options) => client.answerSession(sessionId, options),
       hangup: (sessionId, options) => client.hangupSession(sessionId, options),
       hangupAll: (options) => client.hangupAll(options),
@@ -2068,6 +2201,9 @@ function createSipKernel() {
       toggleHold: (sessionId) => client.toggleHoldSession(sessionId),
       sendDTMF: (sessionId, tones, options) => client.sendDTMFSession(sessionId, tones, options),
       transfer: (sessionId, target, options) => client.transferSession(sessionId, target, options),
+      sendInfo: (sessionId, contentType, body, options) => client.sendInfoSession(sessionId, contentType, body, options),
+      update: (sessionId, options) => client.updateSession(sessionId, options),
+      reinvite: (sessionId, options) => client.reinviteSession(sessionId, options),
       getSession: (sessionId) => client.getSession(sessionId),
       getSessionIds: () => client.getSessionIds(),
       getSessions: () => client.getSessions(),
@@ -2105,6 +2241,8 @@ function useSipActions() {
       register: commands.register,
       setDebug: commands.setDebug,
       call: commands.call,
+      sendMessage: commands.sendMessage,
+      sendOptions: commands.sendOptions,
       answer: commands.answer,
       hangup: commands.hangup,
       hangupAll: commands.hangupAll,
@@ -2112,6 +2250,9 @@ function useSipActions() {
       toggleHold: commands.toggleHold,
       sendDTMF: commands.sendDTMF,
       transfer: commands.transfer,
+      sendInfo: commands.sendInfo,
+      update: commands.update,
+      reinvite: commands.reinvite,
       getSession: commands.getSession,
       getSessionIds: commands.getSessionIds,
       getSessions: commands.getSessions,
@@ -2140,22 +2281,12 @@ function useSipSelector(selector, equalityFn = Object.is) {
   return react.useSyncExternalStore(store.subscribe, getSelection, getSelection);
 }
 
-// src/hooks/useActiveSipSession.ts
-function useActiveSipSession() {
-  return useSipSelector((state) => {
-    const activeId = state.sessionIds.find(
-      (id) => state.sessionsById[id]?.status === CallStatus.Active
-    );
-    return activeId ? state.sessionsById[activeId] : null;
-  });
-}
-
 // src/hooks/useSipSession.ts
 function useSipSession(sessionId) {
   return useSipSelector((state) => {
     if (!sessionId)
       return null;
-    return state.sessionsById[sessionId] ?? null;
+    return state.sessions.find((session) => session.id === sessionId) ?? null;
   });
 }
 function useSipSessions() {
@@ -2180,25 +2311,15 @@ function useSipSessionEvent(sessionId, event, handler) {
 }
 function useSessionMedia(sessionId) {
   const { media } = useSipKernel();
-  const { sessionIds, sessionsById } = useSipSelector(
-    (state) => ({
-      sessionIds: state.sessionIds,
-      sessionsById: state.sessionsById
-    }),
-    (prev, next) => prev.sessionIds === next.sessionIds && prev.sessionsById === next.sessionsById
-  );
-  const [peerConnection, setPeerConnection] = react.useState(
-    null
-  );
+  const sessions = useSipSelector((state) => state.sessions);
+  const [peerConnection, setPeerConnection] = react.useState(null);
   const [remoteStream, setRemoteStream] = react.useState(null);
   const resolvedSessionId = react.useMemo(() => {
     if (sessionId)
       return sessionId;
-    const activeId = sessionIds.find(
-      (id) => sessionsById[id]?.status === CallStatus.Active
-    );
-    return activeId ?? sessionIds[0];
-  }, [sessionId, sessionIds, sessionsById]);
+    const active = sessions.find((s) => s.status === CallStatus.Active);
+    return active?.id ?? sessions[0]?.id;
+  }, [sessionId, sessions]);
   const session = react.useMemo(
     () => resolvedSessionId ? media.getSession(resolvedSessionId) : null,
     [media, resolvedSessionId]
@@ -2206,8 +2327,8 @@ function useSessionMedia(sessionId) {
   const sessionState = react.useMemo(() => {
     if (!resolvedSessionId)
       return null;
-    return sessionsById[resolvedSessionId] ?? null;
-  }, [sessionsById, resolvedSessionId]);
+    return sessions.find((s) => s.id === resolvedSessionId) ?? null;
+  }, [sessions, resolvedSessionId]);
   react.useEffect(() => {
     if (!resolvedSessionId) {
       setPeerConnection(null);
@@ -2261,15 +2382,14 @@ function CallPlayer({ sessionId }) {
   const { remoteStream } = useSessionMedia(sessionId);
   const audioRef = react.useRef(null);
   react.useEffect(() => {
-    if (!audioRef.current)
+    const audioEl = audioRef.current;
+    if (!audioEl)
       return;
-    audioRef.current.srcObject = remoteStream;
-    audioRef.current.play?.().catch(() => {
+    audioEl.srcObject = remoteStream;
+    audioEl.play?.().catch(() => {
     });
     return () => {
-      if (audioRef.current) {
-        audioRef.current.srcObject = null;
-      }
+      audioEl.srcObject = null;
     };
   }, [remoteStream]);
   return /* @__PURE__ */ jsxRuntime.jsx("audio", { ref: audioRef, autoPlay: true, playsInline: true });
@@ -2290,7 +2410,6 @@ exports.SipStatus = SipStatus;
 exports.createSipClientInstance = createSipClientInstance;
 exports.createSipEventManager = createSipEventManager;
 exports.createSipKernel = createSipKernel;
-exports.useActiveSipSession = useActiveSipSession;
 exports.useSessionMedia = useSessionMedia;
 exports.useSipActions = useSipActions;
 exports.useSipEvent = useSipEvent;