@livedigital/client 3.37.0 → 3.38.0-tt-504-data-channels.1

package/dist/EnhancedEventEmitter.d.ts

@@ -1,18 +1,16 @@
 import { EventEmitter } from 'events';
-export type Events = Record<string, any[]>;
-export default class EnhancedEventEmitter<E extends Events = Events> extends EventEmitter {
+type EventMap = Record<PropertyKey, any[]>;
+export default class EnhancedEventEmitter<E extends Record<keyof E, any[]> = EventMap> extends EventEmitter {
     constructor();
-    emit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
-    safeEmit<K extends keyof E & string>(eventName: K, ...args: E[K]): boolean;
-    on<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    off<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    addListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    prependListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    once<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    prependOnceListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    removeListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    removeAllListeners(eventName?: keyof E & string): this;
-    listenerCount(eventName: keyof E & string): number;
-    listeners(eventName: keyof E & string): Function[];
-    rawListeners(eventName: keyof E & string): Function[];
+    emit<K extends keyof E & string>(event: K, ...args: E[K]): boolean;
+    safeEmit<K extends keyof E & string>(event: K, ...args: E[K]): boolean;
+    on<K extends keyof E & string>(e: K, fn: (...a: E[K]) => void): this;
+    off<K extends keyof E & string>(e: K, fn: (...a: E[K]) => void): this;
+    once<K extends keyof E & string>(e: K, fn: (...a: E[K]) => void): this;
+    addListener: <K extends keyof E & string>(event: K, listener: (...a: E[K]) => void) => this;
+    removeListener: <K extends keyof E & string>(event: K, listener: (...a: E[K]) => void) => this;
+    prependListener: <K extends keyof E & string>(event: K, listener: (...a: E[K]) => void) => this;
+    prependOnceListener: <K extends keyof E & string>(event: K, listener: (...a: E[K]) => void) => this;
+    removeAllListeners(event?: keyof E & string): this;
 }
+export {};

package/dist/constants/common.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '../types/common';
-export declare const SIGNALING_API_VERSION = 4;
+export declare const SIGNALING_API_VERSION = 5;
 export declare const LOG_LEVEL_ERROR: LogLevel;
 export declare const LOG_LEVEL_WARN: LogLevel;
 export declare const LOG_LEVEL_INFO: LogLevel;
@@ -16,6 +16,7 @@ export declare const SECOND_IN_MS = 1000;
 export declare const TWO_SECONDS_IN_MS: number;
 export declare const FIVE_SECONDS_IN_MS: number;
 export declare const TEN_SECONDS_IN_MS: number;
+export declare const FIFTEEN_SECONDS_IN_MS: number;
 export declare const MINUTE_IN_MS: number;
 export declare enum HttpStatusCode {
     Continue = 100,

package/dist/constants/common.ts

@@ -2,7 +2,7 @@
 
 import type { LogLevel } from '../types/common';
 
-export const SIGNALING_API_VERSION = 4;
+export const SIGNALING_API_VERSION = 5;
 
 export const LOG_LEVEL_ERROR: LogLevel = 3;
 export const LOG_LEVEL_WARN: LogLevel = 4;
@@ -29,11 +29,12 @@ export const DEBOUNCE_LIMIT = 3;
 export const MEDIASOUP_SSRC_PROBATOR = 1234;
 
 export const HALF_SECOND_IN_MS = 500;
-export const SECOND_IN_MS = 1000;
-export const TWO_SECONDS_IN_MS = 2 * 1000;
-export const FIVE_SECONDS_IN_MS = 5 * 1000;
-export const TEN_SECONDS_IN_MS = 10 * 1000;
-export const MINUTE_IN_MS = 60 * 1000;
+export const SECOND_IN_MS = 1_000;
+export const TWO_SECONDS_IN_MS = 2 * 1_000;
+export const FIVE_SECONDS_IN_MS = 5 * 1_000;
+export const TEN_SECONDS_IN_MS = 10 * 1_000;
+export const FIFTEEN_SECONDS_IN_MS = 15 * 1_000;
+export const MINUTE_IN_MS = 60 * 1_000;
 
 export enum HttpStatusCode {
   // 1xx Informational

package/dist/constants/videoConstrains.ts

@@ -17,5 +17,5 @@ export const SpatialLayer = {
 export const TemporalLayer = {
   BASE: 0,
   MIDDLE: 1,
-  HIGH: 2
+  HIGH: 2,
 };

package/dist/engine/EventsQueue.d.ts

@@ -1,14 +1,12 @@
 import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
-import { Socket } from 'socket.io-client';
-import Logger from './Logger';
+import { Logger } from '../types/common';
 export default class EventsQueue {
     #private;
     constructor(loggerFactory: (namespace: string) => Logger);
-    subscribeToSocket(emmiter: Socket): void;
-    subscribeToDataChannel(dataChannel: DataConsumer): void;
+    subscribe(dataChannel: DataConsumer): void;
     on(event: string, handler: (...args: any[]) => void | Promise<void>): void;
     removeListener(event: string): void;
-    removeAllListeners(events: string[], emitter?: Socket): void;
+    removeListeners(events: string[], emitter?: DataConsumer): void;
     private push;
     private process;
     private emit;

package/dist/engine/handlers/ChannelEventHandler.d.ts

@@ -1,20 +1,17 @@
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import EventsQueue from '../EventsQueue';
 import Logger from '../Logger';
-import SocketIO from '../network/Socket';
 import { Peers } from '../Peers';
+import DataChannelsManager from '../network/DataChannelsManager';
 declare class ChannelEventHandler {
     #private;
     private readonly eventsQueue;
-    private readonly socket;
+    private readonly dataChannelsManager;
     private readonly peers;
     private readonly clientEventEmitter;
-    constructor(eventsQueue: EventsQueue, socket: SocketIO, peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
-    handleDataChannelEvent(payload: string): void;
-    private doHandleDataChannelEvent;
+    constructor(eventsQueue: EventsQueue, dataChannelsManager: DataChannelsManager, peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
     subscribeToEvents(): void;
     private removeEventListeners;
-    private handlePeerAppDataUpdate;
     reset(): void;
 }
 export default ChannelEventHandler;

package/dist/engine/handlers/ChannelStateSyncEventHandler/types.d.ts

@@ -1,4 +1,4 @@
-export declare enum InconsistenceType {
+export declare enum InconsistencyType {
     MissingPeer = "missing-peer",
     MissingProducer = "missing-producer",
     IncorrectProducerState = "incorrect-producer-state",

package/dist/engine/handlers/MediaSoupEventHandler.d.ts

@@ -1,23 +1,19 @@
 import EventsQueue from '../EventsQueue';
 import Media from '../media';
-import Network from '../network';
 import { Peers } from '../Peers';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import Logger from '../Logger';
-import SocketIO from '../network/Socket';
+import DataChannelsManager from '../network/DataChannelsManager';
 declare class MediaSoupEventHandler {
     #private;
     private readonly eventsQueue;
     private readonly media;
-    private readonly network;
-    private readonly socket;
+    private readonly dataChannelsManager;
     private readonly internalEventEmitter;
     private readonly peers;
     private readonly clientEventEmitter;
-    constructor(eventsQueue: EventsQueue, media: Media, network: Network, socket: SocketIO, internalEventEmitter: EnhancedEventEmitter, peers: Peers, clientEventEmitter: EnhancedEventEmitter, loggerFactory: (namespace: string) => Logger);
+    constructor(eventsQueue: EventsQueue, media: Media, dataChannelsManager: DataChannelsManager, internalEventEmitter: EnhancedEventEmitter, peers: Peers, clientEventEmitter: EnhancedEventEmitter);
     subscribeToEvents(): void;
     private removeEventListeners;
     reset(): void;
-    private handleProducerSetMaxSpatialLayer;
 }
 export default MediaSoupEventHandler;

package/dist/engine/media/index.d.ts

@@ -1,7 +1,7 @@
 import { Device, type types } from 'mediasoup-client';
 import ConfigService from '../../config/ConfigService';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, CreateVideoTrackParams, TrackLabel, TransformParams } from '../../types/common';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, CreateVideoTrackParams, ProducerRequestMaxSpatialLayer, TrackLabel, TransformParams } from '../../types/common';
 import type { AudioTrackFactory, VideoTrackFactory } from '../../types/container';
 import { AudioTrack, BaseTrack, InitEffectsSDKParams, TrackWithEncodings } from '../../types/media';
 import { IntegrationsService } from '../IntegrationsService';
@@ -9,6 +9,7 @@ import Logger from '../Logger';
 import { ProcessorsCache } from './streamEffects/ProcessorsCache';
 import EffectsSDKTrackProcessor from './streamEffects/video/esdk/TrackProcessor';
 import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
+import SocketIO from '../network/Socket';
 export interface DenoiserFallbackContext {
     reason: string;
     options?: CreateMicrophoneAudioTrackOptions;
@@ -24,10 +25,11 @@ declare class Media {
     private readonly processorsCache;
     private readonly videoTrackFactory;
     private readonly mediaStreamTrackManager;
+    private readonly socket;
     isDeviceLoaded: boolean;
     private device?;
     private readonly tracks;
-    constructor(config: ConfigService, loggerFactory: (namespace: string) => Logger, audioTrackFactory: AudioTrackFactory, clientEventEmitter: EnhancedEventEmitter, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, videoTrackFactory: VideoTrackFactory, mediaStreamTrackManager: MediaStreamTrackManager);
+    constructor(config: ConfigService, loggerFactory: (namespace: string) => Logger, audioTrackFactory: AudioTrackFactory, clientEventEmitter: EnhancedEventEmitter, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, videoTrackFactory: VideoTrackFactory, mediaStreamTrackManager: MediaStreamTrackManager, socket: SocketIO);
     get mediasoupDevice(): Device;
     get effectsSDKInitialized(): boolean;
     get effectsSDKParams(): InitEffectsSDKParams | null;
@@ -48,6 +50,7 @@ declare class Media {
     initDenoiser(track: AudioTrack, options?: CreateMicrophoneAudioTrackOptions): Promise<void>;
     fallbackToRNoise(track: AudioTrack, context: DenoiserFallbackContext): Promise<void>;
     createEffectsSDKTrackProcessor(trackLabel?: TrackLabel): Promise<EffectsSDKTrackProcessor>;
+    handleProducerSetMaxSpatialLayer({ producerId, spatialLayer: rawSpatialLayer, }: ProducerRequestMaxSpatialLayer): Promise<void>;
     static getVideoTrackTransformParams(track: MediaStreamTrack): TransformParams;
     static getScreenVideoTrackParams(options?: CreateScreenMediaOptions): CreateVideoTrackParams;
     static getCameraVideoTrackParams(options?: CreateCameraVideoTrackOptions): CreateVideoTrackParams;

package/dist/engine/media/streamEffects/ProcessorsCache.d.ts

@@ -7,5 +7,5 @@ export declare class ProcessorsCache {
     get(type: ProcessorType, label: TrackLabel): AudioTrackProcessor | undefined;
     has(type: ProcessorType, label: TrackLabel): boolean;
     private getKey;
-    reset(): Promise<void>;
+    reset(): void;
 }

package/dist/engine/media/streamEffects/audio/AudioTrackProcessor.d.ts

@@ -1,6 +1,6 @@
 export interface AudioTrackProcessor {
     readonly type: 'asdk' | 'rnnoise';
     processTrack: (track: MediaStreamTrack) => Promise<MediaStreamTrack>;
-    stopProcessing: () => Promise<void>;
+    stopProcessing: () => void;
     get isProcessing(): boolean;
 }

package/dist/engine/media/streamEffects/audio/asdk/ASDKTrackProcessor.d.ts

@@ -25,7 +25,7 @@ interface ErrorObject {
     code?: ErrorCode;
     emitter?: ErrorEmitter;
     cause?: Error;
-    data?: any;
+    data?: unknown;
 }
 declare global {
     interface Window {
@@ -46,7 +46,7 @@ export declare class ASDKTrackProcessor implements AudioTrackProcessor {
     init(): Promise<void>;
     get isProcessing(): boolean;
     processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
-    stopProcessing(): Promise<void>;
+    stopProcessing(): void;
     getUpdatedDebounceCounter(errorCode: number): number;
     onError(error: ErrorObject): void;
 }

package/dist/engine/media/streamEffects/audio/noiseSuppression/RNNoiseTrackProcessor.d.ts

@@ -10,6 +10,6 @@ export default class RNNoiseTrackProcessor implements AudioTrackProcessor {
     constructor(params: TrackProcessorParams);
     get isProcessing(): boolean;
     processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
-    stopProcessing(): Promise<void>;
+    stopProcessing(): void;
 }
 export {};

package/dist/engine/media/streamEffects/video/esdk/TrackProcessor.d.ts

@@ -62,7 +62,7 @@ export default class EffectsSDKTrackProcessor {
     get isReady(): boolean;
     setOnLoadModels(callback: () => void): void;
     onReady(): void;
-    processTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
+    processTrack(track: MediaStreamTrack): MediaStreamTrack;
     stopProcessing(): void;
     updateEffects(effects?: Effects): void;
 }

package/dist/engine/media/tracks/DefaultVideoTrack.d.ts

@@ -25,7 +25,7 @@ declare class DefaultVideoTrack extends DefaultBaseTrack implements VideoTrack {
     publish(params?: VideoTrackPublishParams): Promise<void>;
     adjustEncodingPresetToCurrentMaxSpatialLayer(maxSpatialLayer: number): Promise<void>;
     applyEffects(effects: Effects): Promise<void>;
-    resetEffects(): Promise<void>;
+    resetEffects(): void;
     setOnLoadModels(callback: () => void): void;
     get modelsLoadProgress(): number;
     pause(): Promise<void>;

package/dist/engine/media/tracks/PeerTrack.d.ts

@@ -38,7 +38,6 @@ interface PeerTrackObserverEvents {
     [PEER_EVENTS.trackFailed]: [PeerTrack];
     [PEER_EVENTS.trackPaused]: [PeerTrack];
     [PEER_EVENTS.trackResumed]: [PeerTrack];
-    [event: string]: any[];
 }
 declare class PeerTrack {
     #private;

package/dist/engine/network/DataChannelsManager.d.ts

@@ -1,25 +1,21 @@
+import { DataConsumer } from 'mediasoup-client/lib/DataConsumer';
 import Logger from '../Logger';
 import Network from '.';
-import ChannelEventHandler from '../handlers/ChannelEventHandler';
 import ChannelAudioObserverEventHandler from '../handlers/ChannelAudioObserverEventHandler';
 import ChannelStateSyncEventHandler from '../handlers/ChannelStateSyncEventHandler';
 import EventsQueue from '../EventsQueue';
 import { CallState } from '../CallState';
 import { MyPeer } from '../MyPeer';
-import type { IPeersService } from '../Peers';
-import MediaSoupEventHandler from '../handlers/MediaSoupEventHandler';
 declare class DataChannelsManager {
     #private;
     private readonly state;
     private readonly myPeer;
     readonly network: Network;
-    private readonly channelEventsHandler;
     private readonly eventsQueue;
-    private readonly peers;
-    private readonly mediaSoupEventsHandler;
     private readonly channelAudioObserverEventHandler;
     private readonly channelStateSyncEventHandler;
-    constructor(state: CallState, loggerFactory: (namespace: string) => Logger, myPeer: MyPeer, network: Network, channelEventsHandler: ChannelEventHandler, eventsQueue: EventsQueue, peers: IPeersService, mediaSoupEventsHandler: MediaSoupEventHandler, channelAudioObserverEventHandler: ChannelAudioObserverEventHandler, channelStateSyncEventHandler: ChannelStateSyncEventHandler);
+    constructor(state: CallState, loggerFactory: (namespace: string) => Logger, myPeer: MyPeer, network: Network, eventsQueue: EventsQueue, channelAudioObserverEventHandler: ChannelAudioObserverEventHandler, channelStateSyncEventHandler: ChannelStateSyncEventHandler);
+    get generalDataConsumer(): DataConsumer | undefined;
     createAllDataChannels(): Promise<void>;
     closeAllDataChannels(): void;
     private createAudioObserver;

package/dist/engine/network/index.d.ts

@@ -2,17 +2,19 @@ import { Device, type types } from 'mediasoup-client';
 import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { CreateConsumerPayload, CreateConsumerResponse, CreateDataConsumerPayload, PeerResponse, Role, SocketResponse, TransportsStateInfo, UpdatePeerAppDataPayload } from '../../types/common';
-import { LDTransport } from '../../types/mediasoup';
 import { NetworkObserverEvents } from '../../types/network';
 import { CallState } from '../CallState';
 import Logger from '../Logger';
 import { MyPeer } from '../MyPeer';
 import SocketIO from './Socket';
+import { LDTransport } from '../../types/mediasoup';
+import { ClientObserverEvents } from '../../types/engine';
 declare class Network {
     #private;
     private readonly state;
     private readonly myPeer;
     private readonly socket;
+    private readonly clientEventEmitter;
     sendTransport?: Transport;
     receiveTransport?: Transport;
     signalingDataProducer?: types.DataProducer;
@@ -20,16 +22,16 @@ declare class Network {
     private signalingConsumerId?;
     private preferRelay?;
     peersLoaded: boolean;
-    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, socket: SocketIO);
+    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, socket: SocketIO, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>);
     get isNetworkActive(): boolean;
     get observer(): EnhancedEventEmitter<NetworkObserverEvents>;
     get isSocketConnectionActive(): boolean;
     checkSocketConnectionActivity(): void;
     private removeEventListeners;
-    reset(): Promise<void>;
+    reset(): void;
     closeRemoteProducer(producerId: string): Promise<void>;
-    closeSendTransport(): Promise<void>;
-    closeReceiveTransport(): Promise<void>;
+    closeSendTransport(): void;
+    closeReceiveTransport(): void;
     closeConnectionTransport(): Promise<void>;
     private closeTransport;
     createSendTransport(mediasoupDevice: Device): Promise<LDTransport>;
@@ -58,7 +60,8 @@ declare class Network {
     }>;
     private getParsedTransportStats;
     private logTransportDetails;
-    private stopRestartIceAtempts;
+    private stopRestartIceAttempts;
     private subscribeCommonTransportEvents;
+    private checkTransportState;
 }
 export default Network;

package/dist/helpers/common.d.ts

@@ -7,7 +7,7 @@ declare global {
 type PlainObject = Record<string, unknown>;
 export declare function isObject(value: unknown): value is PlainObject;
 export declare function deepEqualObject(object1: PlainObject, object2: PlainObject): boolean;
-export declare function debounce<T extends (...args: any[]) => void>(callback: T, delay: number, immediate?: boolean): (this: unknown, ...args: Parameters<typeof callback>) => void;
+export declare function debounce<T extends (...args: unknown[]) => void>(callback: T, delay: number, immediate?: boolean): (this: unknown, ...args: Parameters<typeof callback>) => void;
 export declare function prepareLogLevel(level?: LogLevel): LogLevel;
 export declare function isAnalyticsActive(flag?: boolean): boolean;
 export declare function randomString(): string;

package/dist/helpers/retry.d.ts

@@ -9,6 +9,6 @@ export interface RetryOpts {
     onError?: (error: any) => Promise<void>;
 }
 declare const retryAsync: <ReturnType>(action: () => Promise<ReturnType>, opts?: RetryOpts) => Promise<ReturnType>;
-declare const retry: <ReturnType>(action: () => ReturnType, opts?: RetryOpts) => Promise<ReturnType>;
+declare const retry: <ReturnType extends () => ReturnType>(action: () => ReturnType, opts?: RetryOpts) => Promise<ReturnType>;
 export { retryAsync };
 export default retry;

package/dist/index.d.ts

@@ -9,13 +9,13 @@ import type { TransportsWebRTCStats } from './engine/WebRTCStats/types';
 declare class Client {
     #private;
     private readonly clientEventEmitter;
+    readonly canUseNoiseSuppression = true;
     constructor(params: ClientParams);
     get observer(): EnhancedEventEmitter<ClientObserverEvents>;
     get id(): string | undefined;
     get peers(): Peer[];
     get availableVideoDevices(): MediaDeviceInfo[];
     get availableAudioDevices(): MediaDeviceInfo[];
-    get canUseNoiseSuppression(): boolean;
     get effectsSDKInitialized(): boolean;
     detectDevices(force?: boolean): Promise<AvailableMediaDevices>;
     initEffectsSDK(): Promise<boolean>;
@@ -25,8 +25,8 @@ declare class Client {
     createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack>;
     createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack>;
     createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
-    createCustomAudioTrack(options: CreateCustomAudioOptions): Promise<Track>;
-    createCustomVideoTrack(options: CreateCustomVideoOptions): Promise<Track>;
+    createCustomAudioTrack(options: CreateCustomAudioOptions): Track;
+    createCustomVideoTrack(options: CreateCustomVideoOptions): Track;
     deleteTrack(track: Track): Promise<void>;
     loadPeers(role?: Role): Promise<void>;
     updateAppData(appData: Record<string, unknown>): Promise<void>;