@vkontakte/calls-sdk 2.8.11-dev.4bbae276.0 → 2.8.11-dev.7ac19827.0

package/classes/ConversationResponseValidator.d.ts

@@ -0,0 +1,3 @@
+import ConversationResponse from '../types/ConversationResponse';
+export type ConversationResponseSource = 'startConversation' | 'joinConversation' | 'joinConversationByLink' | 'fastStart' | 'fastJoin';
+export declare function assertValidConversationResponse(response: ConversationResponse | null | undefined, source: ConversationResponseSource): void;

package/default/Signaling.d.ts

@@ -5,7 +5,6 @@ import { TransportTopology } from '../classes/transport/Transport';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
-import SignalingCommandType from '../enums/SignalingCommandType';
 import SignalingConnectionType from '../enums/SignalingConnectionType';
 import UserRole from '../enums/UserRole';
 import { JSONObject } from '../static/Json';
@@ -21,42 +20,33 @@ import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/Partici
 import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
 import { StreamDescriptionString } from '../types/ParticipantStreamDescription';
 import { PerfStatReport } from '../types/PerfStatReporter';
-import SignalingMessage, { GetParticipantsSignalingResponse, GetRoomsSignalingResponse, SignalingSuccessResponse } from '../types/SignalingMessage';
+import SignalingMessage, { GetParticipantsSignalingResponse, GetRoomsSignalingResponse } from '../types/SignalingMessage';
 import { IPublishStreamData, IRecordConfData, IStartStreamData, IStopStreamData } from '../types/Streams';
 export default class Signaling extends BaseSignaling {
-    private socket;
-    protected sequence: number;
+    private transport;
+    private sequence;
     private lastStamp;
     private websocketCommandsQueue;
     private datachannelCommandsQueue;
     private incomingCache;
     private responseHandlers;
     private connectionType;
-    private reconnectCount;
-    private endpoint;
-    private wtEndpoint;
-    protected conversationResolve: Function | null;
-    protected conversationReject: Function | null;
+    private conversationResolve;
+    private conversationReject;
     private connected;
     private listenersReady;
-    private postfix;
-    protected peerId: number | null;
-    protected conversationId: string | null;
-    private reconnectTimer;
+    private peerId;
+    private conversationId;
     private connectionMessageWaitTimer;
-    private doctorTimer;
     private participantIdRegistry;
     private producerNotificationDataChannel;
     private producerCommandDataChannel;
     private producerCommandDataChannelEnabled;
     private producerCommandSerializationService;
-    private static get RECONNECT_DELAY();
-    private static get RECONNECT_MAX_DELAY();
-    private static get RECONNECT_MAX_COUNT();
     private static get WAIT_CONNECTION_DELAY();
     private static get WAIT_RESPONSE_DELAY();
-    private static get WAIT_MESSAGE_DELAY();
     get ready(): boolean;
+    setAbortSignal(signal: AbortSignal | undefined): void;
     setEndpoint(endpoint: string): void;
     setWebTransportEndpoint(endpoint: string | null): void;
     setConversationId(conversationId: string): void;
@@ -72,15 +62,6 @@ export default class Signaling extends BaseSignaling {
      * Open a connection with a signaling server
      */
     connect(connectionType: SignalingConnectionType): Promise<SignalingMessage.Connection>;
-    /**
-     * Send a command to a signaling server
-     */
-    protected _send<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
-    /**
-     * Send a raw command to a signaling server
-     */
-    protected _sendRaw<T extends SignalingSuccessResponse>(command: SignalingCommandType, params?: any, needResponse?: boolean, retryCount?: number): Promise<T>;
-    private _isDataChannelCommand;
     getNextCommandSequenceNumber(): number;
     hangup(reason: string): Promise<SignalingMessage | void>;
     sendCandidate(participantId: ParticipantId, candidate: RTCIceCandidate): Promise<SignalingMessage>;
@@ -164,32 +145,36 @@ export default class Signaling extends BaseSignaling {
     startAsr(params: IAsrStartParams): Promise<SignalingMessage>;
     stopAsr(params?: IAsrStopParams): Promise<SignalingMessage>;
     requestAsr(request: boolean): Promise<SignalingMessage>;
-    protected _connect(connectionType: SignalingConnectionType, useWebTransport: boolean): void;
-    protected _disconnect(code?: number): void;
+    /**
+     * Send a command to a signaling server
+     */
+    private _send;
+    /**
+     * Send a raw command to a signaling server
+     */
+    private _sendRaw;
+    private _isDataChannelCommand;
     private _onOpen;
     private _onMessage;
-    protected _handleMessage(message: SignalingMessage): void;
+    private _handleMessage;
     private _handleErrorMessage;
-    protected _handleCachedMessages(): void;
+    private _handleCachedMessages;
     private _throwError;
     private _onError;
-    protected _onClose(event: CloseEvent): void;
-    protected _closeSocket(error?: Error | null): void;
-    protected _reconnect(): void;
+    private _serializeErrorEvent;
+    private _onClose;
+    private _closeSocket;
     private _handleCommandResponse;
     private _handleCommandsQueue;
     private _startResponseTimer;
     private _serializeBinary;
     private _serializeJson;
     private _convertDisplayLayout;
-    protected _waitConnectionMessage(): void;
-    protected _stopWaitConnectionMessage(): void;
-    /**
-     * Отвечает за timeout логику в WebSocket, если неполучаем никаких сообщений в течении WAIT_MESSAGE_DELAY, то запускаем реконнект
-     */
-    private _startDoctor;
-    private _stopDoctor;
-    private isWebTransportAvailable;
+    private _waitConnectionMessage;
+    private _stopWaitConnectionMessage;
+    private _onTransportFailed;
+    private _onTransportReconnectScheduled;
+    private _onTransportConnectionDead;
     private _getSocketType;
     private _markTransportStat;
     private _logTransportStat;

package/default/SignalingTransport.d.ts

@@ -0,0 +1,68 @@
+import SignalingConnectionType from '../enums/SignalingConnectionType';
+import { SignalingTransportType } from '../enums/SignalingTransportStat';
+export declare enum SignalingTransportFailure {
+    EMPTY_ENDPOINT = "EMPTY_ENDPOINT",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    ABORTED = "ABORTED"
+}
+export type SignalingTransportFailedEvent = {
+    failure: SignalingTransportFailure;
+    message: string;
+    remote?: boolean;
+};
+export type SignalingTransportReconnectEvent = {
+    count: number;
+    delay: number;
+};
+export type SignalingTransportHandlers = {
+    onOpen: () => void;
+    onMessage: (event: MessageEvent) => void;
+    onError: (event: Event) => void;
+    onClose: (event: CloseEvent) => void;
+    onFailed: (event: SignalingTransportFailedEvent) => void;
+    onReconnectScheduled: (event: SignalingTransportReconnectEvent) => void;
+    onConnectionDead: () => void;
+};
+export default class SignalingTransport {
+    private readonly handlers;
+    private socket;
+    private endpoint;
+    private wtEndpoint;
+    private peerId;
+    private lastStamp;
+    private connectionType;
+    private reconnectCount;
+    private reconnectTimer;
+    private doctorTimer;
+    private forceWebSocket;
+    private abortSignal;
+    private manualClose;
+    private currentType;
+    constructor(handlers: SignalingTransportHandlers);
+    get readyState(): number | null;
+    get type(): SignalingTransportType;
+    setEndpoint(endpoint: string): void;
+    setWebTransportEndpoint(endpoint: string | null): void;
+    setPeerId(peerId: number | null): void;
+    setLastStamp(lastStamp: number): void;
+    setAbortSignal(signal?: AbortSignal): void;
+    resetReconnectCount(): void;
+    connect(connectionType: SignalingConnectionType): void;
+    close(code?: number): void;
+    send(data: string | ArrayBuffer): void;
+    private _connect;
+    private _connectWebTransport;
+    private _connectWebSocket;
+    private _setSocketHandlers;
+    private _buildUrl;
+    private _canUseWebTransport;
+    private _onOpen;
+    private _onMessage;
+    private _onError;
+    private _onClose;
+    private _disconnect;
+    private _scheduleReconnect;
+    private _getReconnectDelay;
+    private _startDoctor;
+    private _stopDoctor;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/calls-sdk",
-  "version": "2.8.11-dev.4bbae276.0",
+  "version": "2.8.11-dev.7ac19827.0",
   "author": "vk.com",
   "description": "Library for video calls based on the vk.com platform",
   "homepage": "https://vk.com",

package/types/WebTransport.d.ts

@@ -7,6 +7,8 @@ declare class WebTransportEventual {
     private readonly url;
     private readonly options;
     private readonly compression;
+    private closeRequested;
+    private closeEventEmitted;
     private encoder;
     private decoder;
     onopen: ((this: WebTransportEventual, ev: Event) => any) | null;
@@ -20,7 +22,10 @@ declare class WebTransportEventual {
     private readChunks;
     private readLoop;
     send(data: string): Promise<void>;
+    private createErrorEvent;
     close(code?: number, reason?: string): void;
+    private closeConnectedTransport;
+    private emitClose;
     static isBrowserSupported(): boolean;
 }
 export { WebTransportEventual as WebTransport };