@livedigital/client 2.4.2 → 2.4.3

package/dist/EnhancedEventEmitter.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+declare class EnhancedEventEmitter extends EventEmitter {
+    constructor();
+    safeEmit(event: string, ...args: unknown[]): boolean;
+}
+export default EnhancedEventEmitter;

package/dist/constants/events.d.ts

@@ -0,0 +1,54 @@
+export declare const CHANNEL_EVENTS: {
+    channelEvent: string;
+    channelJoin: string;
+    channelGetPeers: string;
+    channelLeave: string;
+};
+export declare const CLIENT_EVENTS: {
+    channelEvent: string;
+    peerJoined: string;
+    peerLeft: string;
+    channelRejoinRequired: string;
+    devicesListUpdated: string;
+};
+export declare const PEER_EVENTS: {
+    mediaPublished: string;
+    mediaUnPublished: string;
+    connectionQualityChanged: string;
+    trackStart: string;
+    trackEnd: string;
+};
+export declare enum SocketIOEvents {
+    Connected = "connected",
+    Reconnecting = "reconnecting",
+    Reconnected = "reconnected",
+    Disconnected = "disconnected",
+    Reconnect = "reconnect",
+    Error = "error"
+}
+export declare const MEDIASOUP_EVENTS: {
+    newProducer: string;
+    producerClose: string;
+    pauseProducer: string;
+    resumeProducer: string;
+    producerScoreChanged: string;
+    producerSetMaxSpatialLayer: string;
+    producerRequestMaxSpatialLayer: string;
+    createConsumer: string;
+    closeConsumer: string;
+    pauseConsumer: string;
+    resumeConsumer: string;
+    consumerScoreChanged: string;
+    consumerChangePreferredLayers: string;
+    setConsumerPriority: string;
+    transportCreate: string;
+    transportClose: string;
+    transportConnect: string;
+    transportProduce: string;
+    transportStateChange: string;
+    transportGetIceParameters: string;
+};
+export declare const MEDIASOUP_TRANSPORT_EVENTS: {
+    connect: string;
+    produce: string;
+};

package/dist/constants/simulcastEncodings.d.ts

@@ -0,0 +1,9 @@
+export declare const WEBCAM_SIMULCAST_ENCODINGS: {
+    scaleResolutionDownBy: number;
+    maxBitrate: number;
+    maxFramerate: number;
+}[];
+export declare const SCREEN_SHARING_SIMULCAST_ENCODINGS: {
+    maxBitrate: number;
+    dtx: boolean;
+}[];

package/dist/constants/videoConstrains.d.ts

@@ -0,0 +1,18 @@
+export declare const VIDEO_CONSTRAINS: {
+    qvga: {
+        width: number;
+        height: number;
+    };
+    vga: {
+        width: number;
+        height: number;
+    };
+    hd: {
+        width: number;
+        height: number;
+    };
+    fullhd: {
+        width: number;
+        height: number;
+    };
+};

package/dist/engine/Logger.d.ts

@@ -0,0 +1,11 @@
+import debug from 'debug';
+declare class Logger {
+    private readonly _debug;
+    private readonly _warn;
+    private readonly _error;
+    constructor(prefix?: string);
+    get debug(): debug.Debugger;
+    get warn(): debug.Debugger;
+    get error(): debug.Debugger;
+}
+export default Logger;

package/dist/engine/Peer.d.ts

@@ -0,0 +1,56 @@
+import { ProducerData, ConnectionQuality, PayloadOfPublishedMedia, Role } from '../types/common';
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import Engine from './index';
+import PeerProducer from './PeerProducer';
+import PeerConsumer from './PeerConsumer';
+import PeerTrack from './media/tracks/PeerTrack';
+interface PeerConstructor {
+    id: string;
+    channelIds: string[];
+    appId: string;
+    producers: ProducerData[];
+    videoConsumer?: PeerConsumer;
+    audioConsumer?: PeerConsumer;
+    engine: Engine;
+    soundLevel?: number;
+    loginDate: Date;
+    uid?: string;
+    appData?: Record<string, unknown>;
+    role: Role;
+}
+export declare enum ScoreThreshold {
+    BAD = 4,
+    MEDIUM = 6,
+    GOOD = 10
+}
+declare class Peer {
+    id: string;
+    channelIds: string[];
+    appId: string;
+    loginDate: Date;
+    uid?: string;
+    appData: Record<string, unknown>;
+    role: Role;
+    private producers;
+    readonly tracks: Map<string, PeerTrack>;
+    private readonly engine;
+    private readonly _observer;
+    private readonly logger;
+    private incomingConnectionQuality;
+    private outgoingConnectionQuality;
+    constructor({ id, channelIds, appId, loginDate, producers, engine, appData, uid, role, }: PeerConstructor);
+    get observer(): EnhancedEventEmitter;
+    get isMe(): boolean;
+    get publishedMedia(): PayloadOfPublishedMedia[];
+    subscribe(producerId: string): Promise<void>;
+    private createConsumer;
+    private handleNewProducer;
+    private handlePeerEvents;
+    private emitConnectionQuality;
+    static getConnectionQualityByScore(score: number): ConnectionQuality;
+    private getAllConsumers;
+    getAllProducers(): PeerProducer[];
+    getConsumerByProducerId(producerId: string): PeerConsumer | undefined;
+    getConsumerById(id: string): PeerConsumer | undefined;
+}
+export default Peer;

package/dist/engine/PeerConsumer.d.ts

@@ -0,0 +1,37 @@
+import { MediaKind, RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
+import { ConsumerData, SpatialLayerParams } from '../types/common';
+declare class PeerConsumer {
+    score: number;
+    producerScore: number;
+    spatialLayers: number;
+    temporalLayers: number;
+    currentSpatialLayer: number;
+    currentTemporalLayer: number;
+    requestedSpatialLayer?: number;
+    currentMaxSpatialLayer: number;
+    availableSpatialLayers: SpatialLayerParams[];
+    currentSpatialLayerParams?: SpatialLayerParams;
+    readonly id: string;
+    readonly kind: MediaKind;
+    readonly producerId: string;
+    readonly appData: ConsumerData;
+    private readonly consumer;
+    private readonly logger;
+    constructor(consumer: MediasoupConsumer);
+    get paused(): boolean;
+    pause(): void;
+    resume(): void;
+    close(): void;
+    get isVideo(): boolean;
+    get isAudio(): boolean;
+    parseScalabilityMode(): void;
+    setSpatialLayersParams(): void;
+    setCurrentSpatialLayerParams(): void;
+    parseSpatialLayerParams(encoding: RtpEncodingParameters): SpatialLayerParams;
+    setCurrentSpatialLayer(currentSpatialLayer: number): void;
+    setCurrentTemporalLayer(currentTemporalLayer: number): void;
+    setRequestedSpatialLayer(spatialLayer: number | undefined): void;
+    setCurrentMaxSpatialLayer(spatialLayer: number): void;
+}
+export default PeerConsumer;

package/dist/engine/PeerProducer.d.ts

@@ -0,0 +1,15 @@
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import { ProducerData, TrackLabel, TrackTransformParams } from '../types/common';
+declare class PeerProducer {
+    readonly id: string;
+    readonly kind: MediaKind;
+    readonly peerId: string;
+    readonly label: TrackLabel;
+    readonly encodings: RtpEncodingParameters[];
+    readonly trackTransformParams: TrackTransformParams;
+    readonly maxSpatialLayer: number;
+    score: number;
+    constructor(params: ProducerData);
+}
+export default PeerProducer;

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

@@ -0,0 +1,8 @@
+import Engine from '../index';
+declare class ChannelEventHandler {
+    private readonly engine;
+    private readonly logger;
+    constructor(engine: Engine);
+    subscribeToEvents(): void;
+}
+export default ChannelEventHandler;

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

@@ -0,0 +1,8 @@
+import Engine from '../index';
+declare class MediaSoupEventHandler {
+    private readonly engine;
+    private readonly logger;
+    constructor(engine: Engine);
+    subscribeToEvents(): void;
+}
+export default MediaSoupEventHandler;

package/dist/engine/index.d.ts

@@ -0,0 +1,54 @@
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, Track } from '../types/common';
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import System from './system';
+import Peer from './Peer';
+import Network, { NetworkParams } from './network';
+import Media from './media';
+declare type EngineParams = {
+    clientEventEmitter: EnhancedEventEmitter;
+    network: NetworkParams;
+};
+declare class Engine {
+    system: System;
+    network: Network;
+    media: Media;
+    clientEventEmitter: EnhancedEventEmitter;
+    private readonly peersRepository;
+    private channelEventsHandler;
+    private mediaSoupEventsHandler;
+    private initialized;
+    private isJoined;
+    private app?;
+    private channel?;
+    private isRoomJoining;
+    private logger;
+    constructor(params: EngineParams);
+    private initialize;
+    release(): Promise<void>;
+    private pauseRemoteProducer;
+    private resumeRemoteProducer;
+    private watchSocketState;
+    get peers(): Peer[];
+    get hostPeers(): Peer[];
+    get audiencePeers(): Peer[];
+    get mySocketId(): string | undefined;
+    join(params: JoinChannelParams): Promise<void>;
+    loadPeers(role?: Role): Promise<void>;
+    setPeer(peerData: PeerResponse): Peer;
+    removePeer(peerId: string): void;
+    pause(track: Track): Promise<void>;
+    resume(track: Track): Promise<void>;
+    createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track>;
+    createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track>;
+    createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
+    publish(tracks: Track | Track[]): Promise<void>;
+    unpublish(tracks?: Track | Track[]): Promise<void>;
+    deleteTrack(tracks: Track): void;
+    get channelId(): string | undefined;
+    get appId(): string | undefined;
+    private getAvailableNode;
+    private waitForSocketConnection;
+    private performJoin;
+    get cahPublish(): boolean;
+}
+export default Engine;

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

@@ -0,0 +1,20 @@
+import { Device } from 'mediasoup-client';
+import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
+import { CreateScreenVideoTrackOptions, CreateVideoTrackParams, Track } from '../../types/common';
+declare class Media {
+    #private;
+    isDeviceLoaded: boolean;
+    private device?;
+    private tracks;
+    get mediasoupDevice(): Device;
+    loadDevice(routerRtpCapabilities: RtpCapabilities): Promise<void>;
+    getTrackCodec(track: Track): RtpCodecCapability | undefined;
+    private createTracks;
+    createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]>;
+    createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]>;
+    deleteTrack(track: Track): void;
+    getAllTracks(): Track[];
+    static getScreenVideoTrackParams(options?: CreateScreenVideoTrackOptions): CreateVideoTrackParams;
+    static getCameraVideoTrackParams(options?: CreateScreenVideoTrackOptions): CreateVideoTrackParams;
+}
+export default Media;

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

@@ -0,0 +1,9 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { AudioEncoderConfig } from '../../../types/common';
+import BaseTrack from './BaseTrack';
+import TrackWithCodecOptions from './TrackWithCodecOptions';
+declare class AudioTrack extends BaseTrack implements TrackWithCodecOptions {
+    getEncoderConfig(): AudioEncoderConfig;
+    getCodecOptions(): ProducerCodecOptions;
+}
+export default AudioTrack;

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

@@ -0,0 +1,26 @@
+import { Producer } from 'mediasoup-client/lib/Producer';
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import { EncoderConfig, TrackLabel } from '../../../types/common';
+import Logger from '../../Logger';
+declare class BaseTrack {
+    #private;
+    protected encoderConfig: EncoderConfig;
+    private producer?;
+    private label;
+    protected logger: Logger;
+    constructor(mediaStreamTrack: MediaStreamTrack);
+    get mediaStreamTrack(): MediaStreamTrack;
+    get id(): string;
+    get kind(): MediaKind;
+    get producerId(): string | undefined;
+    get isPublished(): boolean;
+    getLabel(): TrackLabel;
+    setLabel(label: TrackLabel): void;
+    setEncoderConfig(encoderConfig: EncoderConfig): void;
+    getEncoderConfig(): EncoderConfig;
+    setProducer(producer: Producer): void;
+    getProducer(): Producer | undefined;
+    closeProducer(): void;
+    setPriority(priority: RTCPriorityType): Promise<void>;
+}
+export default BaseTrack;

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

@@ -0,0 +1,29 @@
+import { PreferredLayersParams, SpatialLayerParams, TrackLabel } from '../../../types/common';
+import PeerConsumer from '../../PeerConsumer';
+import Engine from '../../index';
+interface PeerTrackConstructor {
+    mediaStreamTrack: MediaStreamTrack;
+    label: TrackLabel;
+    consumer?: PeerConsumer;
+    engine: Engine;
+}
+declare class PeerTrack {
+    #private;
+    readonly mediaStreamTrack: MediaStreamTrack;
+    readonly label: TrackLabel;
+    readonly consumer?: PeerConsumer;
+    constructor(payload: PeerTrackConstructor);
+    get consumerId(): string | undefined;
+    get currentSpatialLayer(): number;
+    close(): void;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    setPriority(priority: number): Promise<void>;
+    private setConsumerPriority;
+    private pauseRemoteConsumer;
+    private resumeRemoteConsumer;
+    requestVideoPreferredLayers({ spatialLayer, temporalLayer }: PreferredLayersParams): Promise<void>;
+    getVideoAvailableLayers(): SpatialLayerParams[] | undefined;
+    private requestMaxSpatialLayer;
+}
+export default PeerTrack;

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

@@ -0,0 +1,4 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+export default interface TrackWithCodecOptions {
+    getCodecOptions(): ProducerCodecOptions;
+}

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

@@ -0,0 +1,4 @@
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+export default interface TrackWithEncodings {
+    getEncodings(): RtpEncodingParameters[];
+}

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

@@ -0,0 +1,17 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+import { VideoCodec, VideoEncoderConfig } from '../../../types/common';
+import BaseTrack from './BaseTrack';
+import TrackWithCodecOptions from './TrackWithCodecOptions';
+import TrackWithEncodings from './TrackWithEncodings';
+declare class VideoTrack extends BaseTrack implements TrackWithCodecOptions, TrackWithEncodings {
+    transformParams: {};
+    getEncoderConfig(): VideoEncoderConfig;
+    getCodecOptions(): ProducerCodecOptions;
+    getPreferredCodec(): VideoCodec;
+    getEncodings(): RtpEncodingParameters[];
+    setTransformParams(transformParams: {}): void;
+    setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+    getMaxSpatialLayer(): number | undefined;
+}
+export default VideoTrack;

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

@@ -0,0 +1,13 @@
+import { GetNodeRequest, GetNodeResponse } from '../../types/network';
+export declare type LoadBalancerApiClientParams = {
+    baseURL?: string;
+    timeout?: number;
+    customNode?: GetNodeResponse;
+};
+declare class LoadBalancerApiClient {
+    private readonly api;
+    private customNode?;
+    constructor(params: LoadBalancerApiClientParams);
+    getNode(params: GetNodeRequest): Promise<GetNodeResponse>;
+}
+export default LoadBalancerApiClient;

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

@@ -0,0 +1,20 @@
+import { Socket } from 'socket.io-client';
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import { SocketResponse } from '../../types/common';
+declare class SocketIO {
+    connection?: Socket;
+    connectionError?: string;
+    disconnectReason?: string;
+    reconnectingAttempt: number;
+    private serverUrl?;
+    private isConnected;
+    private readonly _observer;
+    private readonly logger;
+    constructor();
+    get observer(): EnhancedEventEmitter;
+    get id(): string | undefined;
+    connect(serverUrl: string): void;
+    disconnect(): void;
+    request(type: string, data?: {}): Promise<SocketResponse>;
+}
+export default SocketIO;

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

@@ -0,0 +1,24 @@
+import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
+import { Device } from 'mediasoup-client';
+import SocketIO from './Socket';
+import LoadBalancerApiClient, { LoadBalancerApiClientParams } from './LoadBalancerClient';
+export declare type NetworkParams = {
+    loadbalancer: LoadBalancerApiClientParams;
+};
+declare class Network {
+    readonly socket: SocketIO;
+    readonly loadBalancerClient: LoadBalancerApiClient;
+    sendTransport?: Transport;
+    receiveTransport?: Transport;
+    private readonly logger;
+    constructor(params: NetworkParams);
+    closeRemoteProducer(producerId: string): Promise<void>;
+    closeSendTransport(): Promise<void>;
+    closeReceiveTransport(): Promise<void>;
+    private closeTransport;
+    createSendTransport(mediasoupDevice: Device): Promise<void>;
+    createRecvTransport(mediasoupDevice: Device): Promise<void>;
+    getIceParameters(transport: Transport): Promise<IceParameters>;
+    restartIce(transport: Transport): Promise<void>;
+}
+export default Network;

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

@@ -0,0 +1,24 @@
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+declare type SystemParams = {
+    clientEventEmitter: EnhancedEventEmitter;
+};
+declare class System {
+    isEnableVideoDevicesLock: boolean;
+    isEnableAudioDevicesLock: boolean;
+    isDevicesDetected: boolean;
+    availableVideoDevices: MediaDeviceInfo[];
+    availableAudioDevices: MediaDeviceInfo[];
+    private isMediaDevicesAccessGranted;
+    clientEventEmitter: EnhancedEventEmitter;
+    private readonly logger;
+    constructor(params: SystemParams);
+    setIsEnableVideoDevicesLock(value: boolean): void;
+    setIsEnableAudioDevicesLock(value: boolean): void;
+    setAvailableVideoDevices(availableVideoDevices: MediaDeviceInfo[]): void;
+    setAvailableAudioDevices(availableAudioDevices: MediaDeviceInfo[]): void;
+    requestMediaDevicesAccess(): Promise<void>;
+    refreshAvailableMediaDevicesList(): Promise<void>;
+    detectDevices(): Promise<void>;
+    listenDevices(): void;
+}
+export default System;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, Track } from './types/common';
+import EnhancedEventEmitter from './EnhancedEventEmitter';
+import Peer from './engine/Peer';
+import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
+declare type ClientParams = {
+    network?: {
+        loadbalancer?: LoadBalancerApiClientParams;
+    };
+};
+declare class Client {
+    private readonly engine;
+    private readonly _observer;
+    constructor(params: ClientParams);
+    get observer(): EnhancedEventEmitter;
+    get id(): string | undefined;
+    get peers(): Peer[];
+    get availableVideoDevices(): MediaDeviceInfo[];
+    get availableAudioDevices(): MediaDeviceInfo[];
+    detectDevices(): Promise<AvailableMediaDevices>;
+    join(params: JoinChannelParams): Promise<void>;
+    leave(): Promise<void>;
+    publish(tracks: Track | Track[]): Promise<void>;
+    unpublish(tracks?: Track | Track[]): Promise<void>;
+    pause(track: Track): Promise<void>;
+    resume(track: Track): Promise<void>;
+    createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track>;
+    createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track>;
+    createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
+    deleteTrack(track: Track): void;
+    loadPeers(role?: Role): Promise<void>;
+}
+export default Client;