@livedigital/client 2.12.0 → 2.14.1

package/dist/constants/common.d.ts

@@ -0,0 +1,11 @@
+import { LogLevel } from '../types/common';
+export declare const LOG_LEVEL_ERROR: LogLevel;
+export declare const LOG_LEVEL_WARN: LogLevel;
+export declare const LOG_LEVEL_INFO: LogLevel;
+export declare const LOG_LEVEL_DEBUG: LogLevel;
+export declare const LogLevels: {
+    Error: 3;
+    Warn: 4;
+    Info: 6;
+    Debug: 7;
+};

package/dist/engine/DefaultEngineDependenciesFactory.d.ts

@@ -1,4 +1,3 @@
-import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Network from './network';
 import System from './system';
 import Media from './media';
@@ -6,10 +5,10 @@ import ChannelEventHandler from './handlers/ChannelEventHandler';
 import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
-import { CreateIssueDetectorParams, CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
+import { CreateIssueDetectorParams, CreateMediaParams, CreateNetworkParams, CreateSystemParams, EngineDependenciesFactory } from '../types/engine';
 declare class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
-    createSystem(clientEventEmitter: EnhancedEventEmitter): System;
-    createMedia(): Media;
+    createSystem(params: CreateSystemParams): System;
+    createMedia(params: CreateMediaParams): Media;
     createNetwork(params: CreateNetworkParams): Network;
     createChannelEventHandler(engine: Engine): ChannelEventHandler;
     createMediaSoupEventHandler(engine: Engine): MediaSoupEventHandler;

package/dist/engine/Logger.d.ts

@@ -1,11 +1,18 @@
-import { LogMessageHandler } from '../types/common';
+import { LogLevel, LogMessageHandler } from '../types/common';
+export declare type LoggerConstructorParams = {
+    namespace: string;
+    logLevel: LogLevel;
+    onLogMessage?: LogMessageHandler;
+};
 declare class Logger {
+    #private;
     private readonly _debug;
+    private readonly _info;
     private readonly _warn;
     private readonly _error;
-    private readonly onLogMessage;
-    constructor(prefix?: string, onLogMessage?: LogMessageHandler);
+    constructor(params: LoggerConstructorParams);
     debug(msg: any, ...meta: any[]): void;
+    info(msg: any, ...meta: any[]): void;
     warn(msg: any, ...meta: any[]): void;
     error(msg: any, ...meta: any[]): void;
 }

package/dist/engine/PeerConsumer.d.ts

@@ -1,6 +1,10 @@
 import { MediaKind, RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
 import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
-import { ConsumerData, SpatialLayerParams } from '../types/common';
+import { ConsumerData, LogLevel, SpatialLayerParams } from '../types/common';
+export declare type PeerConsumerConstructorParams = {
+    consumer: MediasoupConsumer;
+    logLevel: LogLevel;
+};
 declare class PeerConsumer {
     score: number;
     producerScore: number;
@@ -18,7 +22,7 @@ declare class PeerConsumer {
     readonly appData: ConsumerData;
     private readonly consumer;
     private readonly logger;
-    constructor(consumer: MediasoupConsumer);
+    constructor(params: PeerConsumerConstructorParams);
     get paused(): boolean;
     pause(): void;
     resume(): void;

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

@@ -2,7 +2,9 @@ import Engine from '../index';
 declare class MediaSoupEventHandler {
     private readonly engine;
     private readonly logger;
+    private readonly queue;
     constructor(engine: Engine);
     subscribeToEvents(): void;
+    private handleProducerSetMaxSpatialLayer;
 }
 export default MediaSoupEventHandler;

package/dist/engine/index.d.ts

@@ -1,21 +1,27 @@
-import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, Track, LogMessageHandler } from '../types/common';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, Track, LogMessageHandler, LogLevel } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
 import Peer from './Peer';
 import Network from './network';
 import Media from './media';
-import { CreateNetworkParams, EngineDependenciesFactory } from '../types/engine';
+import { EngineDependenciesFactory, IssuesHandler } from '../types/engine';
+import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 declare type EngineParams = {
     clientEventEmitter: EnhancedEventEmitter;
-    network: CreateNetworkParams;
-    onLogMessage?: LogMessageHandler;
+    network: {
+        loadbalancer: LoadBalancerApiClientParams;
+    };
     dependenciesFactory: EngineDependenciesFactory;
+    logLevel?: LogLevel;
+    onLogMessage?: LogMessageHandler;
+    onIssues?: IssuesHandler;
 };
 declare class Engine {
     system: System;
     network: Network;
     media: Media;
     clientEventEmitter: EnhancedEventEmitter;
+    logLevel: LogLevel;
     private readonly peersRepository;
     private channelEventsHandler;
     private mediaSoupEventsHandler;

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

@@ -1,11 +1,13 @@
 import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
 import { CreateScreenVideoTrackOptions, CreateVideoTrackParams, Track } from '../../types/common';
+import { CreateMediaParams } from '../../types/engine';
 declare class Media {
     #private;
     isDeviceLoaded: boolean;
     private device?;
     private tracks;
+    constructor(params: CreateMediaParams);
     get mediasoupDevice(): Device;
     loadDevice(routerRtpCapabilities: RtpCapabilities): Promise<void>;
     getTrackCodec(track: Track): RtpCodecCapability | undefined;

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

@@ -1,14 +1,18 @@
 import { Producer } from 'mediasoup-client/lib/Producer';
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import { EncoderConfig, TrackLabel } from '../../../types/common';
+import { EncoderConfig, LogLevel, TrackLabel } from '../../../types/common';
 import Logger from '../../Logger';
+export declare type BaseTrackConstructorParams = {
+    mediaStreamTrack: MediaStreamTrack;
+    logLevel: LogLevel;
+};
 declare class BaseTrack {
     #private;
     protected encoderConfig: EncoderConfig;
     private producer?;
     private label;
     protected logger: Logger;
-    constructor(mediaStreamTrack: MediaStreamTrack);
+    constructor(params: BaseTrackConstructorParams);
     get mediaStreamTrack(): MediaStreamTrack;
     get id(): string;
     get kind(): MediaKind;

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

@@ -1,6 +1,9 @@
 import { Socket } from 'socket.io-client';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { SocketResponse } from '../../types/common';
+import { LogLevel, SocketResponse } from '../../types/common';
+export declare type SocketIOConstructorParams = {
+    logLevel: LogLevel;
+};
 declare class SocketIO {
     connection?: Socket;
     connectionError?: string;
@@ -11,7 +14,7 @@ declare class SocketIO {
     private readonly _observer;
     private readonly logger;
     private readonly knownDisconnectReasonsCodes;
-    constructor();
+    constructor(params: SocketIOConstructorParams);
     get observer(): EnhancedEventEmitter;
     get id(): string | undefined;
     connect(serverUrl: string): void;

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

@@ -1,9 +1,11 @@
 import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
 import { Device } from 'mediasoup-client';
 import SocketIO from './Socket';
+import { LogLevel } from '../../types/common';
 import LoadBalancerApiClient from './LoadBalancerClient';
 export declare type NetworkParams = {
     socketClient: SocketIO;
+    logLevel: LogLevel;
     loadBalancerApiClient: LoadBalancerApiClient;
 };
 declare class Network {

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

@@ -1,7 +1,5 @@
+import { CreateSystemParams } from '../../types/engine';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-declare type SystemParams = {
-    clientEventEmitter: EnhancedEventEmitter;
-};
 declare class System {
     isEnableVideoDevicesLock: boolean;
     isEnableAudioDevicesLock: boolean;
@@ -11,7 +9,7 @@ declare class System {
     private isMediaDevicesAccessGranted;
     clientEventEmitter: EnhancedEventEmitter;
     private readonly logger;
-    constructor(params: SystemParams);
+    constructor(params: CreateSystemParams);
     setIsEnableVideoDevicesLock(value: boolean): void;
     setIsEnableAudioDevicesLock(value: boolean): void;
     setAvailableVideoDevices(availableVideoDevices: MediaDeviceInfo[]): void;

package/dist/engine/wid/types.d.ts

@@ -13,7 +13,7 @@ export declare enum EventType {
 }
 export declare type EventPayload = IssueDetectorResult;
 export declare type WebRTCIssueDetectorConstructorParams = {
-    onIssue?: (payload: IssueDetectorResult) => void;
+    onIssues?: (payload: IssueDetectorResult) => void;
 };
 export declare enum IssueType {
     Network = "network",

package/dist/helpers/retry.d.ts

@@ -1,8 +1,10 @@
+import Logger from '../engine/Logger';
 export declare type RetryOpts = {
     maxRetries?: number;
     minBackoffDelayMs?: number;
     maxBackoffDelayMs?: number;
     actionName?: string;
+    logger?: Logger;
 };
 declare const retryAsync: <ReturnType_1>(action: () => Promise<ReturnType_1>, opts?: RetryOpts) => Promise<ReturnType_1>;
 declare const retry: <ReturnType_1>(action: () => ReturnType_1, opts?: RetryOpts) => Promise<ReturnType_1>;

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, LogMessageHandler, Role, Track } from './types/common';
+import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, LogLevel, LogMessageHandler, Role, Track } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
+import { IssuesHandler } from './types/engine';
 declare type ClientParams = {
     observer?: EnhancedEventEmitter;
     network?: {
         loadbalancer?: LoadBalancerApiClientParams;
     };
+    logLevel: LogLevel;
     onLogMessage?: LogMessageHandler;
+    onIssues?: IssuesHandler;
 };
 declare class Client {
     private readonly engine;