sip-connector 29.0.0 → 29.1.0

package/dist/CallManager/types.d.ts

@@ -32,7 +32,7 @@ export type TCustomError = Error & {
     url?: string;
     code?: string;
 };
-export type TCallConfiguration = {
+export type TCallConfig = {
     answer?: boolean;
     number?: string;
 };

package/dist/ConnectionManager/@ConnectionManager.d.ts

@@ -6,7 +6,7 @@ import { TGetUri } from '../CallManager';
 import { TJsSIP } from '../types';
 import { TConnect } from './ConnectionFlow';
 import { TEventMap } from './events';
-import { TConnectionConfiguration, TParametersConnection } from './types';
+import { TConnectionConfig, TParametersConnection } from './types';
 type TConnectParameters = (() => Promise<TParametersConnection>) | TParametersConnection;
 type TConnectOptions = Parameters<TConnect>[1] & {
     hasReadyForConnection?: () => boolean;
@@ -33,7 +33,7 @@ export default class ConnectionManager extends EventEmitterProxy<TEventMap> {
     get connectionState(): import('./ConnectionStateMachine').EConnectionStatus;
     get isRegistered(): boolean;
     get isRegisterConfig(): boolean;
-    connect: (parameters: TConnectParameters, options?: TConnectOptions) => Promise<TConnectionConfiguration>;
+    connect: (parameters: TConnectParameters, options?: TConnectOptions) => Promise<TConnectionConfig>;
     disconnect: () => Promise<void>;
     register(): Promise<RegisteredEvent>;
     unregister(): Promise<UnRegisteredEvent>;
@@ -42,7 +42,7 @@ export default class ConnectionManager extends EventEmitterProxy<TEventMap> {
     ping: (body?: Parameters<SipOperations["ping"]>[0], extraHeaders?: Parameters<SipOperations["ping"]>[1]) => Promise<void>;
     checkTelephony: (parameters: TParametersCheckTelephony) => Promise<void>;
     isConfigured(): boolean;
-    getConnectionConfiguration: () => TConnectionConfiguration | undefined;
+    getConnectionConfiguration: () => TConnectionConfig | undefined;
     destroy(): void;
     getUri: TGetUri;
     getUser(): string | undefined;

package/dist/ConnectionManager/ConnectionFlow.d.ts

@@ -3,12 +3,12 @@ import { TGetUri } from '../CallManager';
 import { ConnectionStateMachine } from './ConnectionStateMachine';
 import { TEvents } from './events';
 import { default as RegistrationManager } from './RegistrationManager';
-import { TConnectionConfiguration, TParametersConnection } from './types';
+import { TConnectionConfig, TParametersConnection } from './types';
 import { default as UAFactory } from './UAFactory';
 type TConnectParameters = (() => Promise<TParametersConnection>) | TParametersConnection;
 export type TConnect = (parameters: TConnectParameters, options?: {
     numberOfConnectionAttempts?: number;
-}) => Promise<TConnectionConfiguration>;
+}) => Promise<TConnectionConfig>;
 interface IDependencies {
     events: TEvents;
     uaFactory: UAFactory;

package/dist/ConnectionManager/ConnectionStateMachine/ConnectionStateMachine.d.ts

@@ -1,29 +1,29 @@
 import { BaseStateMachine } from '../../tools/BaseStateMachine';
 import { EEvents, EState } from './constants';
 import { TEvents } from '../events';
-import { TConnectionConfiguration } from '../types';
+import { TConnectionConfig } from '../types';
 import { TContext, TContextMap } from './types';
 declare const connectionMachine: import('xstate').StateMachine<{
     connectionConfiguration: undefined;
 } | {
     connectionConfiguration: undefined;
 } | {
-    connectionConfiguration: TConnectionConfiguration;
+    connectionConfiguration: TConnectionConfig;
 } | {
-    connectionConfiguration: TConnectionConfiguration;
+    connectionConfiguration: TConnectionConfig;
 } | {
-    connectionConfiguration: TConnectionConfiguration;
+    connectionConfiguration: TConnectionConfig;
 } | {
-    connectionConfiguration: TConnectionConfiguration;
+    connectionConfiguration: TConnectionConfig;
 } | {
-    connectionConfiguration: TConnectionConfiguration;
+    connectionConfiguration: TConnectionConfig;
 } | {
     connectionConfiguration: undefined;
 }, {
     type: EEvents.START_CONNECT;
 } | {
     type: EEvents.START_UA;
-    configuration: TConnectionConfiguration;
+    configuration: TConnectionConfig;
 } | {
     type: EEvents.START_DISCONNECT;
 } | {
@@ -114,9 +114,9 @@ export declare class ConnectionStateMachine extends BaseStateMachine<typeof conn
     get isPendingInitUa(): boolean;
     get isActiveConnection(): boolean;
     readonly toStartConnect: () => void;
-    readonly toStartUa: (configuration: TConnectionConfiguration) => void;
+    readonly toStartUa: (config: TConnectionConfig) => void;
     reset(): void;
-    getConnectionConfiguration(): TConnectionConfiguration | undefined;
+    getConnectionConfiguration(): TConnectionConfig | undefined;
     isRegisterEnabled(): boolean;
     destroy(): void;
     private hasState;

package/dist/ConnectionManager/ConnectionStateMachine/createConnectionMachine.d.ts

@@ -4,22 +4,22 @@ export declare const createConnectionMachine: () => import('xstate').StateMachin
 } | {
     connectionConfiguration: undefined;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
     connectionConfiguration: undefined;
 }, {
     type: EEvents.START_CONNECT;
 } | {
     type: EEvents.START_UA;
-    configuration: import('..').TConnectionConfiguration;
+    configuration: import('..').TConnectionConfig;
 } | {
     type: EEvents.START_DISCONNECT;
 } | {

package/dist/ConnectionManager/ConnectionStateMachine/createConnectionMachineSetup.d.ts

@@ -4,22 +4,22 @@ export declare const createConnectionMachineSetup: () => import('xstate').SetupR
 } | {
     connectionConfiguration: undefined;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
-    connectionConfiguration: import('..').TConnectionConfiguration;
+    connectionConfiguration: import('..').TConnectionConfig;
 } | {
     connectionConfiguration: undefined;
 }, {
     type: EEvents.START_CONNECT;
 } | {
     type: EEvents.START_UA;
-    configuration: import('..').TConnectionConfiguration;
+    configuration: import('..').TConnectionConfig;
 } | {
     type: EEvents.START_DISCONNECT;
 } | {

package/dist/ConnectionManager/ConnectionStateMachine/types.d.ts

@@ -1,10 +1,10 @@
-import { TConnectionConfiguration } from '../types';
+import { TConnectionConfig } from '../types';
 import { EEvents, EState } from './constants';
 export type TConnectionMachineEvents = {
     type: EEvents.START_CONNECT;
 } | {
     type: EEvents.START_UA;
-    configuration: TConnectionConfiguration;
+    configuration: TConnectionConfig;
 } | {
     type: EEvents.START_DISCONNECT;
 } | {
@@ -31,19 +31,19 @@ export type TContextMap = {
         connectionConfiguration: undefined;
     };
     [EState.CONNECTING]: {
-        connectionConfiguration: TConnectionConfiguration;
+        connectionConfiguration: TConnectionConfig;
     };
     [EState.CONNECTED]: {
-        connectionConfiguration: TConnectionConfiguration;
+        connectionConfiguration: TConnectionConfig;
     };
     [EState.REGISTERED]: {
-        connectionConfiguration: TConnectionConfiguration;
+        connectionConfiguration: TConnectionConfig;
     };
     [EState.ESTABLISHED]: {
-        connectionConfiguration: TConnectionConfiguration;
+        connectionConfiguration: TConnectionConfig;
     };
     [EState.DISCONNECTING]: {
-        connectionConfiguration: TConnectionConfiguration;
+        connectionConfiguration: TConnectionConfig;
     };
     [EState.DISCONNECTED]: {
         connectionConfiguration: undefined;

package/dist/ConnectionManager/UAFactory.d.ts

@@ -1,6 +1,6 @@
 import { UA, UAConfigurationParams, WebSocketInterface } from '@krivega/jssip';
 import { TJsSIP } from '../types';
-export type TUAConfiguration = {
+export type TUAConfig = {
     configuration: UAConfigurationParams;
     helpers: {
         socket: WebSocketInterface;
@@ -11,7 +11,7 @@ export type TCreateUAParameters = UAConfigurationParams & {
     remoteAddress?: string;
     extraHeaders?: string[];
 };
-type TParametersCreateUaConfiguration = {
+type TParametersCreateUaConfig = {
     sipServerUrl: string;
     displayName: string;
     sipServerIp: string;
@@ -32,19 +32,19 @@ export default class UAFactory {
     private static resolveAuthorizationUser;
     private static buildExtraHeaders;
     createConfiguration({ user, password, sipServerUrl, displayName, sipServerIp, register, sessionTimers, registerExpires, // 5 minutes in sec
-    connectionRecoveryMinInterval, connectionRecoveryMaxInterval, userAgent, }: TParametersCreateUaConfiguration): TUAConfiguration;
+    connectionRecoveryMinInterval, connectionRecoveryMaxInterval, userAgent, }: TParametersCreateUaConfig): TUAConfig;
     createUA({ remoteAddress, extraHeaders, ...parameters }: TCreateUAParameters): UA;
     /**
      * Создает UA с полным жизненным циклом - конфигурация + создание + настройка событий
      */
-    createUAWithConfiguration(parameters: TParametersCreateUaConfiguration & {
+    createUAWithConfiguration(parameters: TParametersCreateUaConfig & {
         remoteAddress?: string;
         extraHeaders?: string[];
     }, events: {
         eachTriggers: (callback: (trigger: (...args: unknown[]) => void, eventName: string) => void) => void;
     }): {
         ua: UA;
-        helpers: TUAConfiguration['helpers'];
+        helpers: TUAConfig['helpers'];
     };
 }
 export {};

package/dist/ConnectionManager/events.d.ts

@@ -1,6 +1,6 @@
 import { TypedEvents } from 'events-constructor';
 import { ConnectedEvent, ConnectingEvent, DisconnectEvent, IncomingMessageEvent, IncomingRequest, OutgoingMessageEvent, RegisteredEvent, RTCSessionEvent, UnRegisteredEvent, RegistrationFailedEvent } from '@krivega/jssip';
-import { TConnectionConfiguration, TParametersConnection } from './types';
+import { TConnectionConfig, TParametersConnection } from './types';
 export declare const UA_EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent"];
 export declare const EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent", "disconnecting", "connect-started", "connect-succeeded", "connect-failed", "connect-parameters-resolve-success", "connect-parameters-resolve-failed", "connected-with-configuration"];
 export type TEventMap = {
@@ -18,8 +18,8 @@ export type TEventMap = {
         request: IncomingRequest;
     };
     'connect-started': Record<string, never>;
-    'connect-succeeded': TConnectionConfiguration;
-    'connected-with-configuration': TConnectionConfiguration;
+    'connect-succeeded': TConnectionConfig;
+    'connected-with-configuration': TConnectionConfig;
     'connect-failed': unknown;
     'connect-parameters-resolve-success': TParametersConnection;
     'connect-parameters-resolve-failed': unknown;

package/dist/ConnectionManager/index.d.ts

@@ -1,7 +1,7 @@
 export { default as ConnectionManager } from './@ConnectionManager';
-export { EConnectionStatus, ConnectionStateMachine, EConnectionStateMachineEvents, } from './ConnectionStateMachine';
-export { hasNotReadyForConnectionError, createNotReadyForConnectionError } from './utils';
+export { ConnectionStateMachine, EConnectionStateMachineEvents, EConnectionStatus, } from './ConnectionStateMachine';
 export { EVENT_NAMES as CONNECTION_MANAGER_EVENT_NAMES, createEvents } from './events';
-export type { TIceServer, TServerConfiguration, TParametersConnection, TConnectionConfiguration, } from './types';
-export type { TEvents as TConnectionManagerEvents, TEventMap as TConnectionManagerEventMap, } from './events';
-export type { TConnectionSnapshot, TConnectionContextMap } from './ConnectionStateMachine';
+export { createNotReadyForConnectionError, hasNotReadyForConnectionError } from './utils';
+export type { TIceServer, TMaxAvailableResolution, TServerConfig, TParametersConnection, TConnectionConfig, } from './types';
+export type { TEventMap as TConnectionManagerEventMap, TEvents as TConnectionManagerEvents, } from './events';
+export type { TConnectionContextMap, TConnectionSnapshot } from './ConnectionStateMachine';

package/dist/ConnectionManager/types.d.ts

@@ -6,13 +6,18 @@ export type TIceServer = {
     username?: string;
     credential?: string;
 };
-export type TServerConfiguration = {
+export type TMaxAvailableResolution = {
+    width: number;
+    height: number;
+};
+export type TServerConfig = {
     sipServerUrl: string;
     sipServerIp: string;
     remoteAddress: string;
     iceServers: TIceServer[];
+    maxAvailableResolution?: TMaxAvailableResolution;
 };
-export type TParametersConnection = TServerConfiguration & TOptionsExtraHeaders & {
+export type TParametersConnection = TServerConfig & TOptionsExtraHeaders & {
     displayName: string;
     register?: boolean;
     user?: string;
@@ -23,7 +28,7 @@ export type TParametersConnection = TServerConfiguration & TOptionsExtraHeaders
     connectionRecoveryMinInterval?: number;
     connectionRecoveryMaxInterval?: number;
 };
-export type TConnectionConfiguration = TServerConfiguration & {
+export type TConnectionConfig = TServerConfig & {
     displayName: string;
     authorizationUser: string;
     register?: boolean;

package/dist/PresentationManager/@PresentationManager.d.ts

@@ -2,11 +2,12 @@ import { EventEmitterProxy } from 'events-constructor';
 import { PresentationStateMachine } from './PresentationStateMachine';
 import { CallManager } from '../CallManager';
 import { TEventMap } from './events';
-import { TContentHint, TOnAddedTransceiver } from './types';
+import { TContentHint, TMaxResolution, TOnAddedTransceiver } from './types';
 type TPresentationOptions = {
     isNeedReinvite?: boolean;
     contentHint?: TContentHint;
     sendEncodings?: RTCRtpEncodingParameters[];
+    maxResolution?: TMaxResolution;
     onAddedTransceiver?: TOnAddedTransceiver;
 };
 export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('repeated-calls').TCanceledError<unknown>;
@@ -24,11 +25,11 @@ declare class PresentationManager extends EventEmitterProxy<TEventMap> {
     });
     get isPendingPresentation(): boolean;
     get isPresentationInProcess(): boolean;
-    startPresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { isNeedReinvite, contentHint, sendEncodings, onAddedTransceiver }?: TPresentationOptions, options?: {
+    startPresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { isNeedReinvite, contentHint, sendEncodings, maxResolution, onAddedTransceiver, }?: TPresentationOptions, options?: {
         callLimit: number;
     }): Promise<MediaStream>;
     stopPresentation(beforeStopPresentation: () => Promise<void>): Promise<MediaStream | undefined>;
-    updatePresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { contentHint, sendEncodings, onAddedTransceiver }?: TPresentationOptions): Promise<MediaStream | undefined>;
+    updatePresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { contentHint, sendEncodings, maxResolution, onAddedTransceiver }?: TPresentationOptions): Promise<MediaStream | undefined>;
     cancelSendPresentationWithRepeatedCalls(): void;
     private subscribe;
     private sendPresentationWithDuplicatedCalls;

package/dist/PresentationManager/resolveSendEncodings.d.ts

@@ -0,0 +1,8 @@
+import { TMaxResolution } from './types';
+type TParameters = {
+    stream: MediaStream;
+    sendEncodings?: RTCRtpEncodingParameters[];
+    maxResolution?: TMaxResolution;
+};
+declare const resolveSendEncodings: ({ stream, sendEncodings, maxResolution, }: TParameters) => RTCRtpEncodingParameters[] | undefined;
+export default resolveSendEncodings;

package/dist/PresentationManager/types.d.ts

@@ -1,2 +1,6 @@
 export type TOnAddedTransceiver = (transceiver: RTCRtpTransceiver, track: MediaStreamTrack, streams: MediaStream[]) => Promise<void>;
 export type TContentHint = 'motion' | 'detail' | 'text' | 'none';
+export type TMaxResolution = {
+    width: number;
+    height: number;
+};

package/dist/SipConnector/@SipConnector.d.ts

@@ -71,7 +71,7 @@ declare class SipConnector extends EventEmitterProxy<TEventMap> {
     ping: (body?: Parameters<ConnectionManager["ping"]>[0], extraHeaders?: Parameters<ConnectionManager["ping"]>[1]) => Promise<void>;
     checkTelephony: ConnectionManager['checkTelephony'];
     isConfigured: () => boolean;
-    getConnectionConfiguration: () => import('../ConnectionManager').TConnectionConfiguration | undefined;
+    getConnectionConfiguration: () => import('../ConnectionManager').TConnectionConfig | undefined;
     getUri: TGetUri;
     startAutoConnect: (...args: Parameters<AutoConnectorManager["start"]>) => Promise<Awaited<ReturnType<AutoConnectorManager["start"]>>>;
     stopAutoConnect: AutoConnectorManager['stop'];

package/dist/SipConnector/events.d.ts

@@ -3,7 +3,7 @@ import { TApiManagerEventMap } from '../ApiManager';
 import { TAutoConnectorManagerEventMap } from '../AutoConnectorManager';
 import { TCallManagerEventMap } from '../CallManager';
 import { TCallReconnectManagerEventMap } from '../CallReconnectManager';
-import { TConnectionConfiguration, TConnectionManagerEventMap } from '../ConnectionManager';
+import { TConnectionConfig, TConnectionManagerEventMap } from '../ConnectionManager';
 import { TIncomingCallManagerEventMap } from '../IncomingCallManager';
 import { TMainStreamHealthMonitorEventMap } from '../MainStreamHealthMonitor';
 import { TPresentationManagerEventMap } from '../PresentationManager';
@@ -17,7 +17,7 @@ type PrefixedEventMap<T extends Record<string, unknown>, Prefix extends string>
 };
 type TSipConnectorEventMap = {
     'disconnected-from-out-of-call': Record<string, never>;
-    'connected-with-configuration-from-out-of-call': TConnectionConfiguration;
+    'connected-with-configuration-from-out-of-call': TConnectionConfig;
     'stopped-presentation-by-server-command': Record<string, never>;
 };
 export type TEventMap = PrefixedEventMap<TAutoConnectorManagerEventMap, 'auto-connect'> & PrefixedEventMap<TCallReconnectManagerEventMap, 'call-reconnect'> & PrefixedEventMap<TConnectionManagerEventMap, 'connection'> & PrefixedEventMap<TCallManagerEventMap, 'call'> & PrefixedEventMap<TApiManagerEventMap, 'api'> & PrefixedEventMap<TIncomingCallManagerEventMap, 'incoming-call'> & PrefixedEventMap<TPresentationManagerEventMap, 'presentation'> & PrefixedEventMap<TStatsManagerEventMap, 'stats'> & PrefixedEventMap<TVideoSendingBalancerManagerEventMap, 'video-balancer'> & PrefixedEventMap<TMainStreamHealthMonitorEventMap, 'main-stream-health'> & PrefixedEventMap<TSessionManagerEventMap, 'session'> & TSipConnectorEventMap;