react-jssip-kit 0.7.8 → 1.0.0

package/dist/index.d.cts

@@ -1,22 +1,50 @@
+import { UA } from 'jssip';
+export { WebSocketInterface } from 'jssip';
 import * as jssip_src_RTCSession from 'jssip/src/RTCSession';
-import { RTCSessionEventMap, Originator, AnswerOptions, TerminateOptions, DTMFOptions, ReferOptions, RTCSession } from 'jssip/src/RTCSession';
+import { RTCSessionEventMap, TerminateOptions, AnswerOptions, DTMFOptions, ReferOptions, RTCSession } from 'jssip/src/RTCSession';
 export { AnswerOptions, DTMFOptions, RTCSession, RTCSessionEventMap, ReferOptions, TerminateOptions } from 'jssip/src/RTCSession';
 import * as jssip_src_UA from 'jssip/src/UA';
 import { UAEventMap, IncomingRTCSessionEvent, UAConfiguration, CallOptions, RTCSessionEvent } from 'jssip/src/UA';
 export { CallOptions } from 'jssip/src/UA';
-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';
+import React from 'react';
+
+declare const SipStatus: {
+    readonly Disconnected: "disconnected";
+    readonly Connecting: "connecting";
+    readonly Connected: "connected";
+    readonly Registered: "registered";
+    readonly Unregistered: "unregistered";
+    readonly RegistrationFailed: "registrationFailed";
+};
+type SipStatus = (typeof SipStatus)[keyof typeof SipStatus];
+declare const CallStatus: {
+    readonly Idle: "idle";
+    readonly Dialing: "dialing";
+    readonly Ringing: "ringing";
+    readonly Active: "active";
+    readonly Hold: "hold";
+};
+type CallStatus = (typeof CallStatus)[keyof typeof CallStatus];
+type CallDirection = "local" | "remote";
+type SipSessionState = {
+    id: string;
+    status: CallStatus;
+    direction: CallDirection | null;
+    from: string | null;
+    to: string | null;
+    muted: boolean;
+    acceptedAt: number | null;
+};
+interface SipState {
+    sipStatus: SipStatus;
+    error: string | null;
+    sessions: SipSessionState[];
+    sessionsById: Record<string, SipSessionState>;
+    sessionIds: string[];
+}
 
 type UAExtraEvents = {
-    error: {
-        cause: string;
-        code?: string;
-        raw?: any;
-        message?: string;
-    };
     missed: IncomingRTCSessionEvent;
 };
 type UAEventName = keyof UAEventMap | keyof UAExtraEvents;
@@ -37,26 +65,12 @@ 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;
-    /**
-     * Enable automatic microphone recovery for sessions.
-     */
     enableMicRecovery?: boolean;
-    /**
-     * Interval between recovery attempts in milliseconds.
-     */
     micRecoveryIntervalMs?: number;
-    /**
-     * Maximum number of recovery attempts per session.
-     */
     micRecoveryMaxRetries?: number;
-    /**
-     * Maximum allowed concurrent sessions. Additional sessions are rejected.
-     */
     maxSessionCount?: number;
+    iceCandidateReadyDelayMs?: number;
 };
 
 type StartOpts = {
@@ -81,41 +95,6 @@ declare class SipUserAgent {
     private clearSessionFlag;
 }
 
-declare const SipStatus: {
-    readonly Disconnected: "disconnected";
-    readonly Connecting: "connecting";
-    readonly Connected: "connected";
-    readonly Registered: "registered";
-    readonly Unregistered: "unregistered";
-    readonly RegistrationFailed: "registrationFailed";
-};
-type SipStatus = (typeof SipStatus)[keyof typeof SipStatus];
-declare const CallStatus: {
-    readonly Idle: "idle";
-    readonly Dialing: "dialing";
-    readonly Ringing: "ringing";
-    readonly Active: "active";
-    readonly Hold: "hold";
-};
-type CallStatus = (typeof CallStatus)[keyof typeof CallStatus];
-type CallDirection = Originator.LOCAL | Originator.REMOTE;
-type SipSessionState = {
-    id: string;
-    status: CallStatus;
-    direction: CallDirection | null;
-    from: string | null;
-    to: string | null;
-    muted: boolean;
-    acceptedAt: number | null;
-    mediaKind: "audio" | "video";
-    remoteVideoEnabled: boolean;
-};
-interface SipState {
-    sipStatus: SipStatus;
-    error: string | null;
-    sessions: SipSessionState[];
-}
-
 type Listener<T = any> = (payload: T) => void;
 declare class EventTargetEmitter<Events extends Record<string, any> = any> {
     private target;
@@ -123,30 +102,6 @@ declare class EventTargetEmitter<Events extends Record<string, any> = any> {
     emit<K extends keyof Events>(event: K, payload?: Events[K]): void;
 }
 
-interface SipErrorPayload {
-    cause: string;
-    code?: string;
-    raw?: any;
-    message?: string;
-}
-interface SipErrorFormatInput {
-    raw: any;
-    code?: string;
-    fallback?: string;
-}
-type SipErrorFormatter = (input: SipErrorFormatInput) => SipErrorPayload | undefined;
-type SipErrorHandlerOptions = {
-    formatter?: SipErrorFormatter;
-    messages?: Record<string, string>;
-};
-declare class SipErrorHandler {
-    private readonly formatter?;
-    private readonly messages?;
-    constructor(options?: SipErrorHandlerOptions);
-    format(input: SipErrorFormatInput): SipErrorPayload;
-    private readRawMessage;
-}
-
 type SipStateListener = (state: SipState) => void;
 declare class SipStateStore {
     private state;
@@ -163,55 +118,34 @@ declare class SipStateStore {
     private emit;
 }
 
+declare function createSipEventManager(client: SipClient): SipEventManager;
+
 type SipClientOptions = {
-    errorMessages?: Record<string, string>;
-    formatError?: SipErrorFormatter;
-    errorHandler?: SipErrorHandler;
     debug?: boolean | string;
 };
 declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     readonly userAgent: SipUserAgent;
     readonly stateStore: SipStateStore;
-    private readonly uaHandlers;
-    private readonly uaHandlerKeys;
-    private sessionHandlers;
-    private readonly errorHandler;
+    private readonly uaModule;
     private debugPattern?;
     private maxSessionCount;
+    private iceCandidateReadyDelayMs?;
     private sessionManager;
-    private lifecycle;
+    private sessionModule;
     private micRecovery;
-    private unloadHandler?;
-    private stateLogOff?;
+    private unloadRuntime;
+    private debugRuntime;
     get state(): SipState;
     constructor(options?: SipClientOptions);
     connect(uri: string, password: string, config: SipConfiguration): void;
     registerUA(): void;
     disconnect(): void;
     call(target: string, callOptions?: CallOptions): void;
-    answer(sessionId: string, options?: AnswerOptions): boolean;
-    hangup(sessionId: string, options?: TerminateOptions): boolean;
     hangupAll(options?: TerminateOptions): boolean;
-    toggleMute(sessionId: string): boolean;
-    toggleHold(sessionId: string): boolean;
-    sendDTMF(sessionId: string, tones: string | number, options?: DTMFOptions): boolean;
-    transfer(sessionId: string, target: string, options?: ReferOptions): boolean;
     onChange(fn: (s: SipState) => void): () => void;
-    private attachUAHandlers;
     setDebug(debug?: boolean | string): void;
-    private attachSessionHandlers;
-    private detachSessionHandlers;
-    private detachUAHandlers;
-    private cleanupSession;
     private cleanupAllSessions;
-    private createSessionHandlersFor;
     protected onNewRTCSession(e: RTCSessionEvent): void;
-    protected onSessionFailed(error?: string, event?: RTCSessionEvent): void;
-    private emitError;
-    private resolveSessionId;
-    private sessionExists;
-    private resolveExistingSessionId;
-    private ensureMediaConstraints;
     answerSession(sessionId: string, options?: AnswerOptions): boolean;
     hangupSession(sessionId: string, options?: TerminateOptions): boolean;
     toggleMuteSession(sessionId?: string): boolean;
@@ -219,41 +153,77 @@ declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     sendDTMFSession(sessionId: string, tones: string | number, options?: DTMFOptions): boolean;
     transferSession(sessionId: string, target: string, options?: ReferOptions): boolean;
     setSessionMedia(sessionId: string, stream: MediaStream): void;
-    switchCameraSession(sessionId: string, track: MediaStreamTrack): false | Promise<boolean>;
-    enableVideoSession(sessionId: string): boolean;
-    disableVideoSession(sessionId: string): boolean;
     getSession(sessionId: string): RTCSession | null;
     getSessionIds(): string[];
     getSessions(): {
         id: string;
         session: RTCSession;
     }[];
-    private attachBeforeUnload;
-    private detachBeforeUnload;
-    private syncDebugInspector;
-    private toggleStateLogger;
-    private getPersistedDebug;
-    private requestMicrophoneStreamInternal;
 }
 declare function createSipClientInstance(options?: SipClientOptions): SipClient;
-declare function createSipEventManager(client: SipClient): SipEventManager;
 
-type SipContextType = {
-    client: SipClient;
-    sipEventManager: SipEventManager;
+type SessionMediaState = {
+    sessionId: string;
+    session: RTCSession | null;
+    peerConnection: RTCPeerConnection | null;
+    remoteStream: MediaStream | null;
+    audioTracks: MediaStreamTrack[];
 };
-declare const SipContext: react.Context<SipContextType | null>;
+interface MediaModule {
+    getSession(sessionId: string): RTCSession | null;
+    observePeerConnection(sessionId: string, onPeerConnection: (peerConnection: RTCPeerConnection | null) => void): () => void;
+    buildRemoteStream(peerConnection: RTCPeerConnection | null): MediaStream | null;
+}
+
+interface SipKernel {
+    client: SipClient;
+    store: {
+        getState: () => SipState;
+        subscribe: (onStoreChange: () => void) => () => void;
+    };
+    commands: {
+        connect: (uri: string, password: string, config: SipConfiguration) => void;
+        disconnect: () => void;
+        register: () => void;
+        setDebug: (debug?: boolean | string) => void;
+        call: (target: string, options?: CallOptions) => void;
+        answer: (sessionId: string, options?: AnswerOptions) => boolean;
+        hangup: (sessionId: string, options?: TerminateOptions) => boolean;
+        hangupAll: (options?: TerminateOptions) => boolean;
+        toggleMute: (sessionId?: string) => boolean;
+        toggleHold: (sessionId?: string) => boolean;
+        sendDTMF: (sessionId: string, tones: string | number, options?: DTMFOptions) => boolean;
+        transfer: (sessionId: string, target: string, options?: ReferOptions) => boolean;
+        getSession: SipClient["getSession"];
+        getSessionIds: SipClient["getSessionIds"];
+        getSessions: SipClient["getSessions"];
+        setSessionMedia: SipClient["setSessionMedia"];
+    };
+    events: {
+        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;
+    };
+    eventManager: SipEventManager;
+    media: MediaModule;
+}
+
+declare function createSipKernel(): SipKernel;
 
 declare function useSipState(): SipState;
 
 declare function useSipActions(): {
-    call: (target: string, callOptions?: jssip_src_UA.CallOptions | undefined) => void;
-    answer: (sessionId: string, options?: jssip_src_RTCSession.AnswerOptions | undefined) => boolean;
-    hangup: (sessionId: string, options?: jssip_src_RTCSession.TerminateOptions | undefined) => boolean;
-    toggleMute: (sessionId?: string | undefined) => boolean;
-    toggleHold: (sessionId?: string | undefined) => boolean;
-    sendDTMF: (sessionId: string, tones: string | number, options?: jssip_src_RTCSession.DTMFOptions | undefined) => boolean;
-    transfer: (sessionId: string, target: string, options?: jssip_src_RTCSession.ReferOptions | undefined) => boolean;
+    connect: (uri: string, password: string, config: SipConfiguration) => void;
+    disconnect: () => void;
+    register: () => void;
+    setDebug: (debug?: boolean | string) => void;
+    call: (target: string, options?: jssip_src_UA.CallOptions) => void;
+    answer: (sessionId: string, options?: jssip_src_RTCSession.AnswerOptions) => boolean;
+    hangup: (sessionId: string, options?: jssip_src_RTCSession.TerminateOptions) => boolean;
+    hangupAll: (options?: jssip_src_RTCSession.TerminateOptions) => boolean;
+    toggleMute: (sessionId?: string) => boolean;
+    toggleHold: (sessionId?: string) => boolean;
+    sendDTMF: (sessionId: string, tones: string | number, options?: jssip_src_RTCSession.DTMFOptions) => boolean;
+    transfer: (sessionId: string, target: string, options?: jssip_src_RTCSession.ReferOptions) => boolean;
     getSession: (sessionId: string) => jssip_src_RTCSession.RTCSession | null;
     getSessionIds: () => string[];
     getSessions: () => {
@@ -261,26 +231,33 @@ declare function useSipActions(): {
         session: jssip_src_RTCSession.RTCSession;
     }[];
     setSessionMedia: (sessionId: string, stream: MediaStream) => void;
-    switchCamera: (sessionId: string, track: MediaStreamTrack) => false | Promise<boolean>;
-    enableVideo: (sessionId: string) => boolean;
-    disableVideo: (sessionId: string) => boolean;
 };
 
-declare function useSip(): SipContextType;
+declare function useSipKernel(): SipKernel;
+
+type SipSelector<TSelected> = (state: SipState) => TSelected;
+type SipSelectorEqualityFn<TSelected> = (prev: TSelected, next: TSelected) => boolean;
+declare function useSipSelector<TSelected>(selector: SipSelector<TSelected>, equalityFn?: SipSelectorEqualityFn<TSelected>): TSelected;
+
+declare function useActiveSipSession(): SipSessionState | null;
+
+declare function useSipSession(sessionId?: string): SipSessionState | null;
 
 declare function useSipSessions(): Pick<SipState, "sessions">;
 
 declare function useSipEvent<K extends UAEventName>(event: K, handler?: (payload?: UAEventPayload<K>) => void): void;
 declare function useSipSessionEvent<K extends SessionEventName>(sessionId: string, event: K, handler?: (payload?: SessionEventPayload<K>) => void): void;
 
+declare function useSessionMedia(sessionId?: string): SessionMediaState;
+
 declare function CallPlayer({ sessionId }: {
     sessionId?: string;
 }): react_jsx_runtime.JSX.Element;
 
-declare function SipProvider({ client, children, sipEventManager, }: {
-    sipEventManager?: SipEventManager;
-    client: SipClient;
-    children: react__default.ReactNode;
-}): react_jsx_runtime.JSX.Element;
+type SipProviderProps = {
+    kernel: SipKernel;
+    children: React.ReactNode;
+};
+declare function SipProvider(props: SipProviderProps): react_jsx_runtime.JSX.Element;
 
-export { type CallDirection, type CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, type JsSIPEventMap, type JsSIPEventName, type SessionEventName, type SessionEventPayload, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };
+export { type CallDirection, type CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, type JsSIPEventMap, type JsSIPEventName, type SessionEventName, type SessionEventPayload, type SipConfiguration, type SipEventHandlers, type SipEventManager, type SipKernel, SipProvider, type SipProviderProps, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, createSipKernel, useActiveSipSession, useSessionMedia, useSipActions, useSipEvent, useSipKernel, useSipSelector, useSipSession, useSipSessionEvent, useSipSessions, useSipState };