@livedigital/client 2.0.1 → 2.2.0

package/dist/constants/events.d.ts

@@ -32,6 +32,8 @@ export declare const MEDIASOUP_EVENTS: {
     pauseProducer: string;
     resumeProducer: string;
     producerScoreChanged: string;
+    producerSetMaxSpatialLayer: string;
+    producerRequestMaxSpatialLayer: string;
     createConsumer: string;
     closeConsumer: string;
     pauseConsumer: string;

package/dist/constants/simulcastEncodings.d.ts

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

package/dist/engine/Peer.d.ts

@@ -1,16 +1,16 @@
 import { ProducerData, ConnectionQuality, PayloadOfPublishedMedia, Role } from '../types/common';
-import Consumer from './media/Consumer';
-import VideoConsumer from './media/VideoConsumer';
 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?: VideoConsumer;
-    audioConsumer?: Consumer;
+    videoConsumer?: PeerConsumer;
+    audioConsumer?: PeerConsumer;
     engine: Engine;
     soundLevel?: number;
     loginDate: Date;
@@ -32,7 +32,7 @@ declare class Peer {
     appData: Record<string, unknown>;
     role: Role;
     private producers;
-    private consumers;
+    readonly tracks: Map<string, PeerTrack>;
     private readonly engine;
     private readonly _observer;
     private readonly logger;
@@ -43,22 +43,14 @@ declare class Peer {
     get isMe(): boolean;
     get publishedMedia(): PayloadOfPublishedMedia[];
     subscribe(producerId: string): Promise<void>;
-    setMinResolution(consumerId: string): Promise<void>;
-    setMediumResolution(consumerId: string): Promise<void>;
-    setMaxResolution(consumerId: string): Promise<void>;
-    pause(consumerId: string): Promise<void>;
-    resume(consumerId: string): Promise<void>;
-    setPriority(consumerId: string, priority: number): Promise<void>;
-    private setConsumerPriority;
     private createConsumer;
-    private changeConsumerPreferredLayers;
-    private pauseRemoteConsumer;
-    private resumeRemoteConsumer;
     private handleNewProducer;
     private handlePeerEvents;
     private emitConnectionQuality;
     static getConnectionQualityByScore(score: number): ConnectionQuality;
-    getAllConsumers(): Consumer[];
+    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

@@ -1,10 +1,14 @@
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import { ProducerData, TrackLabel } from '../types/common';
+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);
 }

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

@@ -1,11 +1,13 @@
 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;
@@ -19,5 +21,6 @@ declare class BaseTrack {
     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/VideoTrack.d.ts

@@ -5,9 +5,13 @@ 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;