@livedigital/client 2.6.0-force-disconnect-evt.1 → 2.7.0

package/dist/constants/events.d.ts

@@ -8,7 +8,6 @@ export declare const CLIENT_EVENTS: {
     channelEvent: string;
     peerJoined: string;
     peerLeft: string;
-    peersForceDisconnectRequired: string;
     channelRejoinRequired: string;
     devicesListUpdated: string;
 };
@@ -18,7 +17,6 @@ export declare const PEER_EVENTS: {
     connectionQualityChanged: string;
     trackStart: string;
     trackEnd: string;
-    forceDisconnectPeers: string;
 };
 export declare enum SocketIOEvents {
     Connected = "connected",

package/dist/engine/Logger.d.ts

@@ -1,11 +1,12 @@
-import debug from 'debug';
+import { LogMessageHandler } from '../types/common';
 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;
+    private readonly onLogMessage;
+    constructor(prefix?: string, onLogMessage?: LogMessageHandler);
+    debug(msg: any, ...meta: any[]): void;
+    warn(msg: any, ...meta: any[]): void;
+    error(msg: any, ...meta: any[]): void;
 }
 export default Logger;

package/dist/engine/Peer.d.ts

@@ -4,7 +4,7 @@ import Engine from './index';
 import PeerProducer from './PeerProducer';
 import PeerConsumer from './PeerConsumer';
 import PeerTrack from './media/tracks/PeerTrack';
-export interface PeerConstructor {
+interface PeerConstructor {
     id: string;
     channelIds: string[];
     appId: string;
@@ -38,6 +38,7 @@ declare class Peer {
     private readonly logger;
     private incomingConnectionQuality;
     private outgoingConnectionQuality;
+    private overallConnectionQuality;
     constructor({ id, channelIds, appId, loginDate, producers, engine, appData, uid, role, }: PeerConstructor);
     get observer(): EnhancedEventEmitter;
     get isMe(): boolean;

package/dist/engine/index.d.ts

@@ -1,4 +1,4 @@
-import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, Track } from '../types/common';
+import { CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, PeerResponse, Role, Track, LogMessageHandler } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
 import Peer from './Peer';
@@ -7,7 +7,7 @@ import Media from './media';
 declare type EngineParams = {
     clientEventEmitter: EnhancedEventEmitter;
     network: NetworkParams;
-    forceDisconnectTimeoutMs?: number;
+    onLogMessage?: LogMessageHandler;
 };
 declare class Engine {
     system: System;
@@ -23,7 +23,7 @@ declare class Engine {
     private channel?;
     private isRoomJoining;
     private logger;
-    private peersForceDisconnectEmitter;
+    private webRtcIssueDetector;
     constructor(params: EngineParams);
     private initialize;
     release(): Promise<void>;
@@ -54,7 +54,6 @@ declare class Engine {
     private waitForSocketConnection;
     private performJoin;
     private sendJoinChannelRequestWithRetry;
-    private handlePeerTrackLifetimeEvent;
     private sendJoinChannelRequest;
     get cahPublish(): boolean;
 }

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

@@ -1,7 +1,7 @@
 import { PreferredLayersParams, SpatialLayerParams, TrackLabel } from '../../../types/common';
 import PeerConsumer from '../../PeerConsumer';
 import Engine from '../../index';
-export interface PeerTrackConstructor {
+interface PeerTrackConstructor {
     mediaStreamTrack: MediaStreamTrack;
     label: TrackLabel;
     consumer?: PeerConsumer;

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

@@ -10,12 +10,14 @@ declare class SocketIO {
     private isConnected;
     private readonly _observer;
     private readonly logger;
+    private readonly knownDisconnectReasonsCodes;
     constructor();
     get observer(): EnhancedEventEmitter;
     get id(): string | undefined;
     connect(serverUrl: string): void;
     disconnect(): void;
     request(type: string, data?: {}): Promise<SocketResponse>;
+    private getDisconnectReasonCode;
     private setReconnectingAttempt;
 }
 export default SocketIO;

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

@@ -0,0 +1,4 @@
+declare class WIDRTCPeerConnection extends RTCPeerConnection {
+    constructor(configuration?: RTCConfiguration);
+}
+export default WIDRTCPeerConnection;

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

@@ -0,0 +1,18 @@
+import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
+import { WebRTCIssueDetectorConstructorParams } from './types';
+declare class WebRTCIssueDetector {
+    #private;
+    private readonly webrtcStats;
+    private readonly webrtcStatsPeerId;
+    private readonly getStatsInterval;
+    private readonly detectors;
+    readonly eventEmitter: WebRTCIssueEmitter;
+    constructor(params: WebRTCIssueDetectorConstructorParams);
+    watchNewPeerConnections(): void;
+    stopWatchingNewPeerConnections(): void;
+    resetWatchedPeerConnectionsList(): void;
+    handleNewPeerConnection(pc: RTCPeerConnection): void;
+    private emitIssues;
+    private detectIssues;
+}
+export default WebRTCIssueDetector;

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { EventType, EventPayload, IssueDetectorResult } from './types';
+export declare interface WebRTCIssueEmitter {
+    on(event: EventType, listener: (issues: IssueDetectorResult) => void): this;
+    emit(event: EventType, payload: EventPayload): boolean;
+}
+export declare class WebRTCIssueEmitter extends EventEmitter {
+}

package/dist/engine/wid/detectors/AvailableOutgoingBitrateIssueDetector.d.ts

@@ -0,0 +1,7 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class AvailableOutgoingBitrateIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+}
+export default AvailableOutgoingBitrateIssueDetector;

package/dist/engine/wid/detectors/FramesDroppedIssueDetector.d.ts

@@ -0,0 +1,8 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class FramesDroppedIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    private processData;
+}
+export default FramesDroppedIssueDetector;

package/dist/engine/wid/detectors/FramesEncodedSentIssueDetector.d.ts

@@ -0,0 +1,8 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class FramesEncodedSentIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    private processData;
+}
+export default FramesEncodedSentIssueDetector;

package/dist/engine/wid/detectors/NetworkIssueDetector.d.ts

@@ -0,0 +1,8 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class NetworkIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    private processData;
+}
+export default NetworkIssueDetector;

package/dist/engine/wid/detectors/NetworkMediaSyncIssueDetector.d.ts

@@ -0,0 +1,8 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class NetworkMediaSyncIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    private processData;
+}
+export default NetworkMediaSyncIssueDetector;

package/dist/engine/wid/detectors/QualityLimitationsIssueDetector.d.ts

@@ -0,0 +1,8 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { IssueDetector, IssueDetectorResult } from '../types';
+declare class QualityLimitationsIssueDetector implements IssueDetector {
+    #private;
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    private processData;
+}
+export default QualityLimitationsIssueDetector;

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

@@ -0,0 +1,39 @@
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+export interface WIDWindow {
+    wid: {
+        handleNewPeerConnection(pc: RTCPeerConnection): void;
+    };
+}
+export declare type IssueDetectorResult = IssuePayload[];
+export interface IssueDetector {
+    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+}
+export declare enum EventType {
+    Issue = "issue"
+}
+export declare type EventPayload = IssueDetectorResult;
+export declare type WebRTCIssueDetectorConstructorParams = {
+    onIssue?: (payload: IssueDetectorResult) => void;
+};
+export declare enum IssueType {
+    Network = "network",
+    CPU = "cpu",
+    Server = "server"
+}
+export declare enum IssueReason {
+    NetworkQuality = "network-quality",
+    NetworkMediaLatency = "network-media-latency",
+    NetworkMediaSyncFailure = "network-media-sync-failure",
+    OutboundNetworkThroughput = "outbound-network-throughput",
+    InboundNetworkThroughput = "inbound-network-throughput",
+    EncoderCPUThrottling = "encoder-cpu-throttling",
+    DecoderCPUThrottling = "decoder-cpu-throttling",
+    ServerIssue = "server-issue"
+}
+export declare type IssuePayload = {
+    type: IssueType;
+    reason: IssueReason;
+    ssrc?: number;
+    iceCandidate?: string;
+    debug?: string;
+};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, Track } from './types/common';
+import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role, Track, LogMessageHandler } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
@@ -6,7 +6,7 @@ declare type ClientParams = {
     network?: {
         loadbalancer?: LoadBalancerApiClientParams;
     };
-    forceDisconnectTimeoutMs?: number;
+    onLogMessage?: LogMessageHandler;
 };
 declare class Client {
     private readonly engine;