react-jssip-kit 0.5.0 → 0.5.2

package/dist/index.d.ts

@@ -1,99 +1,418 @@
-import * as jssip_lib_UA from 'jssip/lib/UA';
-import { RTCSessionEvent, IncomingRTCSessionEvent, UAEventMap, UAConfiguration, CallOptions } from 'jssip/lib/UA';
-export { CallOptions, RTCSessionEvent, UAEventMap } from 'jssip/lib/UA';
-import * as jssip_lib_RTCSession from 'jssip/lib/RTCSession';
-import { RTCSessionEventMap, DTFMOptions as DTFMOptions$1, AnswerOptions, TerminateOptions, RTCSession, ReferOptions } from 'jssip/lib/RTCSession';
-export { AnswerOptions, RTCSession, RTCSessionEventMap, ReferOptions, TerminateOptions } from 'jssip/lib/RTCSession';
 import { UA } from 'jssip';
 export { WebSocketInterface } from 'jssip';
 import * as react from 'react';
 import react__default from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-type ExtraEvents = {
-    error: {
-        cause: string;
-        code?: string;
-        raw?: any;
-        message?: string;
-    };
-    missed: IncomingRTCSessionEvent;
-    sessionCleanup: {
-        sessionId: string;
-        session?: jssip_lib_RTCSession.RTCSession | null;
-    };
+type Originator = "local" | "remote" | "system";
+type SessionDirection = "incoming" | "outgoing";
+
+interface SIPURI {
+  user: string;
+}
+
+interface NameAddrHeader {
+  uri: SIPURI;
+}
+
+interface IncomingRequest {
+  body?: string | { toString(): string };
+  from: NameAddrHeader;
+  to: NameAddrHeader;
+}
+
+interface OutgoingRequest {
+  body?: string | { toString(): string };
+  from: NameAddrHeader;
+  to: NameAddrHeader;
+}
+
+interface IncomingResponse {
+  status_code?: number;
+  reason_phrase?: string;
+}
+
+interface ExtraHeaders {
+  extraHeaders?: string[];
+}
+
+interface AnswerOptions extends ExtraHeaders {
+  mediaConstraints?: MediaStreamConstraints;
+  mediaStream?: MediaStream;
+  pcConfig?: RTCConfiguration;
+  rtcConstraints?: object;
+  rtcAnswerConstraints?: RTCOfferOptions;
+  rtcOfferConstraints?: RTCOfferOptions;
+  sessionTimersExpires?: number;
+}
+
+interface RejectOptions extends ExtraHeaders {
+  status_code?: number;
+  reason_phrase?: string;
+}
+
+interface TerminateOptions extends RejectOptions {
+  body?: string;
+  cause?: string;
+}
+
+interface ReferOptions extends ExtraHeaders {
+  eventHandlers?: Record<string, unknown>;
+  replaces?: RTCSession;
+}
+
+interface DTFMOptions extends ExtraHeaders {
+  duration?: number;
+  interToneGap?: number;
+  transportType?: string;
+}
+
+interface HoldOptions extends ExtraHeaders {
+  useUpdate?: boolean;
+}
+
+interface MediaStreamTypes {
+  audio?: boolean;
+  video?: boolean;
+}
+
+interface DTMF {
+  tone: string;
+  duration: number;
+}
+
+interface Info {
+  contentType: string;
+  body: string;
+}
+
+interface PeerConnectionEvent {
+  peerconnection: RTCPeerConnection;
+}
+
+interface ConnectingEvent {
+  request: IncomingRequest | OutgoingRequest;
+}
+
+interface SendingEvent {
+  request: OutgoingRequest;
+}
+
+interface IncomingEvent {
+  originator: Originator;
+}
+
+interface OutgoingEvent {
+  originator: Originator;
+  response?: IncomingResponse;
+}
+
+interface IncomingAckEvent {
+  originator: Originator;
+  ack: IncomingRequest;
+}
+
+interface OutgoingAckEvent {
+  originator: Originator;
+}
+
+interface EndEvent {
+  originator: Originator;
+  message?: IncomingRequest | IncomingResponse;
+  cause?: string;
+}
+
+interface IncomingDTMFEvent {
+  originator: Originator;
+  dtmf: DTMF;
+  request?: IncomingRequest;
+}
+
+interface OutgoingDTMFEvent {
+  originator: Originator;
+  dtmf: DTMF;
+  request?: OutgoingRequest;
+}
+
+interface IncomingInfoEvent {
+  originator: Originator;
+  info: Info;
+  request?: IncomingRequest;
+}
+
+interface OutgoingInfoEvent {
+  originator: Originator;
+  info: Info;
+  request?: OutgoingRequest;
+}
+
+interface HoldEvent {
+  originator: Originator;
+}
+
+interface ReInviteEvent {
+  request?: IncomingRequest;
+  callback?: VoidFunction;
+  reject?: (options?: RejectOptions) => void;
+}
+
+interface ReferEvent {
+  request?: IncomingRequest;
+  accept?: () => void;
+  reject?: VoidFunction;
+}
+
+interface SDPEvent {
+  originator: Originator;
+  type: string;
+  sdp: string;
+}
+
+interface IceCandidateEvent {
+  candidate: RTCIceCandidate;
+  ready: VoidFunction;
+}
+
+interface IncomingRTCSessionEvent {
+  originator: "remote";
+  session: RTCSession;
+  request: IncomingRequest;
+}
+
+interface OutgoingRTCSessionEvent {
+  originator: "local";
+  session: RTCSession;
+  request: OutgoingRequest;
+}
+
+type RTCSessionEvent = IncomingRTCSessionEvent | OutgoingRTCSessionEvent;
+
+type RTCSessionEventMap = {
+  peerconnection: (event: PeerConnectionEvent) => void;
+  connecting: (event: ConnectingEvent) => void;
+  sending: (event: SendingEvent) => void;
+  progress: (event: IncomingEvent | OutgoingEvent) => void;
+  accepted: (event: IncomingEvent | OutgoingEvent) => void;
+  confirmed: (event: IncomingAckEvent | OutgoingAckEvent) => void;
+  ended: (event: EndEvent) => void;
+  failed: (event: EndEvent) => void;
+  newDTMF: (event: IncomingDTMFEvent | OutgoingDTMFEvent) => void;
+  newInfo: (event: IncomingInfoEvent | OutgoingInfoEvent) => void;
+  hold: (event: HoldEvent) => void;
+  unhold: (event: HoldEvent) => void;
+  muted: (event: MediaStreamTypes) => void;
+  unmuted: (event: MediaStreamTypes) => void;
+  reinvite: (event: ReInviteEvent) => void;
+  update: (event: ReInviteEvent) => void;
+  refer: (event: ReferEvent) => void;
+  replaces: (event: ReferEvent) => void;
+  sdp: (event: SDPEvent) => void;
+  icecandidate: (event: IceCandidateEvent) => void;
+  getusermediafailed: (error: unknown) => void;
+  "peerconnection:createofferfailed": (error: unknown) => void;
+  "peerconnection:createanswerfailed": (error: unknown) => void;
+  "peerconnection:setlocaldescriptionfailed": (error: unknown) => void;
+  "peerconnection:setremotedescriptionfailed": (error: unknown) => void;
 };
-declare const JsSIPEventName: {
-    readonly connecting: "connecting";
-    readonly connected: "connected";
-    readonly disconnected: "disconnected";
-    readonly registered: "registered";
-    readonly unregistered: "unregistered";
-    readonly registrationFailed: "registrationFailed";
-    readonly registrationExpiring: "registrationExpiring";
-    readonly newRTCSession: "newRTCSession";
-    readonly newMessage: "newMessage";
-    readonly sipEvent: "sipEvent";
-    readonly newOptions: "newOptions";
-    readonly peerconnection: "peerconnection";
-    readonly sending: "sending";
-    readonly progress: "progress";
-    readonly accepted: "accepted";
-    readonly confirmed: "confirmed";
-    readonly ended: "ended";
-    readonly failed: "failed";
-    readonly newDTMF: "newDTMF";
-    readonly newInfo: "newInfo";
-    readonly hold: "hold";
-    readonly unhold: "unhold";
-    readonly muted: "muted";
-    readonly unmuted: "unmuted";
-    readonly reinvite: "reinvite";
-    readonly update: "update";
-    readonly refer: "refer";
-    readonly replaces: "replaces";
-    readonly sdp: "sdp";
-    readonly error: "error";
-    readonly icecandidate: "icecandidate";
-    readonly getusermediafailed: "getusermediafailed";
-    readonly "peerconnection:createofferfailed": "peerconnection:createofferfailed";
-    readonly "peerconnection:createanswerfailed": "peerconnection:createanswerfailed";
-    readonly "peerconnection:setlocaldescriptionfailed": "peerconnection:setlocaldescriptionfailed";
-    readonly "peerconnection:setremotedescriptionfailed": "peerconnection:setremotedescriptionfailed";
-    readonly missed: "missed";
-    readonly sessionCleanup: "sessionCleanup";
-};type JsSIPEventName = keyof typeof JsSIPEventName;
-type JsSIPEventPayload<K extends JsSIPEventName> = BaseJsSIPEventPayload<K>;
-type BaseJsSIPEventPayload<K extends JsSIPEventName> = K extends "newRTCSession" ? RTCSessionEvent : K extends "missed" ? IncomingRTCSessionEvent : K extends keyof UAEventMap ? Parameters<UAEventMap[K]>[0] : K extends keyof RTCSessionEventMap ? Parameters<RTCSessionEventMap[K]>[0] : K extends keyof ExtraEvents ? ExtraEvents[K] : never;
-type JsSIPEventHandler<K extends JsSIPEventName> = (payload?: JsSIPEventPayload<K>) => void;
-type SipEventHandlers = {
-    [K in JsSIPEventName]?: JsSIPEventHandler<K>;
-};
+
+interface RTCSession {
+  id: string;
+  direction: SessionDirection;
+  connection?: RTCPeerConnection;
+  answer(options?: AnswerOptions): void;
+  terminate(options?: TerminateOptions): void;
+  mute(options?: MediaStreamTypes): void;
+  unmute(options?: MediaStreamTypes): void;
+  hold(options?: HoldOptions, done?: VoidFunction): boolean;
+  unhold(options?: HoldOptions, done?: VoidFunction): boolean;
+  sendDTMF(tones: string | number, options?: DTFMOptions): void;
+  refer(target: string | RTCSession, options?: ReferOptions): void;
+  on<K extends keyof RTCSessionEventMap>(
+    type: K,
+    listener: RTCSessionEventMap[K]
+  ): this;
+  off<K extends keyof RTCSessionEventMap>(
+    type: K,
+    listener: RTCSessionEventMap[K]
+  ): this;
+}
+
+interface UAConfiguration {
+  sockets: unknown | unknown[];
+  uri: string;
+  password?: string;
+  [key: string]: unknown;
+}
+
+interface CallOptions extends AnswerOptions {
+  eventHandlers?: Partial<RTCSessionEventMap>;
+  anonymous?: boolean;
+  fromUserName?: string;
+  fromDisplayName?: string;
+}
+
+interface ConnectingUAEvent {
+  socket: unknown;
+  attempts: number;
+}
+
+interface ConnectedEvent {
+  socket: unknown;
+}
+
+interface DisconnectEvent {
+  socket: unknown;
+  error: boolean;
+  code?: number;
+  reason?: string;
+}
+
+interface RegisteredEvent {
+  response: IncomingResponse;
+}
+
+interface UnRegisteredEvent {
+  response: IncomingResponse;
+  cause?: string;
+}
+
+interface IncomingMessageEvent {
+  originator: Originator;
+  message: unknown;
+  request: IncomingRequest;
+}
+
+interface OutgoingMessageEvent {
+  originator: Originator;
+  message: unknown;
+  request: OutgoingRequest;
+}
+
+interface IncomingOptionsEvent {
+  originator: Originator;
+  request: IncomingRequest;
+}
+
+interface OutgoingOptionsEvent {
+  originator: Originator;
+  request: OutgoingRequest;
+}
+
+type UAEventMap = {
+  connecting: (event: ConnectingUAEvent) => void;
+  connected: (event: ConnectedEvent) => void;
+  disconnected: (event: DisconnectEvent) => void;
+  registered: (event: RegisteredEvent) => void;
+  unregistered: (event: UnRegisteredEvent) => void;
+  registrationFailed: (event: UnRegisteredEvent) => void;
+  registrationExpiring: () => void;
+  newRTCSession: (event: RTCSessionEvent) => void;
+  newMessage: (event: IncomingMessageEvent | OutgoingMessageEvent) => void;
+  sipEvent: (event: { event: unknown; request: IncomingRequest }) => void;
+  newOptions: (event: IncomingOptionsEvent | OutgoingOptionsEvent) => void;
+};
+
+type UAExtraEvents = {
+  error: { cause: string; code?: string; raw?: any; message?: string };
+  missed: IncomingRTCSessionEvent;
+};
+
+type UAEventName = keyof UAEventMap | keyof UAExtraEvents;
+type SessionEventName = keyof RTCSessionEventMap;
+
+declare const JsSIPEventName: {
+  readonly connecting: "connecting";
+  readonly connected: "connected";
+  readonly disconnected: "disconnected";
+  readonly registered: "registered";
+  readonly unregistered: "unregistered";
+  readonly registrationFailed: "registrationFailed";
+  readonly registrationExpiring: "registrationExpiring";
+  readonly newRTCSession: "newRTCSession";
+  readonly newMessage: "newMessage";
+  readonly sipEvent: "sipEvent";
+  readonly newOptions: "newOptions";
+  readonly peerconnection: "peerconnection";
+  readonly sending: "sending";
+  readonly progress: "progress";
+  readonly accepted: "accepted";
+  readonly confirmed: "confirmed";
+  readonly ended: "ended";
+  readonly failed: "failed";
+  readonly newDTMF: "newDTMF";
+  readonly newInfo: "newInfo";
+  readonly hold: "hold";
+  readonly unhold: "unhold";
+  readonly muted: "muted";
+  readonly unmuted: "unmuted";
+  readonly reinvite: "reinvite";
+  readonly update: "update";
+  readonly refer: "refer";
+  readonly replaces: "replaces";
+  readonly sdp: "sdp";
+  readonly error: "error";
+  readonly icecandidate: "icecandidate";
+  readonly getusermediafailed: "getusermediafailed";
+  readonly "peerconnection:createofferfailed": "peerconnection:createofferfailed";
+  readonly "peerconnection:createanswerfailed": "peerconnection:createanswerfailed";
+  readonly "peerconnection:setlocaldescriptionfailed": "peerconnection:setlocaldescriptionfailed";
+  readonly "peerconnection:setremotedescriptionfailed": "peerconnection:setremotedescriptionfailed";
+  readonly missed: "missed";
+};
+type JsSIPEventName = UAEventName | SessionEventName;
+
+type UAEventPayload<K extends UAEventName> = K extends keyof UAEventMap
+  ? Parameters<UAEventMap[K]>[0]
+  : K extends keyof UAExtraEvents
+  ? UAExtraEvents[K]
+  : never;
+
+type SessionEventPayload<K extends SessionEventName> =
+  K extends keyof RTCSessionEventMap ? Parameters<RTCSessionEventMap[K]>[0] : never;
+
+type JsSIPEventPayload<K extends JsSIPEventName> = K extends UAEventName
+  ? UAEventPayload<K>
+  : K extends SessionEventName
+  ? SessionEventPayload<K>
+  : never;
+
+type JsSIPEventHandler<K extends JsSIPEventName> = (
+  payload?: JsSIPEventPayload<K>
+) => void;
+
+type SipEventHandlers = {
+  [K in JsSIPEventName]?: JsSIPEventHandler<K>;
+};
+
 interface SipEventManager {
-    on: <K extends JsSIPEventName>(event: K, handler: JsSIPEventHandler<K>) => () => void;
-    onSession: <K extends JsSIPEventName>(sessionId: string, event: K, handler: JsSIPEventHandler<K>) => () => void;
-    bind: (handlers: SipEventHandlers) => () => void;
-    bindSession: (sessionId: string, handlers: SipEventHandlers) => () => void;
+  onUA: <K extends UAEventName>(
+    event: K,
+    handler: (payload?: UAEventPayload<K>) => void
+  ) => () => void;
+  onSession: <K extends SessionEventName>(
+    sessionId: string,
+    event: K,
+    handler: (payload?: SessionEventPayload<K>) => void
+  ) => () => void;
 }
-type JsSIPEventMap = {
-    [K in JsSIPEventName]: JsSIPEventPayload<K>;
-};
-
-type DTFMOptions = DTFMOptions$1;
-
-type SipConfiguration = Omit<UAConfiguration, "password" | "uri"> & {
-    /**
-     * Enable JsSIP debug logging. If string, treated as debug pattern.
-     */
-    debug?: boolean | string;
-    /**
-     * Maximum allowed concurrent sessions. Additional sessions are rejected.
-     */
-    maxSessionCount?: number;
-    /**
-     * Milliseconds to keep enqueued outgoing media before dropping. Defaults to 30000.
-     */
-    pendingMediaTtlMs?: number;
+
+type JsSIPEventMap = {
+  [K in JsSIPEventName]: JsSIPEventPayload<K>;
+};
+
+type SipConfiguration = Omit<UAConfiguration, "password" | "uri"> & {
+  /**
+   * Enable JsSIP debug logging. If string, treated as debug pattern.
+   */
+  debug?: boolean | string;
+  /**
+   * Maximum allowed concurrent sessions. Additional sessions are rejected.
+   */
+  maxSessionCount?: number;
+  /**
+   * Milliseconds to keep enqueued outgoing media before dropping. Defaults to 30000.
+   */
+  pendingMediaTtlMs?: number;
 };
 
 type StartOpts = {
@@ -274,19 +593,19 @@ declare const SipContext: react.Context<SipContextType | null>;
 declare function useSipState(): SipState;
 
 declare function useSipActions(): {
-    call: (target: string, callOptions?: jssip_lib_UA.CallOptions | undefined) => void;
-    answer: (sessionId: string, options?: jssip_lib_RTCSession.AnswerOptions | undefined) => boolean;
-    hangup: (sessionId: string, options?: jssip_lib_RTCSession.TerminateOptions | undefined) => boolean;
+    call: (target: string, callOptions?: CallOptions | undefined) => void;
+    answer: (sessionId: string, options?: AnswerOptions | undefined) => boolean;
+    hangup: (sessionId: string, options?: TerminateOptions | undefined) => boolean;
     toggleMute: (sessionId?: string | undefined) => boolean;
     toggleHold: (sessionId?: string | undefined) => boolean;
-    sendDTMF: (sessionId: string, tones: string | number, options?: jssip_lib_RTCSession.DTFMOptions | undefined) => boolean;
-    transfer: (sessionId: string, target: string | jssip_lib_RTCSession.RTCSession, options?: jssip_lib_RTCSession.ReferOptions | undefined) => boolean;
-    attendedTransfer: (sessionId: string, otherSession: jssip_lib_RTCSession.RTCSession) => boolean;
-    getSession: (sessionId: string) => jssip_lib_RTCSession.RTCSession | null;
+    sendDTMF: (sessionId: string, tones: string | number, options?: DTFMOptions | undefined) => boolean;
+    transfer: (sessionId: string, target: string | RTCSession, options?: ReferOptions | undefined) => boolean;
+    attendedTransfer: (sessionId: string, otherSession: RTCSession) => boolean;
+    getSession: (sessionId: string) => RTCSession | null;
     getSessionIds: () => string[];
     getSessions: () => {
         id: string;
-        session: jssip_lib_RTCSession.RTCSession;
+        session: RTCSession;
     }[];
     setSessionMedia: (sessionId: string, stream: MediaStream) => void;
     switchCamera: (sessionId: string, track: MediaStreamTrack) => false | Promise<boolean>;
@@ -298,9 +617,8 @@ declare function useSip(): SipContextType;
 
 declare function useSipSessions(): Pick<SipState, "sessions">;
 
-type EventName = keyof JsSIPEventMap;
-declare function useSipEvent<K extends EventName>(event: K, handler?: (payload?: JsSIPEventMap[K]) => void): void;
-declare function useSipSessionEvent<K extends EventName>(sessionId: string | null | undefined, event: K, handler?: (payload?: JsSIPEventMap[K]) => void): void;
+declare function useSipEvent<K extends UAEventName>(event: K, handler?: (payload?: UAEventPayload<K>) => void): void;
+declare function useSipSessionEvent<K extends SessionEventName>(sessionId: string | null | undefined, event: K, handler?: (payload?: SessionEventPayload<K>) => void): void;
 
 declare function CallPlayer({ sessionId }: {
     sessionId?: string;
@@ -312,4 +630,4 @@ declare function SipProvider({ client, children, sipEventManager, }: {
     children: react__default.ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
-export { CallDirection, CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, type DTFMOptions, type JsSIPEventMap, JsSIPEventName, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };
+export { type AnswerOptions, CallDirection, CallDirection as CallDirectionType, type CallOptions, CallPlayer, CallStatus, CallStatus as CallStatusType, type DTFMOptions, type JsSIPEventMap, JsSIPEventName, type RTCSession, type RTCSessionEvent, type RTCSessionEventMap, type ReferOptions, type SessionEventName, type SessionEventPayload, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type TerminateOptions, type UAEventMap, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };

package/dist/index.js

@@ -1041,19 +1041,12 @@ var SipClient = class extends EventTargetEmitter {
     });
   }
   cleanupSession(sessionId, session) {
-    const existingSession = this.sessionManager.getSession(sessionId);
-    this.emit("sessionCleanup", { sessionId, session: existingSession });
     const targetSession = session ?? this.sessionManager.getSession(sessionId) ?? this.sessionManager.getRtc(sessionId)?.currentSession;
     this.detachSessionHandlers(sessionId, targetSession);
     this.sessionManager.cleanupSession(sessionId);
     removeSessionState(this.stateStore, sessionId);
   }
   cleanupAllSessions() {
-    const ids = this.sessionManager.getSessionIds();
-    ids.forEach((id) => {
-      const s = this.sessionManager.getSession(id);
-      this.emit("sessionCleanup", { sessionId: id, session: s });
-    });
     this.sessionManager.cleanupAllSessions();
     this.sessionHandlers.clear();
     this.stateStore.setState({
@@ -1285,71 +1278,17 @@ function createSipClientInstance(options) {
   return new SipClient(options);
 }
 function createSipEventManager(client) {
-  const sessionEventNames = /* @__PURE__ */ new Set([
-    "peerconnection",
-    "connecting",
-    "sending",
-    "progress",
-    "accepted",
-    "confirmed",
-    "ended",
-    "failed",
-    "newDTMF",
-    "newInfo",
-    "hold",
-    "unhold",
-    "muted",
-    "unmuted",
-    "reinvite",
-    "update",
-    "refer",
-    "replaces",
-    "sdp",
-    "icecandidate",
-    "getusermediafailed",
-    "peerconnection:createofferfailed",
-    "peerconnection:createanswerfailed",
-    "peerconnection:setlocaldescriptionfailed",
-    "peerconnection:setremotedescriptionfailed"
-  ]);
   return {
-    on(event, handler) {
+    onUA(event, handler) {
       return client.on(event, handler);
     },
     onSession(sessionId, event, handler) {
-      if (sessionEventNames.has(String(event))) {
-        const session = client.getSession(sessionId);
-        if (session) {
-          session.on(event, handler);
-          return () => session.off(event, handler);
-        }
-      }
-      return client.on(event, (payload) => {
-        const id = payload?.session?.id ?? payload?.sessionId ?? payload?.data?.session?.id ?? payload?.data?.id;
-        if (id && String(id) === sessionId) {
-          handler(payload);
-        }
-      });
-    },
-    bind(handlers) {
-      const offs = [];
-      Object.keys(handlers).forEach((event) => {
-        const handler = handlers[event];
-        if (handler) {
-          offs.push(client.on(event, handler));
-        }
-      });
-      return () => offs.forEach((off) => off());
-    },
-    bindSession(sessionId, handlers) {
-      const offs = [];
-      Object.keys(handlers).forEach((event) => {
-        const handler = handlers[event];
-        if (handler) {
-          offs.push(this.onSession(sessionId, event, handler));
-        }
-      });
-      return () => offs.forEach((off) => off());
+      const session = client.getSession(sessionId);
+      if (!session)
+        return () => {
+        };
+      session.on(event, handler);
+      return () => session.off(event, handler);
     }
   };
 }
@@ -1405,7 +1344,7 @@ function useSipEvent(event, handler) {
   useEffect(() => {
     if (!handler)
       return;
-    return sipEventManager.on(event, handler);
+    return sipEventManager.onUA(event, handler);
   }, [event, handler, sipEventManager]);
 }
 function useSipSessionEvent(sessionId, event, handler) {