@vkontakte/calls-sdk 2.8.12-dev.e23c81f4.0 → 2.8.12-dev.ec5956ec.0

package/default/Api.d.ts

@@ -7,11 +7,10 @@ import { ExternalId, ExternalParticipantId, ExternalUserId } from '../types/Exte
 import { CompositeUserId, OkUserId, ParticipantId } from '../types/Participant';
 import PushData from '../types/PushData';
 export default class Api extends BaseApi {
-    private _userId;
     private _uuid;
     private _idCache;
     private _callUnsafe;
-    protected _call(method: string, data?: any, noSession?: boolean): Promise<any>;
+    protected _call(method: string, data?: any, noSession?: boolean, allowReauthorize?: boolean): Promise<any>;
     userId(participantId: ParticipantId): ExternalParticipantId;
     authorize(): Promise<void>;
     private _getAnonymLoginCacheKey;

package/default/Signaling.d.ts

@@ -1,15 +1,15 @@
 import BaseSignaling, { AddParticipantParams } from '../abstract/BaseSignaling';
-import StatsLogger from '../classes/StatsLogger';
 import { ParticipantIdRegistry } from '../classes/ParticipantIdRegistry';
 import { SharingStatReport } from '../classes/screenshare/SharingStatReport';
 import { StatAggregator } from '../classes/stat/StatAggregator';
 import { StatPings } from '../classes/stat/StatPings';
 import { StatSignalingCommands } from '../classes/stat/StatSignalingCommands';
-import TransportTopology from '../enums/TransportTopology';
+import StatsLogger from '../classes/StatsLogger';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
 import SignalingConnectionType from '../enums/SignalingConnectionType';
+import TransportTopology from '../enums/TransportTopology';
 import UserRole from '../enums/UserRole';
 import { type DebugLogger } from '../static/Debug';
 import { JSONObject } from '../static/Json';
@@ -35,13 +35,13 @@ export default class Signaling extends BaseSignaling {
     private datachannelCommandsQueue;
     private incomingCache;
     private responseHandlers;
+    private disposed;
     private connectionType;
     private conversationResolve;
     private conversationReject;
     private connected;
     private listenersReady;
     private peerId;
-    private conversationId;
     private connectionMessageWaitTimer;
     private participantIdRegistry;
     private producerNotificationDataChannel;
@@ -60,21 +60,16 @@ export default class Signaling extends BaseSignaling {
     setAbortSignal(signal: AbortSignal | undefined): void;
     setEndpoint(endpoint: string): void;
     setWebTransportEndpoint(endpoint: string | null): void;
-    setConversationId(conversationId: string): void;
     setParticipantIdRegistry(participantIdRegistry: ParticipantIdRegistry): void;
     setProducerNotificationDataChannel(dataChannel: RTCDataChannel): void;
     setProducerCommandDataChannel(dataChannel: RTCDataChannel): void;
     useCommandDataChannel(status: boolean): void;
-    /**
-     * Free used resources
-     */
-    cleanup(): void;
     /**
      * Open a connection with a signaling server
      */
     connect(connectionType: SignalingConnectionType): Promise<SignalingMessage.Connection>;
     getNextCommandSequenceNumber(): number;
-    hangup(reason: string): Promise<SignalingMessage | void>;
+    hangup(reason: string): Promise<SignalingMessage>;
     sendCandidate(participantId: ParticipantId, candidate: RTCIceCandidate): Promise<SignalingMessage>;
     requestTestMode(consumerCommand: string, producerCommand: string | null): Promise<SignalingMessage>;
     sendSdp(participantId: ParticipantId, sdp: RTCSessionDescriptionInit, extraPayload?: Record<string, any>): Promise<SignalingMessage>;
@@ -138,10 +133,7 @@ export default class Signaling extends BaseSignaling {
     acceptPromotion(reject?: boolean): Promise<SignalingMessage>;
     feedback(key: string): Promise<SignalingMessage>;
     getHandQueue(): Promise<SignalingMessage>;
-    /**
-     * Close a connection with a signaling server
-     */
-    close(): void;
+    dispose(cause?: Error): void;
     /**
      * Этот метод нужен т.к. после получения сообщения "connected" устанавливается транспорт
      * и подписывается на сигналинг. Данные приходят очень быстро и транспорт пропускает
@@ -173,20 +165,25 @@ export default class Signaling extends BaseSignaling {
     private _onError;
     private _serializeErrorEvent;
     private _onClose;
-    private _closeSocket;
+    private _terminate;
+    private _fail;
     private _isRecordCommand;
     private _resolvePendingRecordCommands;
     private _handleCommandResponse;
     private _handleCommandsQueue;
     private _startResponseTimer;
+    private _resolveCommandWithoutResponse;
     private _serializeBinary;
     private _serializeJson;
     private _convertDisplayLayout;
     private _waitConnectionMessage;
     private _stopWaitConnectionMessage;
+    private _onTransportConnecting;
     private _onTransportFailed;
     private _onTransportReconnectScheduled;
     private _onTransportConnectionDead;
+    private _attachNotificationCallError;
+    private _createSignalingCallError;
     private _getSocketType;
     private _markTransportStat;
     private _logTransportStat;

package/default/SignalingTransport.d.ts

@@ -1,5 +1,6 @@
 import SignalingConnectionType from '../enums/SignalingConnectionType';
 import { SignalingTransportType } from '../enums/SignalingTransportStat';
+import { DebugLogger } from '../static/Debug';
 export declare enum SignalingTransportFailure {
     EMPTY_ENDPOINT = "EMPTY_ENDPOINT",
     NETWORK_ERROR = "NETWORK_ERROR",
@@ -8,13 +9,19 @@ export declare enum SignalingTransportFailure {
 export type SignalingTransportFailedEvent = {
     failure: SignalingTransportFailure;
     message: string;
+    source: SignalingTransportType;
     remote?: boolean;
 };
 export type SignalingTransportReconnectEvent = {
     count: number;
     delay: number;
 };
+export type SignalingTransportConnectingEvent = {
+    connectionType: SignalingConnectionType;
+    source: SignalingTransportType;
+};
 export type SignalingTransportHandlers = {
+    onConnecting: (event: SignalingTransportConnectingEvent) => void;
     onOpen: () => void;
     onMessage: (event: MessageEvent) => void;
     onError: (event: Event) => void;
@@ -38,7 +45,8 @@ export default class SignalingTransport {
     private abortSignal;
     private manualClose;
     private currentType;
-    constructor(handlers: SignalingTransportHandlers);
+    private readonly _debug;
+    constructor(debug: DebugLogger | undefined, handlers: SignalingTransportHandlers);
     get readyState(): number | null;
     get type(): SignalingTransportType;
     setEndpoint(endpoint: string): void;
@@ -49,7 +57,7 @@ export default class SignalingTransport {
     resetReconnectCount(): void;
     connect(connectionType: SignalingConnectionType): void;
     close(code?: number): void;
-    send(data: string | ArrayBuffer): void;
+    send(data: string | ArrayBuffer): Promise<void>;
     private _connect;
     private _connectWebTransport;
     private _connectWebSocket;

package/enums/ClientHangupReason.d.ts

@@ -0,0 +1,7 @@
+import HangupType from './HangupType';
+/**
+ * Причины завершения звонка, которые клиент может передать в {@link hangup}/{@link declineCall}
+ * и пробросить в сигналинг без маппинга.
+ */
+export type ClientHangupReason = HangupType.HUNGUP | HangupType.CANCELED | HangupType.REJECTED | HangupType.BUSY | HangupType.MISSED | HangupType.CALL_TIMEOUT;
+export default ClientHangupReason;

package/enums/HangupType.d.ts

@@ -20,7 +20,6 @@ declare enum HangupType {
     CALLER_IS_REJECTED = "CALLER_IS_REJECTED",
     UNKNOWN_ERROR = "UNKNOWN_ERROR",
     UNSUPPORTED = "UNSUPPORTED",
-    OLD_VERSION = "OLD_VERSION",
     SERVICE_DISABLED = "SERVICE_DISABLED",
     SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
     EXTERNAL_API_ERROR = "EXTERNAL_API_ERROR",

package/enums/Stat.d.ts

@@ -1,4 +1,9 @@
 declare const enum Stat {
+    CALL_INIT = "call_init",
+    CALL_START = "call_start",
+    CALL_ACCEPTED_OUTGOING = "call_accepted_outgoing",
+    CALL_ACCEPTED_INCOMING = "call_accepted_incoming",
+    FIRST_MEDIA_SENT = "first_media_sent",
     CALL_FINISH = "call_finish",// событие отправляемое в конце звонка
     CODEC_USAGE = "codec_usage",// событие когда меняется кодек
     SIGNALING_CONNECTED = "signaling_connected",// measure
@@ -7,7 +12,6 @@ declare const enum Stat {
     FIRST_MEDIA_RECEIVED = "first_media_received",
     CALL_DECLINED_OR_HANGED_LOCALLY = "CallDeclinedOrHangedLocally",
     USER_FEEDBACK_RECEIVED = "UserFeedbackReceived",
-    CALL_START = "call_start",
     SIGNALING_PING_SUMMARY = "signaling_ping_summary",
     SIGNALING_COMMAND_SUMMARY = "signaling_command_summary",
     WEBSOCKET_CONNECTED = "websocket_connected",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/calls-sdk",
-  "version": "2.8.12-dev.e23c81f4.0",
+  "version": "2.8.12-dev.ec5956ec.0",
   "author": "vk.com",
   "description": "Library for video calls based on the vk.com platform",
   "homepage": "https://vk.com",

package/static/AuthData.d.ts

@@ -1,12 +1,22 @@
+import type { OkUserId } from '../types/Participant';
 export default abstract class AuthData {
     private static _sessionKey;
     private static _sessionSecretKey;
     private static _accessToken;
+    private static _userId;
+    private static _reauthorizePromise;
     static get sessionKey(): string | undefined;
     static set sessionKey(value: string | undefined);
     static get sessionSecretKey(): string | undefined;
     static set sessionSecretKey(value: string | undefined);
     static get accessToken(): string | undefined;
     static set accessToken(value: string | undefined);
+    static get userId(): OkUserId | null;
+    static set userId(value: OkUserId | null);
     static isEmpty(): boolean;
+    /**
+     * Дедуплицирует одновременные попытки реавторизации из разных инстансов Api.
+     * Первый вызов выполняет authorizeFn, остальные ждут того же промиса.
+     */
+    static reauthorize(authorizeFn: () => Promise<void>): Promise<void>;
 }

package/static/Debug.d.ts

@@ -21,6 +21,7 @@ export type DebugSessionLogger = DebugLogger & {
     readonly sessionId: string | null;
     readonly conversationId: string | null;
     setConversationId(conversationId: string | null): void;
+    send(type: DebugMessageType, ...args: any[]): void;
 };
 declare namespace Debug {
     type ContextProvider = () => DebugMessageContext;

package/static/External.d.ts

@@ -637,6 +637,6 @@ declare namespace External {
     /**
      * Собеседник подключился к сигналлингу
      */
-    function onPeerRegistered(conversationId?: string): void;
+    function onPeerRegistered(conversationId?: string, externalIds?: ExternalId[]): void;
 }
 export default External;

package/static/Params.d.ts

@@ -485,13 +485,6 @@ export type ParamsObject = {
      * _По умолчанию: `false`_
      */
     webtransport: boolean;
-    /**
-     * Включить поддержку webtransport для сигналинга в FireFox
-     * Отдельная ручка, так как есть проблемы сейчас с FF
-     *
-     * _По умолчанию: `false`_
-     */
-    webtransportFF: boolean;
     /**
      * Ждать подтверждения от бэкенда для команд startStream/stopStream.
      * При включении: reject без соединения, resolve/reject по ответу бэкенда,
@@ -899,7 +892,7 @@ export type ParamsObject = {
     /**
      * Собеседник подключился к сигналлингу
      */
-    onPeerRegistered?: (conversationId?: string) => void;
+    onPeerRegistered?: (conversationId?: string, externalIds?: ExternalId[]) => void;
 };
 export default abstract class Params {
     private static _params;
@@ -1031,7 +1024,6 @@ export default abstract class Params {
     static get enableVideoEffectsFpsDegradation(): boolean;
     static get simulcast(): boolean;
     static get webtransport(): boolean;
-    static get webtransportFF(): boolean;
     static get waitForRecordResponse(): boolean;
     static get transparentAudio(): boolean;
     static get enableSessionStateUpdates(): boolean;
@@ -1068,7 +1060,6 @@ export default abstract class Params {
         switchVideoAtBadNetwork: boolean;
         simulcast: boolean;
         webtransport: boolean;
-        webtransportFF: boolean;
         waitForRecordResponse: boolean;
         transparentAudio: boolean;
         enableSessionStateUpdates: boolean;

package/static/WebRTCUtils.d.ts

@@ -122,6 +122,10 @@ declare namespace WebRTCUtils {
      * Проверяет поддержку WebRTC браузером
      */
     function isBrowserSupported(): boolean;
+    /**
+     * Возвращает первую отсутствующую capability в стабильном порядке.
+     */
+    function getBrowserSupportFailure(): BrowserSupportFailure | null;
     /**
      * Проверяет поддержку шаринга экрана браузером
      */

package/types/Conversation.d.ts

@@ -7,7 +7,8 @@ import MediaOption from '../enums/MediaOption';
 import UserRole from '../enums/UserRole';
 import { AsrInfo } from './Asr';
 import { IFeaturesPerRole } from './ConversationFeature';
-import { ExternalId, ExternalParticipantId } from './ExternalId';
+import { ExternalId, ExternalParticipantId, ExternalUserId } from './ExternalId';
+import { FastJoinHandler } from './FastJoin';
 import { FastStartHandler } from './FastStart';
 import MediaModifiers from './MediaModifiers';
 import MuteStates from './MuteStates';
@@ -84,6 +85,16 @@ export type ConversationOnStartParams = {
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };
+export type ConversationOnJoinParams = {
+    conversationId?: string;
+    mediaOptions: MediaOption[];
+    chatId?: string;
+    joinLink?: string;
+    observedIds?: ExternalUserId[];
+    payload?: string;
+    onFastJoin?: FastJoinHandler;
+    anonymous?: boolean;
+};
 export type StartConversationParams = {
     opponentIds?: OkUserId[];
     opponentType: CallType;
@@ -94,7 +105,6 @@ export type StartConversationParams = {
     requireAuthToJoin?: boolean;
     onlyAdminCanShareMovie?: boolean;
     externalIds?: ExternalId[];
-    startedTime: number;
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };

package/types/SignalingMessage.d.ts

@@ -34,8 +34,11 @@ export type RecordInfo = {
     recordExternalOwnerId?: string;
 };
 export interface SignalingResponse extends SignalingMessage {
-    response?: SignalingCommandType;
     error?: string;
+    errorCode?: string;
+    errorMessage?: string;
+    message?: string;
+    response?: SignalingCommandType;
     reason?: HangupType | FatalError;
     sequence?: number;
     type: 'response' | 'error' | 'timeout';
@@ -185,6 +188,7 @@ declare namespace SignalingMessage {
         peerId: PeerId;
         mediaSettings: Partial<MediaSettings>;
         capabilities?: string;
+        externalId?: ExternalId;
     }
     export interface Hungup extends Notification {
         participantId: OkUserId;

package/types/WebTransport.d.ts

@@ -1,31 +1,32 @@
 import { WebTransportOptions } from '@fails-components/webtransport';
+import { DebugLogger } from '../static/Debug';
 declare class WebTransportEventual {
+    static isBrowserSupported(): boolean;
+    onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
+    onmessage: ((this: WebTransportEventual, ev: MessageEvent) => any) | null;
+    onerror: ((this: WebTransportEventual, ev: Event) => any) | null;
+    onclose: ((this: WebTransportEventual, ev: CloseEvent) => any) | null;
+    readyState: number;
     private webTransport;
-    private stream;
     private writer;
-    private reader;
     private readonly url;
     private readonly options;
     private readonly compression;
-    private closeRequested;
-    private closeEventEmitted;
     private encoder;
     private decoder;
-    onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
-    onmessage: ((this: WebTransportEventual, ev: MessageEvent) => any) | null;
-    onerror: ((this: WebTransportEventual, ev: Event) => any) | null;
-    onclose: ((this: WebTransportEventual, ev: CloseEvent) => any) | null;
-    readyState: number;
-    constructor(url: string, options?: WebTransportOptions);
+    private readonly _debug;
+    constructor(url: string, options?: WebTransportOptions, debug?: DebugLogger);
+    send(data: string): Promise<void>;
+    close(code?: number, reason?: string): void;
     private getCompressionTypeFromUrl;
     private connect;
-    private readChunks;
+    private observeClosed;
     private readLoop;
-    send(data: string): Promise<void>;
+    private fail;
+    private handleStreamError;
+    private requestNativeClose;
+    private finishClose;
+    private emitEvent;
     private createErrorEvent;
-    close(code?: number, reason?: string): void;
-    private closeConnectedTransport;
-    private emitClose;
-    static isBrowserSupported(): boolean;
 }
 export { WebTransportEventual as WebTransport };

package/utils/IceServers.d.ts

@@ -0,0 +1,2 @@
+import IceServer from '../types/IceServer';
+export declare function createIceServers(stunServer?: IceServer, turnServer?: IceServer): IceServer[];