sip-connector 14.0.0 → 14.1.0-alpha.0

package/dist/{__fixtures__ → src/__fixtures__}/BaseSession.mock.d.ts

@@ -1,36 +1,32 @@
 import { AnswerOptions, ExtraHeaders, HoldOptions, MediaStreamTypes, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
 import { default as Events } from 'events-constructor';
 import { TEventSession, SESSION_EVENT_NAMES } from '../eventNames';
-/**
- * BaseSession
- * @class
- */
+export type TEventHandlers = Record<string, (data: unknown) => void>;
 declare class BaseSession implements RTCSession {
     originator: string;
-    _connection: RTCPeerConnectionDeprecated;
-    _events: Events<typeof SESSION_EVENT_NAMES>;
-    _remote_identity: NameAddrHeader;
-    _mutedOptions: {
+    connection: RTCPeerConnectionDeprecated;
+    events: Events<typeof SESSION_EVENT_NAMES>;
+    remote_identity: NameAddrHeader;
+    mutedOptions: {
         audio: boolean;
         video: boolean;
     };
-    constructor({ originator, eventHandlers }: {
-        originator?: string | undefined;
-        eventHandlers: any;
+    constructor({ originator, eventHandlers, remoteIdentity, }: {
+        originator?: string;
+        eventHandlers: TEventHandlers;
+        remoteIdentity: NameAddrHeader;
     });
-    get C(): SessionStatus;
-    get causes(): constants.causes;
-    get id(): string;
-    set data(_data: any);
-    get data(): any;
-    get connection(): RTCPeerConnectionDeprecated;
     get contact(): string;
     get direction(): SessionDirection;
     get local_identity(): NameAddrHeader;
-    get remote_identity(): NameAddrHeader;
     get start_time(): Date;
     get end_time(): Date;
     get status(): SessionStatus;
+    get C(): SessionStatus;
+    get causes(): constants.causes;
+    get id(): string;
+    get data(): unknown;
+    set data(_data: unknown);
     isInProgress(): boolean;
     isEnded(): boolean;
     isReadyToReOffer(): boolean;
@@ -50,30 +46,23 @@ declare class BaseSession implements RTCSession {
         deleteExisting: boolean;
         addMissing: boolean;
     }): Promise<void>;
-    addListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    once(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    removeListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    off(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    addListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    once(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    removeListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    off(eventName: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeAllListeners(_event?: string | symbol): this;
     setMaxListeners(_n: number): this;
     getMaxListeners(): number;
     listeners(_event: string | symbol): (() => void)[];
     rawListeners(_event: string | symbol): (() => void)[];
-    emit(_event: string | symbol, ..._arguments_: any[]): boolean;
+    emit(_event: string | symbol, ..._arguments_: unknown[]): boolean;
     listenerCount(_event: string | symbol): number;
-    prependListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    prependOnceListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    prependListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    prependOnceListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     eventNames(): (string | symbol)[];
-    /**
-     * initEvents
-     *
-     * @param {Array} [eventHandlers=[] - ]  The event handlers
-     *
-     * @returns {undefined}
-     */
-    initEvents(eventHandlers?: never[]): void;
+    initEvents(eventHandlers?: TEventHandlers): void;
     on<T>(eventName: string, handler: (data: T) => void): this;
-    trigger(eventName: TEventSession, data?: any): void;
+    trigger(eventName: TEventSession, data?: unknown): void;
     /**
      * sendDTMF
      *
@@ -83,7 +72,6 @@ declare class BaseSession implements RTCSession {
      */
     sendDTMF(): void;
     startPresentation(stream: MediaStream): Promise<MediaStream>;
-    updatePresentation(stream: MediaStream): Promise<MediaStream>;
     stopPresentation(stream: MediaStream): Promise<MediaStream>;
     isEstablished(): boolean;
 }

package/dist/{__fixtures__ → src/__fixtures__}/RTCPeerConnectionMock.d.ts

@@ -2,9 +2,8 @@ import { RTCPeerConnectionDeprecated } from '@krivega/jssip';
 import { MediaStreamTrackMock } from 'webrtc-mock';
 import { default as RTCRtpSenderMock } from './RTCRtpSenderMock';
 declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
-    _senders: RTCRtpSender[];
-    _receivers: any[];
-    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
+    senders: RTCRtpSender[];
+    receivers: RTCRtpReceiver[];
     canTrickleIceCandidates: boolean | null;
     connectionState: RTCPeerConnectionState;
     currentLocalDescription: RTCSessionDescription | null;
@@ -14,21 +13,22 @@ declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     idpErrorInfo: string | null;
     idpLoginUrl: string | null;
     localDescription: RTCSessionDescription | null;
-    onconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    ondatachannel: ((this: RTCPeerConnection, event_: RTCDataChannelEvent) => any) | null;
-    onicecandidate: ((this: RTCPeerConnection, event_: RTCPeerConnectionIceEvent) => any) | null;
-    onicecandidateerror: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    oniceconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onicegatheringstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onnegotiationneeded: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onsignalingstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    ontrack: ((this: RTCPeerConnection, event_: RTCTrackEvent) => any) | null;
+    onconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    ondatachannel: ((this: RTCPeerConnection, event_: RTCDataChannelEvent) => unknown) | null;
+    onicecandidate: ((this: RTCPeerConnection, event_: RTCPeerConnectionIceEvent) => unknown) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    ontrack: ((this: RTCPeerConnection, event_: RTCTrackEvent) => unknown) | null;
     peerIdentity: undefined;
     pendingLocalDescription: RTCSessionDescription | null;
     pendingRemoteDescription: RTCSessionDescription | null;
     remoteDescription: RTCSessionDescription | null;
     sctp: null;
     signalingState: RTCSignalingState;
+    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
     getRemoteStreams(): MediaStream[];
     addIceCandidate(_candidate: RTCIceCandidate | RTCIceCandidateInit): Promise<void>;
     addTransceiver(_trackOrKind: MediaStreamTrack | string, _init?: RTCRtpTransceiverInit): RTCRtpTransceiver;
@@ -47,12 +47,12 @@ declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     setConfiguration(_configuration: RTCConfiguration): void;
     setLocalDescription(_description: RTCSessionDescriptionInit): Promise<void>;
     setRemoteDescription(_description: RTCSessionDescriptionInit): Promise<void>;
-    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: AddEventListenerOptions | boolean): void;
+    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: EventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => unknown, options?: EventListenerOptions | boolean): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
     dispatchEvent(_event: Event): boolean;
-    getReceivers: () => any[];
+    getReceivers: () => RTCRtpReceiver[];
     getSenders: () => RTCRtpSender[];
     addTrack: (track: MediaStreamTrack) => RTCRtpSenderMock;
 }

package/dist/{__fixtures__ → src/__fixtures__}/RTCRtpSenderMock.d.ts

@@ -3,8 +3,8 @@ declare class RTCRtpSenderMock implements RTCRtpSender {
     track: MediaStreamTrack | null;
     transport: RTCDtlsTransport | null;
     transform: RTCRtpTransform | null;
-    private _parameters;
-    private _parametersGets?;
+    private parameters;
+    private parametersGets?;
     constructor({ track }?: {
         track?: MediaStreamTrack;
     });

package/dist/src/__fixtures__/RTCSessionMock.d.ts

@@ -0,0 +1,79 @@
+import { IncomingInfoEvent, NameAddrHeader } from '@krivega/jssip';
+import { TEventHandlers, default as BaseSession } from './BaseSession.mock';
+export declare const FAILED_CONFERENCE_NUMBER = "777";
+export declare const createDeclineStartPresentationError: () => Error;
+declare class RTCSessionMock extends BaseSession {
+    private static presentationError?;
+    private static startPresentationError?;
+    private static countStartPresentationError;
+    private static countStartsPresentation;
+    url: string;
+    status_code?: number;
+    /**
+       * answer
+       *
+       * @param {Object} arg1               - The argument 1
+       * @param {Object} arg1.mediaStream   - The media stream
+       * @param {Array}  arg1.eventHandlers - The event handlers
+  
+   * @returns {undefined}
+       */
+    answer: jest.Mock<void, [{
+        mediaStream: MediaStream;
+    }], any>;
+    replaceMediaStream: jest.Mock<Promise<void>, [_mediaStream: MediaStream], any>;
+    private isEndedInner;
+    constructor({ url, mediaStream, eventHandlers, originator, remoteIdentity, }: {
+        url?: string;
+        mediaStream?: MediaStream;
+        eventHandlers: TEventHandlers;
+        originator: string;
+        remoteIdentity?: NameAddrHeader;
+    });
+    static setPresentationError(presentationError: Error): void;
+    static resetPresentationError(): void;
+    static setStartPresentationError(startPresentationError: Error, { count }?: {
+        count?: number;
+    }): void;
+    static resetStartPresentationError(): void;
+    startPresentation: (stream: MediaStream) => Promise<MediaStream>;
+    stopPresentation: (stream: MediaStream) => Promise<MediaStream>;
+    initPeerconnection(mediaStream: MediaStream | undefined): boolean;
+    createPeerconnection(sendedStream: MediaStream): void;
+    connect(target: string): void;
+    terminate({ status_code, cause }?: {
+        status_code?: number;
+        cause?: string;
+    }): this;
+    terminateAsync({ status_code, cause, }?: {
+        status_code?: number;
+        cause?: string;
+    }): Promise<void>;
+    terminateRemote({ status_code }?: {
+        status_code?: number;
+    }): this;
+    addStream(stream: MediaStream, action?: 'getTracks' | 'getAudioTracks' | 'getVideoTracks'): void;
+    forEachSenders(callback: (sender: RTCRtpSender) => void): RTCRtpSender[];
+    toggleMuteAudio(mute: boolean): void;
+    toggleMuteVideo(mute: boolean): void;
+    mute(options: {
+        audio: boolean;
+        video: boolean;
+    }): void;
+    unmute(options: {
+        audio: boolean;
+        video: boolean;
+    }): void;
+    isMuted(): {
+        audio: boolean;
+        video: boolean;
+    };
+    onmute({ audio, video }: {
+        audio: boolean;
+        video: boolean;
+    }): void;
+    sendInfo(): Promise<void>;
+    isEnded(): boolean;
+    newInfo(data: IncomingInfoEvent): void;
+}
+export default RTCSessionMock;

package/dist/src/__fixtures__/UA.mock.d.ts

@@ -0,0 +1,82 @@
+import { DisconnectEvent, UA as IUA, IncomingRequest, UAConfiguration, UAConfigurationParams, UAEventMap } from '@krivega/jssip';
+import { default as Events } from 'events-constructor';
+import { TEventHandlers } from './BaseSession.mock';
+import { default as Registrator } from './Registrator.mock';
+import { default as RTCSessionMock } from './RTCSessionMock';
+export declare const PASSWORD_CORRECT = "PASSWORD_CORRECT";
+export declare const PASSWORD_CORRECT_2 = "PASSWORD_CORRECT_2";
+export declare const NAME_INCORRECT = "NAME_INCORRECT";
+export declare const createWebsocketHandshakeTimeoutError: (sipServerUrl: string) => DisconnectEvent;
+declare class UA implements IUA {
+    private static isAvailableTelephony;
+    private static startError?;
+    private static countStartError;
+    private static countStarts;
+    events: Events<readonly (keyof UAEventMap)[]>;
+    readonly registratorInner: Registrator;
+    call: jest.Mock<RTCSessionMock, [url: string, parameters: {
+        mediaStream: MediaStream;
+        eventHandlers: TEventHandlers;
+    }], any>;
+    sendOptions: jest.Mock<void, [target: string, body?: string | undefined, options?: Record<string, unknown> | undefined], any>;
+    /**
+     * start – имитирует запуск UA.
+     */
+    start: jest.Mock<void, [], any>;
+    /**
+     * stop – имитирует остановку UA.
+     */
+    stop: jest.Mock<void, [], any>;
+    removeAllListeners: jest.Mock<this, [], any>;
+    once: jest.Mock<this, [eventName: string, handler: () => void], any>;
+    private startedTimeout?;
+    private stopedTimeout?;
+    private session?;
+    private isRegisteredInner?;
+    private isConnectedInner?;
+    private configuration;
+    constructor(_configuration: UAConfigurationParams);
+    static setStartError(startError: DisconnectEvent, { count }?: {
+        count?: number;
+    }): void;
+    static resetStartError(): void;
+    static setAvailableTelephony(): void;
+    static setNotAvailableTelephony(): void;
+    static reset(): void;
+    on<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    off<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    trigger<T extends keyof UAEventMap>(eventName: T, data: Parameters<UAEventMap[T]>[0]): void;
+    /**
+     * terminateSessions
+     *
+     * @returns {undefined}
+     */
+    terminateSessions(): void;
+    set(key: keyof UAConfiguration, value: UAConfiguration[keyof UAConfiguration]): boolean;
+    /**
+     * register
+     *
+     * @returns {undefined}
+     */
+    register(): void;
+    /**
+     * unregister
+     *
+     * @returns {undefined}
+     */
+    unregister(): void;
+    isRegistered(): boolean;
+    isConnected(): boolean;
+    /**
+     * isStarted
+     *
+     * @returns {boolean} isStarted
+     */
+    isStarted(): boolean;
+    newSipEvent(data: {
+        event: unknown;
+        request: IncomingRequest;
+    }): void;
+    registrator(): Registrator;
+}
+export default UA;

package/dist/{__fixtures__ → src/__fixtures__}/channelsNotify.d.ts

@@ -1,5 +1,5 @@
 export declare const channelsHeaders: [string, string][];
 export declare const channelsData: {
-    inputChannels: any;
-    outputChannels: any;
+    inputChannels: string;
+    outputChannels: string;
 };

package/dist/{__fixtures__ → src/__fixtures__}/index.d.ts

@@ -40,7 +40,7 @@ export declare const uaConfigurationWithAuthorization: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -53,7 +53,7 @@ export declare const uaConfigurationWithAuthorizationWithDisplayName: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -64,7 +64,7 @@ export declare const uaConfigurationWithoutAuthorization: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -75,7 +75,7 @@ export declare const uaConfigurationWithoutAuthorizationWithoutDisplayName: {
     session_timers: boolean;
     sockets: import('./WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;

package/dist/{__fixtures__ → src/__fixtures__}/jssip.mock.d.ts

@@ -1,19 +1,19 @@
 import { RTCSession, UA } from '@krivega/jssip';
-import { default as UAmock } from './UA.mock';
+import { default as UAMock } from './UA.mock';
 import { default as WebSocketInterfaceMock } from './WebSocketInterface.mock';
 declare const jssip: {
     triggerNewInfo: (rtcSession: RTCSession, extraHeaders: [string, string][]) => void;
     triggerNewSipEvent: (ua: UA, extraHeaders: [string, string][]) => void;
-    triggerIncomingSession: (ua: UAmock, { incomingNumber, displayName, host, }: {
+    triggerIncomingSession: (ua: UAMock, { incomingNumber, displayName, host, }: {
         incomingNumber?: string;
         displayName: string;
         host: string;
     }) => void;
-    triggerFailIncomingSession: (incomingSession: unknown, options?: {
+    triggerFailIncomingSession: (incomingSession: RTCSession, options?: {
         originator: "local" | "remote";
     }) => void;
     WebSocketInterface: typeof WebSocketInterfaceMock;
-    UA: typeof UAmock;
+    UA: typeof UAMock;
     C: {
         INVITE: string;
     };

package/dist/{__fixtures__ → src/__fixtures__}/participantNotify.d.ts

@@ -1,8 +1,8 @@
 export declare const removedFromListModeratorsHeaders: [string, string][];
 export declare const removedFromListModeratorsData: {
-    conference: any;
+    conference: string;
 };
 export declare const addedToListModeratorsHeaders: [string, string][];
 export declare const addedToListModeratorsData: {
-    conference: any;
+    conference: string;
 };

package/dist/{constants.d.ts → src/constants.d.ts}

@@ -72,3 +72,8 @@ export declare const PRESENTATION_FAILED = "presentation:failed";
 export declare const SPECTATOR = "SPECTATOR";
 export declare const PARTICIPANT = "PARTICIPANT";
 export declare const ONE_MEGABIT_IN_BITS = 1000000;
+export declare enum Originator {
+    LOCAL = "local",
+    REMOTE = "remote",
+    SYSTEM = "system"
+}

package/dist/{doMock.d.ts → src/doMock.d.ts}

@@ -3,3 +3,4 @@ export { FAILED_CONFERENCE_NUMBER } from './__fixtures__/RTCSessionMock';
 export { NAME_INCORRECT, PASSWORD_CORRECT, PASSWORD_CORRECT_2 } from './__fixtures__/UA.mock';
 export * from './__fixtures__/index';
 export declare const doMockSipConnector: () => SipConnector;
+export { default as JsSIP } from './__fixtures__/jssip.mock';

package/dist/{index.d.ts → src/index.d.ts}

@@ -7,5 +7,7 @@ export * as tools from './tools';
 export * from './types';
 export { default as getCodecFromSender } from './utils/getCodecFromSender';
 export { default as resolveVideoSendingBalancer } from './videoSendingBalancer';
-export { hasCanceledCallError, default as SipConnector } from './SipConnector';
+export { hasCanceledCallError } from './CallManager';
+export { hasCanceledStartPresentationError } from './PresentationManager';
+export { default as SipConnector } from './SipConnector';
 export { SipConnectorFacade } from './SipConnectorFacade';

package/dist/{tools → src/tools}/__fixtures__/connectToServer.d.ts

@@ -95,7 +95,7 @@ export declare const uaConfigurationWithAuthorization: {
     session_timers: boolean;
     sockets: import('../../__fixtures__/WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;
@@ -108,7 +108,7 @@ export declare const uaConfigurationWithAuthorizationPasswordChanged: {
     session_timers: boolean;
     sockets: import('../../__fixtures__/WebSocketInterface.mock').default[];
     user_agent: string;
-    sdp_semantics: string;
+    sdpSemantics: string;
     register_expires: number;
     connection_recovery_max_interval: number;
     connection_recovery_min_interval: number;

package/dist/{tools → src/tools}/index.d.ts

@@ -1,6 +1,6 @@
 export * as error from './error';
 export { default as getExtraHeaders } from './getExtraHeaders';
 export { default as getUserAgent } from './getUserAgent';
-export { PURGATORY_CONFERENCE_NUMBER, default as hasPurgatory } from './hasPurgatory';
-export { default as sendDTMFAccumulated } from './sendDTMFAccumulated';
+export { default as hasPurgatory, PURGATORY_CONFERENCE_NUMBER } from './hasPurgatory';
+export { default as sendDtmfAccumulated } from './sendDtmfFAccumulated';
 export { default as createSyncMediaState } from './syncMediaState';

package/dist/{tools/sendDTMFAccumulated.d.ts → src/tools/sendDtmfFAccumulated.d.ts}

@@ -1,9 +1,9 @@
 type TSendKey = (values: string) => Promise<void>;
-declare const sendDTMFAccumulated: ({ accumulatedKeys, sendKey, canRunTask, }: {
+declare const sendDtmfAccumulated: ({ accumulatedKeys, sendKey, canRunTask, }: {
     accumulatedKeys: string;
     sendKey: TSendKey;
     canRunTask?: () => boolean;
 }) => Promise<{
     isSuccessful: boolean;
 }>;
-export default sendDTMFAccumulated;
+export default sendDtmfAccumulated;

package/dist/{types.d.ts → src/types.d.ts}

@@ -1,4 +1,5 @@
 import { UA, WebSocketInterface } from '@krivega/jssip';
+import { Originator } from './constants';
 export declare enum EEventsMainCAM {
     PAUSE_MAIN_CAM = "PAUSEMAINCAM",
     RESUME_MAIN_CAM = "RESUMEMAINCAM",
@@ -20,7 +21,7 @@ export declare enum EUseLicense {
     AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION"
 }
 export type TCustomError = Error & {
-    originator?: string;
+    originator?: Originator;
     cause?: unknown;
     message: unknown;
     _ws?: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-connector",
-  "version": "14.0.0",
+  "version": "14.1.0-alpha.0",
   "description": "Module for connect to Vinteo server",
   "keywords": [
     "webrtc",
@@ -48,7 +48,7 @@
   "scripts": {
     "build": "vite build",
     "lint": "yarn lint:ts && yarn lint:js",
-    "lint:js": "eslint src --ext ts,tsx --ignore-path .gitignore --report-unused-disable-directives --max-warnings 0",
+    "lint:js": "eslint src --ext ts,tsx --report-unused-disable-directives --max-warnings 0 --cache --cache-strategy=content",
     "lint:ts": "tsc",
     "prepare": "husky",
     "prepublishOnly": "yarn build",
@@ -56,69 +56,72 @@
     "release": "standard-version && npm run release:publish",
     "release:major": "standard-version --release-as major && npm run release:publish",
     "release:pre": "standard-version --prerelease && npm run release:publish",
+    "release:alpha": "standard-version --prerelease alpha && npm run release:publish",
     "release:publish": "git push --follow-tags origin master && npm publish --access=public",
-    "test": "jest --watch",
+    "test": "jest",
     "test:ci": "cross-env CI=true jest",
-    "test:coverage": "yarn test:ci --coverage --reporters=default --reporters=jest-junit"
+    "test:coverage": "yarn test:ci --no-cache --coverage",
+    "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@krivega/cancelable-promise": "^1.1.3",
+    "@krivega/cancelable-promise": "^1.1.4",
     "@krivega/jssip": "^5.1.2",
-    "debug": "^4.4.0",
+    "debug": "^4.4.1",
     "events-constructor": "^1.3.0",
-    "repeated-calls": "^2.3.0",
+    "repeated-calls": "^2.3.4",
     "sequent-promises": "^2.0.1",
     "stack-promises": "^2.0.3",
     "ts-debounce": "^4.0.0",
-    "webrtc-mock": "^1.1.6"
+    "webrtc-mock": "^1.1.7",
+    "xstate": "^5.20.1"
   },
   "devDependencies": {
-    "@babel/preset-typescript": "^7.26.0",
-    "@commitlint/cli": "^19.7.1",
-    "@commitlint/config-conventional": "^19.7.1",
+    "@babel/preset-typescript": "^7.27.1",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.1",
     "@nabla/vite-plugin-eslint": "^2.0.5",
+    "@stylistic/eslint-plugin": "^5.2.2",
     "@types/debug": "^4.1.12",
-    "@types/dom-mediacapture-transform": "^0.1.10",
-    "@types/jest": "^29.5.14",
-    "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "@typescript-eslint/parser": "^7.15.0",
+    "@types/dom-mediacapture-transform": "^0.1.11",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
     "cross-env": "^7.0.3",
-    "eslint": "^8.57.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^18.0.0",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint": "^9.31.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-flowtype": "^8.0.3",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^28.11.0",
-    "eslint-plugin-prettier": "^5.2.3",
-    "eslint-plugin-unicorn": "^56.0.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^29.0.1",
+    "eslint-plugin-prettier": "^5.5.3",
+    "eslint-plugin-unicorn": "^60.0.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-extended": "^4.0.2",
+    "jest": "^30.0.5",
+    "jest-environment-jsdom": "^30.0.5",
+    "jest-extended": "^6.0.0",
     "jest-junit": "^16.0.0",
-    "lint-staged": "^15.4.3",
-    "prettier": "^3.5.0",
+    "lint-staged": "^16.1.2",
+    "prettier": "^3.6.2",
     "standard-version": "^9.5.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",
     "tsc-files": "^1.1.4",
-    "typescript": "^5.7.3",
-    "vite": "^6.1.0",
-    "vite-plugin-dts": "^4.5.0",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.5",
+    "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^5.1.4"
   },
   "peerDependencies": {
-    "@krivega/cancelable-promise": "^1.1.3",
+    "@krivega/cancelable-promise": "^1.1.4",
     "@krivega/jssip": "^5.1.2",
-    "debug": "^4.4.0",
+    "debug": "^4.4.1",
     "events-constructor": "^1.3.0",
-    "repeated-calls": "^2.2.1",
+    "repeated-calls": "^2.3.3",
     "sequent-promises": "^2.0.1",
     "stack-promises": "^2.0.3",
     "ts-debounce": "^4.0.0",
-    "webrtc-mock": "^1.0.4"
+    "webrtc-mock": "^1.1.7",
+    "xstate": "^5.20.1"
   },
   "packageManager": "yarn@1.22.22",
   "main:src": "src/index.ts"