react-jssip-kit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,318 @@
+import { UA } from 'jssip';
+export { WebSocketInterface } from 'jssip';
+import * as jssip_lib_UA from 'jssip/lib/UA';
+import { UAEventMap, IncomingRTCSessionEvent, UAConfiguration, CallOptions, RTCSessionEvent } 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';
+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;
+    };
+};
+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 UAEventMap | keyof RTCSessionEventMap | keyof ExtraEvents | "sessionCleanup";
+type JsSIPEventPayload<K extends JsSIPEventName> = 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 SipEventManager {
+    bind: (handlers: SipEventHandlers) => () => 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 StartOpts = {
+    debug?: boolean | string;
+};
+declare class SipUserAgent {
+    private _ua;
+    get ua(): UA | null;
+    get isStarted(): boolean;
+    get isRegistered(): boolean;
+    start(uri: string, password: string, config: Omit<SipConfiguration, "debug">, opts?: StartOpts): UA;
+    register(): void;
+    stop(): void;
+    getUA(): UA | null;
+    setDebug(debug?: boolean | string): void;
+    protected buildUAConfig(config: Omit<SipConfiguration, "debug">, uri: string, password: string): UAConfiguration;
+    protected ensureValid(cfg: UAConfiguration): void;
+    protected applyDebug(debug?: boolean | string): void;
+    protected createUA(cfg: UAConfiguration): UA;
+}
+
+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];
+declare const CallDirection: {
+    readonly Incoming: "incoming";
+    readonly Outgoing: "outgoing";
+    readonly None: "none";
+};
+type CallDirection = typeof CallDirection[keyof typeof CallDirection];
+type SipSessionState = {
+    id: string;
+    status: CallStatus;
+    direction: CallDirection;
+    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;
+    on<K extends keyof Events>(event: K, fn: Listener<Events[K]>): () => void;
+    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;
+    private lastState;
+    private listeners;
+    private pendingState;
+    private updateScheduled;
+    getState(): SipState;
+    onChange(fn: SipStateListener): () => void;
+    subscribe(fn: SipStateListener): () => void;
+    setState(partial: Partial<SipState>): void;
+    batchSet(partial: Partial<SipState>): void;
+    reset(overrides?: Partial<SipState>): void;
+    private emit;
+}
+
+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 debugPattern?;
+    private sessionManager;
+    private lifecycle;
+    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(options?: AnswerOptions): void;
+    hangup(options?: TerminateOptions): void;
+    mute(): void;
+    unmute(): void;
+    hold(): void;
+    unhold(): void;
+    sendDTMF(tones: string | number, options?: DTFMOptions): void;
+    transfer(target: string | RTCSession, options?: ReferOptions): void;
+    attendedTransfer(otherSession: RTCSession): void;
+    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;
+    answerSession(sessionIdOrOptions?: string | AnswerOptions, options?: AnswerOptions): boolean;
+    hangupSession(sessionIdOrOptions?: string | TerminateOptions, options?: TerminateOptions): boolean;
+    muteSession(sessionId?: string): boolean;
+    unmuteSession(sessionId?: string): boolean;
+    holdSession(sessionId?: string): boolean;
+    unholdSession(sessionId?: string): boolean;
+    sendDTMFSession(tones: string | number, options?: DTFMOptions, sessionId?: string): boolean;
+    transferSession(target: string | RTCSession, options?: ReferOptions, sessionId?: string): boolean;
+    attendedTransferSession(otherSession: RTCSession, sessionId?: string): boolean;
+    setSessionMedia(sessionId: string, stream: MediaStream): void;
+    switchCameraSession(sessionId: string, track: MediaStreamTrack): boolean;
+    startScreenShareSession(sessionId: string, getDisplayMedia: () => Promise<MediaStream>): Promise<boolean>;
+    enableVideoSession(sessionId: string): boolean;
+    disableVideoSession(sessionId: string): boolean;
+    getSession(sessionId: string): RTCSession | null;
+    getSessionIds(): string[];
+    getSessions(): {
+        id: string;
+        session: RTCSession;
+    }[];
+}
+declare function createSipClientInstance(options?: SipClientOptions): SipClient;
+declare function createSipEventManager(client: SipClient): SipEventManager;
+
+type SipContextType = {
+    client: SipClient;
+    sipEventManager: SipEventManager;
+};
+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: (sessionIdOrOptions?: string | jssip_lib_RTCSession.AnswerOptions | undefined, options?: jssip_lib_RTCSession.AnswerOptions | undefined) => boolean;
+    hangup: (sessionIdOrOptions?: string | jssip_lib_RTCSession.TerminateOptions | undefined, options?: jssip_lib_RTCSession.TerminateOptions | undefined) => boolean;
+    mute: (sessionId?: string | undefined) => boolean;
+    unmute: (sessionId?: string | undefined) => boolean;
+    hold: (sessionId?: string | undefined) => boolean;
+    unhold: (sessionId?: string | undefined) => boolean;
+    sendDTMF: (tones: string | number, options?: jssip_lib_RTCSession.DTFMOptions | undefined, sessionId?: string | undefined) => boolean;
+    transfer: (target: string | jssip_lib_RTCSession.RTCSession, options?: jssip_lib_RTCSession.ReferOptions | undefined, sessionId?: string | undefined) => boolean;
+    attendedTransfer: (otherSession: jssip_lib_RTCSession.RTCSession, sessionId?: string | undefined) => boolean;
+    getSession: (sessionId: string) => jssip_lib_RTCSession.RTCSession | null;
+    getSessionIds: () => string[];
+    getSessions: () => {
+        id: string;
+        session: jssip_lib_RTCSession.RTCSession;
+    }[];
+    setSessionMedia: (sessionId: string, stream: MediaStream) => void;
+    switchCamera: (sessionId: string, track: MediaStreamTrack) => false | Promise<boolean>;
+    startScreenShare: (sessionId: string, getDisplayMedia: () => Promise<MediaStream>) => false | Promise<boolean>;
+    enableVideo: (sessionId: string) => boolean;
+    disableVideo: (sessionId: string) => boolean;
+};
+
+declare function useSip(): SipContextType;
+
+declare function useSipSessions(): Pick<SipState, "sessions">;
+
+type EventName = JsSIPEventName | "sessionCleanup";
+declare function useSipEvent<K extends EventName>(event: K, handler?: JsSIPEventHandler<K>): void;
+declare function useSipSessionEvent<K extends EventName>(sessionId: string | null | undefined, event: K, handler?: JsSIPEventHandler<K>): void;
+
+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;
+
+export { CallDirection, CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, SipContext, type SipContextType, SipProvider, type SipState, SipStatus, SipStatus as SipStatusType, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };