@livedigital/client 2.26.0-stop-streams.2 → 2.26.0

package/dist/types/common.d.ts

@@ -304,10 +304,6 @@ export declare type UpdatePeerAppDataPayload = {
     peerId: string;
     appData: Record<string, unknown>;
 };
-export declare type CreateTracksPayload = {
-    mediaStreamTracks: MediaStreamTrack[];
-    constraints: MediaStreamConstraints;
-};
 export declare type TrackPublishParams = {
     keyFrameRequestDelay?: number;
 };

package/dist/types/engine.d.ts

@@ -1,3 +1,4 @@
+import WebRTCIssueDetector, { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from '../engine/system';
 import Media from '../engine/media';
@@ -5,9 +6,7 @@ import Network from '../engine/network';
 import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { Logger, LogLevel } from './common';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.26.0-stop-streams.2",
+  "version": "2.26.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -47,7 +47,8 @@
     "mediasoup-client": "^3.6.50",
     "qs": "^6.9.6",
     "serialize-error": "^7.0.1",
-    "socket.io-client": "^4.3.0"
+    "socket.io-client": "^4.3.0",
+    "webrtc-issue-detector": "^1.3.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^19.0.0",

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -1,10 +1,24 @@
+import WebRTCIssueDetector, {
+  QualityLimitationsIssueDetector,
+  FramesDroppedIssueDetector,
+  FramesEncodedSentIssueDetector,
+  InboundNetworkIssueDetector,
+  OutboundNetworkIssueDetector,
+  NetworkMediaSyncIssueDetector,
+  AvailableOutgoingBitrateIssueDetector,
+  VideoCodecMismatchDetector,
+  CompositeRTCStatsParser,
+  WebRTCIssueEmitter,
+  NetworkScoresCalculator,
+  PeriodicWebRTCStatsReporter,
+  RTCStatsParser,
+} from 'webrtc-issue-detector';
 import Network from './network';
 import System from './system';
 import Media from './media';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
 import Engine from './index';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import {
   CreateIssueDetectorParams,
   CreateMediaParams,
@@ -14,19 +28,6 @@ import {
 } from '../types/engine';
 import SocketIO from './network/Socket';
 import LoadBalancerApiClient from './network/LoadBalancerClient';
-import NetworkScoresCalculator from './wid/lib/NetworkScoresCalculator';
-import QualityLimitationsIssueDetector from './wid/detectors/QualityLimitationsIssueDetector';
-import FramesDroppedIssueDetector from './wid/detectors/FramesDroppedIssueDetector';
-import FramesEncodedSentIssueDetector from './wid/detectors/FramesEncodedSentIssueDetector';
-import InboundNetworkIssueDetector from './wid/detectors/InboundNetworkIssueDetector';
-import OutboundNetworkIssueDetector from './wid/detectors/OutboundNetworkIssueDetector';
-import NetworkMediaSyncIssueDetector from './wid/detectors/NetworkMediaSyncIssueDetector';
-import AvailableOutgoingBitrateIssueDetector from './wid/detectors/AvailableOutgoingBitrateIssueDetector';
-import VideoCodecMismatchDetector from './wid/detectors/VideoCodecMismatchDetector';
-import CompositeRTCStatsParser from './wid/lib/parser/CompositeRTCStatsParser';
-import RTCStatsParser from './wid/lib/parser/RTCStatsParser';
-import PeriodicWebRTCStatsReporter from './wid/lib/PeriodicWebRTCStatsReporter';
-import { WebRTCIssueEmitter } from './wid/WebRTCIssueEmitter';
 
 /* eslint-disable class-methods-use-this */
 class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {

package/src/engine/index.ts

@@ -1,4 +1,5 @@
 import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
+import WebRTCIssueDetector from 'webrtc-issue-detector';
 import {
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
@@ -26,7 +27,6 @@ import {
 import { GetNodeRequest } from '../types/network';
 import VideoTrack from './media/tracks/VideoTrack';
 import PeerTrack from './media/tracks/PeerTrack';
-import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
 import { EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler } from '../types/engine';
 import { LogLevels } from '../constants/common';
@@ -161,7 +161,7 @@ class Engine {
       const { state, code } = evt;
       this.clientEventEmitter.emit(state, { code });
 
-      if (state === SocketIOEvents.Reconnecting) {
+      if (state === SocketIOEvents.Reconnected) {
         this.network.socket.disconnect();
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
       }
@@ -457,7 +457,20 @@ class Engine {
 
   private watchClientEvents(): void {
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackProduced, (track: Track) => {
-      this.createSelfPeerTrack(track);
+      const myPeer = this.peersRepository.get(<string> this.mySocketId);
+      if (!myPeer) {
+        return;
+      }
+
+      const peerTrack = new PeerTrack({
+        mediaStreamTrack: track.mediaStreamTrack,
+        label: track.getLabel(),
+        engine: this,
+        isPaused: track.isPaused,
+        peerEventEmitter: myPeer.observer,
+      });
+
+      myPeer.tracks.set(peerTrack.label, peerTrack);
     });
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackUnproduced, (track: Track) => {
@@ -468,29 +481,13 @@ class Engine {
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackPaused, (track: Track) => {
       const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.close();
+      peerTrack?.pause();
     });
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackResumed, (track: Track) => {
-      this.createSelfPeerTrack(track);
-    });
-  }
-
-  private createSelfPeerTrack(track: Track): void {
-    const myPeer = this.peersRepository.get(<string> this.mySocketId);
-    if (!myPeer) {
-      return;
-    }
-
-    const peerTrack = new PeerTrack({
-      mediaStreamTrack: track.mediaStreamTrack,
-      label: track.getLabel(),
-      engine: this,
-      isPaused: track.isPaused,
-      peerEventEmitter: myPeer.observer,
+      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
+      peerTrack?.resume();
     });
-
-    myPeer.tracks.set(peerTrack.label, peerTrack);
   }
 }
 

package/src/engine/media/index.ts

@@ -3,11 +3,7 @@ import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpPar
 import VideoTrack from './tracks/VideoTrack';
 import AudioTrack from './tracks/AudioTrack';
 import {
-  CreateScreenVideoTrackOptions,
-  CreateTracksPayload,
-  CreateVideoTrackParams,
-  LogLevel,
-  Track,
+  CreateScreenVideoTrackOptions, CreateVideoTrackParams, LogLevel, Track,
 } from '../../types/common';
 import Logger from '../Logger';
 import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
@@ -15,7 +11,6 @@ import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '
 import { CreateMediaParams } from '../../types/engine';
 import Engine from '../index';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
 
 class Media {
   public isDeviceLoaded = false;
@@ -32,8 +27,6 @@ class Media {
 
   readonly #clientEventEmitter: EnhancedEventEmitter;
 
-  readonly #mediaStreamTrackManager: MediaStreamTrackManager;
-
   constructor(params: CreateMediaParams) {
     this.#logLevel = params.logLevel;
     this.#logger = new Logger({
@@ -42,7 +35,6 @@ class Media {
     });
     this.#engine = params.engine;
     this.#clientEventEmitter = params.clientEventEmitter;
-    this.#mediaStreamTrackManager = new MediaStreamTrackManager(params.logLevel);
   }
 
   get mediasoupDevice(): Device {
@@ -70,20 +62,20 @@ class Media {
     return codecs.find((c) => c.mimeType.toLowerCase() === `${track.kind}/${track.getPreferredCodec()}`);
   }
 
-  private createTracks({ constraints, mediaStreamTracks }: CreateTracksPayload): Track[] {
+  private createTracks(stream: MediaStream): Track[] {
+    const mediaStreamTracks = stream.getTracks();
     return mediaStreamTracks.map((mediaStreamTrack) => {
       const params = {
         mediaStreamTrack,
         logLevel: this.#logLevel,
         engine: this.#engine,
         clientEventEmitter: this.#clientEventEmitter,
-        constraints,
-        mediaStreamTrackManager: this.#mediaStreamTrackManager,
       };
 
       const track = mediaStreamTrack.kind === 'audio' ? new AudioTrack(params) : new VideoTrack(params);
       this.tracks.set(track.id, track);
       this.#logger.debug('createTrack() track created', {
+        streamId: stream.id,
         trackId: track.id,
         kind: track.kind,
       });
@@ -93,13 +85,14 @@ class Media {
   }
 
   async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
-    const mediaStreamTracks = await this.#mediaStreamTrackManager.createUserMediaTracks(constraints);
-    return this.createTracks({ constraints, mediaStreamTracks });
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    this.#logger.debug('createUserMediaTrack() stream created', { streamId: stream.id });
+    return this.createTracks(stream);
   }
 
   async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
-    const mediaStreamTracks = await this.#mediaStreamTrackManager.createDisplayMediaTracks(constraints);
-    return this.createTracks({ constraints, mediaStreamTracks });
+    const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
+    return this.createTracks(stream);
   }
 
   deleteTrack(track: Track) {

package/src/engine/media/tracks/BaseTrack.ts

@@ -5,31 +5,27 @@ import {
   EncoderConfig,
   LogLevel,
   SocketResponse,
-  TrackLabel,
-  TrackOutboundStats,
+  TrackLabel, TrackOutboundStats,
   TrackProduceParams,
 } from '../../../types/common';
 import Logger from '../../Logger';
 import Engine from '../../index';
 import PeerConsumer from '../../PeerConsumer';
 import { PRODUCER_CHECK_STATE_TIMEOUT } from '../../../constants/common';
-import { CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, MEDIASOUP_EVENTS } from '../../../constants/events';
+import Timeout = NodeJS.Timeout;
+import { MEDIASOUP_EVENTS, INTERNAL_CLIENT_EVENTS, CLIENT_EVENTS } from '../../../constants/events';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
-import Timeout = NodeJS.Timeout;
-import MediaStreamTrackManager from './MediaStreamTrackManager';
 
 export type BaseTrackConstructorParams = {
   mediaStreamTrack: MediaStreamTrack,
   logLevel: LogLevel,
   engine: Engine,
   clientEventEmitter: EnhancedEventEmitter,
-  constraints: MediaStreamConstraints;
-  mediaStreamTrackManager: MediaStreamTrackManager;
 };
 
 class BaseTrack {
-  #mediaStreamTrack: MediaStreamTrack;
+  readonly #mediaStreamTrack: MediaStreamTrack;
 
   protected encoderConfig: EncoderConfig = {};
 
@@ -51,19 +47,13 @@ class BaseTrack {
 
   #closed = false;
 
-  readonly #constraints: MediaStreamConstraints;
-
-  readonly #mediaStreamTrackManager: MediaStreamTrackManager;
-
   constructor(params: BaseTrackConstructorParams) {
     const {
-      mediaStreamTrack, logLevel, engine, clientEventEmitter, constraints, mediaStreamTrackManager,
+      mediaStreamTrack, logLevel, engine, clientEventEmitter,
     } = params;
     this.#mediaStreamTrack = mediaStreamTrack;
     this.#engine = engine;
     this.#clientEventEmitter = clientEventEmitter;
-    this.#constraints = constraints;
-    this.#mediaStreamTrackManager = mediaStreamTrackManager;
     this.logger = new Logger({
       namespace: 'Track',
       logLevel,
@@ -376,7 +366,6 @@ class BaseTrack {
       await this.cancelProducerCheckState();
       await this.pauseRemoteProducer(this.producer.id);
       this.producer.pause();
-      this.#mediaStreamTrack.stop();
       this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackPaused, this);
       this.logger.debug('pause()', { track: this });
     } catch (error) {
@@ -392,12 +381,6 @@ class BaseTrack {
     }
 
     try {
-      const track = await this.#mediaStreamTrackManager.createMediaStreamTrack({
-        label: this.label,
-        constraints: this.#constraints,
-      });
-      this.#mediaStreamTrack = track;
-      await this.producer.replaceTrack({ track });
       await this.resumeRemoteProducer(this.producer.id);
       this.producer.resume();
       this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackResumed, this);

package/src/types/common.ts

@@ -350,11 +350,6 @@ export type UpdatePeerAppDataPayload = {
   appData: Record<string, unknown>,
 };
 
-export type CreateTracksPayload = {
-  mediaStreamTracks: MediaStreamTrack[],
-  constraints: MediaStreamConstraints,
-};
-
 export type TrackPublishParams = {
   keyFrameRequestDelay?: number;
 };

package/src/types/engine.ts

@@ -1,3 +1,4 @@
+import WebRTCIssueDetector, { IssueDetectorResult, NetworkScores } from 'webrtc-issue-detector';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from '../engine/system';
 import Media from '../engine/media';
@@ -5,9 +6,7 @@ import Network from '../engine/network';
 import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
-import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { Logger, LogLevel } from './common';
 
 export type IssuesHandler = (issues: IssueDetectorResult) => void;

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

@@ -1,14 +0,0 @@
-import { LogLevel, TrackLabel } from '../../../types/common';
-export declare type GetMediaStreamTrackParams = {
-    label: TrackLabel;
-    constraints: MediaStreamConstraints;
-};
-declare class MediaStreamTrackManager {
-    #private;
-    constructor(logLevel: LogLevel);
-    createMediaStreamTrack({ label, constraints }: GetMediaStreamTrackParams): Promise<MediaStreamTrack>;
-    private static isDisplayMedia;
-    createUserMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]>;
-    createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]>;
-}
-export default MediaStreamTrackManager;

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

@@ -1,20 +0,0 @@
-import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
-import { WebRTCIssueDetectorConstructorParams } from './types';
-declare class WebRTCIssueDetector {
-    #private;
-    readonly eventEmitter: WebRTCIssueEmitter;
-    private readonly detectors;
-    private readonly networkScoresCalculator;
-    private readonly statsReporter;
-    private readonly compositeStatsParser;
-    private readonly logger;
-    constructor(params: WebRTCIssueDetectorConstructorParams);
-    watchNewPeerConnections(): void;
-    stopWatchingNewPeerConnections(): void;
-    handleNewPeerConnection(pc: RTCPeerConnection): void;
-    private emitIssues;
-    private detectIssues;
-    private calculateNetworkScores;
-    private wrapRTCPeerConnection;
-}
-export default WebRTCIssueDetector;

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

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class InboundNetworkIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default InboundNetworkIssueDetector;

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

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

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

@@ -1,7 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class OutboundNetworkIssueDetector implements IssueDetector {
-    #private;
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-}
-export default OutboundNetworkIssueDetector;

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

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

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

@@ -1,10 +0,0 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
-declare class VideoCodecMismatchDetector implements IssueDetector {
-    #private;
-    readonly UNKNOWN_DECODER = "unknown";
-    detect(data: WebRTCStatsParsed): IssueDetectorResult;
-    private processData;
-    private setLastDecoderWithIssue;
-    private hadLastDecoderWithIssue;
-}
-export default VideoCodecMismatchDetector;

package/dist/engine/wid/lib/NetworkScoresCalculator.d.ts

@@ -1,9 +0,0 @@
-import { NetworkScores, NetworkScoresCalculator as INetworkScoresCalculator, WebRTCStatsParsed } from '../types';
-declare class NetworkScoresCalculator implements INetworkScoresCalculator {
-    #private;
-    calculate(data: WebRTCStatsParsed): NetworkScores;
-    private calcucateOutboundScore;
-    private calculateInboundScore;
-    private calculateMOS;
-}
-export default NetworkScoresCalculator;

package/dist/engine/wid/lib/PeriodicWebRTCStatsReporter.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { CompositeStatsParser } from '../types';
-interface PeriodicWebRTCStatsReporterParams {
-    compositeStatsParser: CompositeStatsParser;
-    getStatsInterval?: number;
-}
-declare class PeriodicWebRTCStatsReporter extends EventEmitter {
-    static readonly STATS_REPORT_READY_EVENT = "stats-report-ready";
-    private isStopped;
-    private reportTimer;
-    private readonly getStatsInterval;
-    private readonly compositeStatsParser;
-    constructor(params: PeriodicWebRTCStatsReporterParams);
-    get isRunning(): boolean;
-    startReporting(): void;
-    stopReporting(): void;
-    private parseReports;
-}
-export default PeriodicWebRTCStatsReporter;

package/dist/engine/wid/lib/parser/CompositeRTCStatsParser.d.ts

@@ -1,22 +0,0 @@
-import { CompositeStatsParser, ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
-export interface AddConnectionPayload {
-    id?: string;
-    pc: RTCPeerConnection;
-}
-export interface RemoveConnectionPayload {
-    pc: RTCPeerConnection;
-}
-interface CompositeRTCStatsParserParams {
-    statsParser: StatsParser;
-}
-declare class CompositeRTCStatsParser implements CompositeStatsParser {
-    private readonly connections;
-    private readonly statsParser;
-    constructor(params: CompositeRTCStatsParserParams);
-    listConnections(): ConnectionInfo[];
-    addPeerConnection(payload: AddConnectionPayload): void;
-    removePeerConnection(payload: RemoveConnectionPayload): void;
-    parse(): Promise<StatsReportItem[]>;
-    private removeConnectionsByIndexes;
-}
-export default CompositeRTCStatsParser;

package/dist/engine/wid/lib/parser/RTCStatsParser.d.ts

@@ -1,20 +0,0 @@
-import { ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
-import { Logger } from '../../../../types/common';
-interface WebRTCStatsParserParams {
-    logger: Logger;
-}
-declare class RTCStatsParser implements StatsParser {
-    private readonly prevStats;
-    private readonly allowedReportTypes;
-    private readonly logger;
-    constructor(params: WebRTCStatsParserParams);
-    parse(connection: ConnectionInfo): Promise<StatsReportItem | undefined>;
-    private getConnectionStats;
-    private mapReportsStats;
-    private updateMappedStatsWithReportItemData;
-    private getMediaType;
-    private propagateStatsWithRateValues;
-    private mapConnectionStatsIfNecessary;
-    private prepareConnectionStats;
-}
-export default RTCStatsParser;

package/dist/engine/wid/lib/parser/utils.d.ts

@@ -1,7 +0,0 @@
-interface WithTS {
-    timestamp: number;
-}
-export declare const checkIsConnectionClosed: (pc: RTCPeerConnection) => boolean;
-export declare const calcValueRate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
-export declare const calcBitrate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
-export {};