@fishjam-cloud/ts-client 0.8.1 → 0.10.0

package/dist/src/webrtc/tracks/LocalTrack.js

@@ -1,225 +0,0 @@
-import { generateCustomEvent } from '../mediaEvent';
-import { defaultBitrates, defaultSimulcastBitrates, UNLIMITED_BANDWIDTH } from '../bitrate';
-import { getEncodingParameters } from './encodings';
-import { createTransceiverConfig } from './transceivers';
-import { emitMutableEvents, getActionType } from './muteTrackUtils';
-/**
- * This is a wrapper over `TrackContext` that adds additional properties such as:
- * - `MLineId`: required to generate sdpOffer
- * - `MediaStreamTrackId`: required to generate sdpOffer and match RTCRtpSender
- * - `RTCRtpSender`: required to manage RTCPeerConnection track, e.g.:
- *   - enable/disable encoding
- *   - remove from connection
- *   - replace track
- *   - set track bandwidth
- *
- * In the future, this object could potentially be merged with `TrackContextImpl`.
- *
- * # Lifecycle, state transitions
- *
- * I identified the following states
- * - Before creating `Connection` object
- *   - connection === null
- *   - sender === null
- *   - mLineId === null
- * - After creating `Connection` object, during `onOfferData` handler
- *   // TODO: Verify if the track acquires a sender at this point or if it's only for past tracks
- *   - connection !== null
- *   - sender !== null
- *   - mLineId === null
- * - After establishing connection, during `onSdpAnswer`, track is being sent
- *   - connection !== null
- *   - sender !== null
- *   - mLineId !== null
- */
-export class LocalTrack {
-    id;
-    mediaStreamTrackId = null;
-    mLineId = null;
-    trackContext;
-    sender = null;
-    encodings;
-    metadataParser;
-    connection;
-    constructor(connection, id, trackContext, metadataParser) {
-        this.connection = connection;
-        this.id = id;
-        this.trackContext = trackContext;
-        // todo maybe we could remove this object and use sender.getParameters().encodings.encodingParameter.active instead
-        this.encodings = { h: true, m: true, l: true };
-        if (trackContext.track?.id) {
-            this.mediaStreamTrackId = trackContext.track?.id;
-        }
-        this.metadataParser = metadataParser;
-    }
-    updateSender = () => {
-        if (this.mediaStreamTrackId && this.connection) {
-            this.sender = this.connection.findSender(this.mediaStreamTrackId);
-        }
-    };
-    updateConnection = (connection) => {
-        this.connection = connection;
-    };
-    disableTrackEncoding = async (encoding) => {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const params = this.sender.getParameters();
-        const encodings = params.encodings;
-        const encodingParameter = encodings.find((en) => en.rid == encoding);
-        if (!encodingParameter)
-            throw new Error(`RTCRtpEncodingParameters for track ${this.id} not found`);
-        encodingParameter.active = false;
-        this.encodings[encoding] = false;
-        await this.sender.setParameters(params);
-    };
-    addTrackToConnection = () => {
-        if (!this.trackContext.track)
-            throw Error(`MediaStreamTrack for track ${this.id} does not exist`);
-        if (!this.connection)
-            throw new Error(`There is no active RTCPeerConnection`);
-        const transceiverConfig = createTransceiverConfig(this.trackContext);
-        this.updateEncodings();
-        this.connection.addTransceiver(this.trackContext.track, transceiverConfig);
-    };
-    // 1
-    updateEncodings = () => {
-        if (this.trackContext?.track?.kind === 'video' && this.trackContext.simulcastConfig?.activeEncodings) {
-            const activeEncodings = this.trackContext.simulcastConfig.activeEncodings;
-            this.encodings.l = activeEncodings.some((e) => e === 'l');
-            this.encodings.m = activeEncodings.some((e) => e === 'm');
-            this.encodings.h = activeEncodings.some((e) => e === 'h');
-        }
-    };
-    removeFromConnection = () => {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        if (!this.connection)
-            throw new Error(`There is no active RTCPeerConnection`);
-        this.connection.removeTrack(this.sender);
-    };
-    replaceTrack = async (newTrack, webrtc) => {
-        const trackId = this.id;
-        const stream = this.trackContext.stream;
-        const oldTrack = this.trackContext.track;
-        if (!this.sender)
-            throw Error('There is no RTCRtpSender for this track id!');
-        stream?.getTracks().forEach((track) => {
-            stream?.removeTrack(track);
-        });
-        if (newTrack) {
-            stream?.addTrack(newTrack);
-        }
-        this.trackContext.track = newTrack;
-        this.mediaStreamTrackId = newTrack?.id ?? null;
-        const action = getActionType(this.trackContext.track, newTrack);
-        if (action === 'mute' || action === 'unmute') {
-            emitMutableEvents(action, webrtc, trackId);
-        }
-        try {
-            await this.sender.replaceTrack(newTrack);
-        }
-        catch (_error) {
-            // rollback: emit opposite events and revert internal state
-            if (action === 'mute') {
-                emitMutableEvents('unmute', webrtc, trackId);
-            }
-            else if (action === 'unmute') {
-                emitMutableEvents('mute', webrtc, trackId);
-            }
-            this.trackContext.track = oldTrack;
-            this.mediaStreamTrackId = oldTrack?.id ?? null;
-        }
-    };
-    setTrackBandwidth = (bandwidth) => {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const parameters = this.sender.getParameters();
-        parameters.encodings = getEncodingParameters(parameters, bandwidth);
-        return this.sender.setParameters(parameters);
-    };
-    setEncodingBandwidth(rid, bandwidth) {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const parameters = this.sender.getParameters();
-        const encoding = parameters.encodings.find((encoding) => encoding.rid === rid);
-        if (!encoding) {
-            return Promise.reject(`Encoding with rid '${rid}' doesn't exist`);
-        }
-        else if (bandwidth === 0) {
-            delete encoding.maxBitrate;
-        }
-        else {
-            encoding.maxBitrate = bandwidth * 1024;
-        }
-        return this.sender.setParameters(parameters);
-    }
-    updateTrackMetadata = (metadata) => {
-        const trackContext = this.trackContext;
-        try {
-            trackContext.metadata = this.metadataParser(metadata);
-            trackContext.rawMetadata = metadata;
-            trackContext.metadataParsingError = undefined;
-        }
-        catch (error) {
-            trackContext.metadata = undefined;
-            trackContext.metadataParsingError = error;
-            throw error;
-        }
-    };
-    enableTrackEncoding = (encoding) => {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const params = this.sender.getParameters();
-        const encodingParameters = params.encodings.find((en) => en.rid == encoding);
-        if (!encodingParameters)
-            throw new Error(`RTCRtEncodingParameters ${encoding} for track ${this.id} not found`);
-        encodingParameters.active = true;
-        this.encodings[encoding] = true;
-        return this.sender.setParameters(params);
-    };
-    getDisabledEncodings = () => {
-        return Object.entries(this.encodings)
-            .filter(([_, value]) => !value)
-            .map(([encoding]) => encoding)
-            .reduce((acc, encoding) => [...acc, encoding], []);
-    };
-    setMLineId = (mLineId) => {
-        this.mLineId = mLineId;
-    };
-    isNotSimulcastTrack = (encodings) => encodings.length === 1 && !encodings[0].rid;
-    getTrackBitrates = () => {
-        const trackContext = this.trackContext;
-        const kind = this.trackContext.track?.kind;
-        if (!trackContext.track) {
-            if (!trackContext.trackKind) {
-                throw new Error('trackContext.trackKind is empty');
-            }
-            return defaultBitrates[trackContext.trackKind];
-        }
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const encodings = this.sender.getParameters().encodings;
-        if (this.isNotSimulcastTrack(encodings)) {
-            return encodings[0].maxBitrate || (kind ? defaultBitrates[kind] : UNLIMITED_BANDWIDTH);
-        }
-        else if (kind === 'audio') {
-            throw 'Audio track cannot have multiple encodings';
-        }
-        return encodings
-            .filter((encoding) => encoding.rid)
-            .reduce((acc, encoding) => {
-            const rid = encoding.rid;
-            acc[rid] = encoding.maxBitrate || defaultSimulcastBitrates[rid];
-            return acc;
-        }, {});
-    };
-    createTrackVariantBitratesEvent = () => {
-        return generateCustomEvent({
-            type: 'trackVariantBitrates',
-            data: {
-                trackId: this.id,
-                variantBitrates: this.getTrackBitrates(),
-            },
-        });
-    };
-}

package/dist/src/webrtc/tracks/LocalTrackManager.d.ts

@@ -1,38 +0,0 @@
-import type { SimulcastConfig, TrackBandwidthLimit } from '../types';
-import { type MediaEvent } from '../mediaEvent';
-import type { ConnectionManager } from '../ConnectionManager';
-import type { Local } from './Local';
-import type { WebRTCEndpoint } from '../webRTCEndpoint';
-/**
- * This class is responsible for handling asynchronous operations related to track management.
- * It contains methods and state associated with handling a single operation
- * (adding, removing, and replacing a track).
- * It facilitates the preparation of events that will later be handled by the `CommandsQueue`.
- * It informs the `CommandsQueue` whether the previous task has been completed
- *
- * Adding and removing tracks requires renegotiation.
- *
- * Replacing a track relies on `ongoingTrackReplacement`, which probably could be removed
- * and replaced with a Promise, because it does not require renegotiation.
- */
-export declare class LocalTrackManager<EndpointMetadata, TrackMetadata> {
-    connection?: ConnectionManager;
-    private readonly local;
-    ongoingTrackReplacement: boolean;
-    /**
-     * Indicates if an ongoing renegotiation is active.
-     * During renegotiation, both parties are expected to actively exchange events: renegotiateTracks, offerData, sdpOffer, sdpAnswer.
-     */
-    ongoingRenegotiation: boolean;
-    private readonly sendMediaEvent;
-    constructor(local: Local<EndpointMetadata, TrackMetadata>, sendMediaEvent: (mediaEvent: MediaEvent) => void);
-    isNegotiationInProgress: () => boolean;
-    cleanUp: () => void;
-    parseAddTrack: (track: MediaStreamTrack, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
-    addTrackHandler: (trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: TrackMetadata | undefined, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
-    removeTrackHandler: (trackId: string) => void;
-    replaceTrackHandler: (webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>, trackId: string, newTrack: MediaStreamTrack | null) => Promise<void>;
-    getEndpointId: () => string;
-    updateConnection: (connection: ConnectionManager) => void;
-    updateSenders: () => void;
-}

package/dist/src/webrtc/tracks/LocalTrackManager.js

@@ -1,77 +0,0 @@
-import { generateCustomEvent } from '../mediaEvent';
-/**
- * This class is responsible for handling asynchronous operations related to track management.
- * It contains methods and state associated with handling a single operation
- * (adding, removing, and replacing a track).
- * It facilitates the preparation of events that will later be handled by the `CommandsQueue`.
- * It informs the `CommandsQueue` whether the previous task has been completed
- *
- * Adding and removing tracks requires renegotiation.
- *
- * Replacing a track relies on `ongoingTrackReplacement`, which probably could be removed
- * and replaced with a Promise, because it does not require renegotiation.
- */
-export class LocalTrackManager {
-    connection;
-    local;
-    ongoingTrackReplacement = false;
-    /**
-     * Indicates if an ongoing renegotiation is active.
-     * During renegotiation, both parties are expected to actively exchange events: renegotiateTracks, offerData, sdpOffer, sdpAnswer.
-     */
-    ongoingRenegotiation = false;
-    sendMediaEvent;
-    constructor(local, sendMediaEvent) {
-        this.local = local;
-        this.sendMediaEvent = sendMediaEvent;
-    }
-    isNegotiationInProgress = () => {
-        return this.ongoingRenegotiation || this.ongoingTrackReplacement;
-    };
-    cleanUp = () => {
-        this.ongoingTrackReplacement = false;
-        this.ongoingRenegotiation = false;
-    };
-    parseAddTrack = (track, simulcastConfig, maxBandwidth) => {
-        if (this.getEndpointId() === '') {
-            throw new Error('Cannot add tracks before being accepted by the server');
-        }
-        if (!simulcastConfig.enabled && !(typeof maxBandwidth === 'number')) {
-            throw new Error('Invalid type of `maxBandwidth` argument for a non-simulcast track, expected: number');
-        }
-        if (this.connection?.isTrackInUse(track)) {
-            throw new Error("This track was already added to peerConnection, it can't be added again!");
-        }
-    };
-    addTrackHandler = (trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
-        this.ongoingRenegotiation = true;
-        const trackManager = this.local.addTrack(this.connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth);
-        if (this.connection) {
-            trackManager.addTrackToConnection();
-        }
-        const mediaEvent = generateCustomEvent({ type: 'renegotiateTracks' });
-        this.sendMediaEvent(mediaEvent);
-    };
-    removeTrackHandler = (trackId) => {
-        if (!this.connection)
-            throw new Error(`There is no active RTCPeerConnection`);
-        this.ongoingRenegotiation = true;
-        this.local.removeTrack(trackId);
-    };
-    replaceTrackHandler = async (webrtc, trackId, newTrack) => {
-        this.ongoingTrackReplacement = true;
-        try {
-            await this.local.replaceTrack(webrtc, trackId, newTrack);
-        }
-        finally {
-            this.ongoingTrackReplacement = false;
-        }
-    };
-    getEndpointId = () => this.local.getEndpoint().id;
-    updateConnection = (connection) => {
-        this.connection = connection;
-    };
-    updateSenders = () => {
-        this.local.updateSenders();
-    };
-}

package/dist/src/webrtc/tracks/Remote.d.ts

@@ -1,38 +0,0 @@
-import type { Encoding, EncodingReason, MetadataParser, MLineId, SimulcastConfig, TrackContext, WebRTCEndpointEvents } from '../types';
-import { RemoteTrack } from './RemoteTrack';
-import type { EndpointWithTrackContext } from '../internal';
-import { type MediaEvent } from '../mediaEvent';
-import type { EndpointId, TrackId } from './TrackCommon';
-type SDPTrack = {
-    metadata: null;
-    simulcastConfig: SimulcastConfig;
-};
-export declare class Remote<EndpointMetadata, TrackMetadata> {
-    private readonly remoteTracks;
-    private readonly remoteEndpoints;
-    private readonly endpointMetadataParser;
-    private readonly trackMetadataParser;
-    private readonly emit;
-    private readonly sendMediaEvent;
-    constructor(emit: <E extends keyof Required<WebRTCEndpointEvents<EndpointMetadata, TrackMetadata>>>(event: E, ...args: Parameters<Required<WebRTCEndpointEvents<EndpointMetadata, TrackMetadata>>[E]>) => void, sendMediaEvent: (mediaEvent: MediaEvent) => void, endpointMetadataParser: MetadataParser<EndpointMetadata>, trackMetadataParser: MetadataParser<TrackMetadata>);
-    getTrackByMid: (mid: string) => RemoteTrack<EndpointMetadata, TrackMetadata>;
-    addTracks: (endpointId: EndpointId, tracks: Record<TrackId, SDPTrack>, trackIdToMetadata: Record<TrackId, any>) => void;
-    removeTracks: (trackIds: TrackId[]) => void;
-    removeRemoteTrack: (trackId: TrackId) => void;
-    addRemoteEndpoint: (endpoint: any, sendNotification?: boolean) => void;
-    private addEndpoint;
-    updateRemoteEndpoint: (data: any) => void;
-    private updateEndpointMetadata;
-    removeRemoteEndpoint: (endpointId: EndpointId) => void;
-    updateRemoteTrack: (data: any) => void;
-    private updateTrackMetadata;
-    disableRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding) => void;
-    enableRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding) => void;
-    setRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding, reason: EncodingReason) => void;
-    setRemoteTrackVadStatus: (trackId: TrackId, vadStatus: string) => void;
-    getRemoteTrackContexts: () => Record<string, TrackContext<EndpointMetadata, TrackMetadata>>;
-    getRemoteEndpoints: () => Record<string, EndpointWithTrackContext<EndpointMetadata, TrackMetadata>>;
-    setTargetRemoteTrackEncoding: (trackId: TrackId, variant: Encoding) => void;
-    updateMLineIds: (midToTrackId: Record<MLineId, TrackId>) => void;
-}
-export {};

package/dist/src/webrtc/tracks/Remote.js

@@ -1,200 +0,0 @@
-import { RemoteTrack } from './RemoteTrack';
-import { TrackContextImpl } from '../internal';
-import { isVadStatus } from '../voiceActivityDetection';
-import { generateCustomEvent } from '../mediaEvent';
-export class Remote {
-    remoteTracks = {};
-    remoteEndpoints = {};
-    endpointMetadataParser;
-    trackMetadataParser;
-    emit;
-    sendMediaEvent;
-    constructor(emit, sendMediaEvent, endpointMetadataParser, trackMetadataParser) {
-        this.emit = emit;
-        this.sendMediaEvent = sendMediaEvent;
-        this.endpointMetadataParser = endpointMetadataParser;
-        this.trackMetadataParser = trackMetadataParser;
-    }
-    getTrackByMid = (mid) => {
-        const remoteTrack = Object.values(this.remoteTracks).find((remote) => remote.mLineId === mid);
-        if (!remoteTrack)
-            throw new Error(`Remote track with ${mid} not found`);
-        return remoteTrack;
-    };
-    addTracks = (endpointId, tracks, trackIdToMetadata) => {
-        const endpoint = this.remoteEndpoints[endpointId];
-        if (!endpoint)
-            throw new Error(`Endpoint ${endpointId} not found`);
-        Object.entries(tracks || {})
-            .map(([trackId, { simulcastConfig }]) => {
-            const trackContext = new TrackContextImpl(endpoint, trackId, trackIdToMetadata[trackId], simulcastConfig, this.trackMetadataParser);
-            return new RemoteTrack(trackId, trackContext);
-        })
-            .forEach((remoteTrack) => {
-            this.remoteTracks[remoteTrack.id] = remoteTrack;
-            endpoint.tracks.set(remoteTrack.id, remoteTrack.trackContext);
-            this.emit('trackAdded', remoteTrack.trackContext);
-        });
-    };
-    removeTracks = (trackIds) => {
-        trackIds.forEach((trackId) => {
-            this.removeRemoteTrack(trackId);
-        });
-    };
-    removeRemoteTrack = (trackId) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        const remoteEndpoint = this.remoteEndpoints[remoteTrack.trackContext.endpoint.id];
-        if (!remoteEndpoint)
-            throw new Error(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found`);
-        remoteEndpoint.tracks.delete(trackId);
-        delete this.remoteTracks[trackId];
-        this.emit('trackRemoved', remoteTrack.trackContext);
-    };
-    addRemoteEndpoint = (endpoint, sendNotification = true) => {
-        const newEndpoint = {
-            id: endpoint.id,
-            type: endpoint.type,
-            metadata: { peer: undefined, server: undefined },
-            rawMetadata: { peer: undefined, server: undefined },
-            metadataParsingError: undefined,
-            tracks: new Map(),
-        };
-        // mutation in place
-        this.updateEndpointMetadata(newEndpoint, endpoint?.metadata?.peer);
-        this.addEndpoint(newEndpoint);
-        this.addTracks(newEndpoint.id, endpoint.tracks, endpoint.trackIdToMetadata);
-        if (sendNotification) {
-            this.emit('endpointAdded', endpoint);
-        }
-    };
-    addEndpoint = (endpoint) => {
-        this.remoteEndpoints[endpoint.id] = endpoint;
-    };
-    updateRemoteEndpoint = (data) => {
-        const endpoint = this.remoteEndpoints[data.id];
-        if (!endpoint)
-            throw new Error(`Endpoint ${data.id} not found`);
-        // mutation in place
-        this.updateEndpointMetadata(endpoint, data.metadata.peer);
-        this.emit('endpointUpdated', endpoint);
-    };
-    updateEndpointMetadata = (endpoint, metadata) => {
-        try {
-            endpoint.metadata.peer = this.endpointMetadataParser(metadata);
-            endpoint.metadataParsingError = undefined;
-        }
-        catch (error) {
-            endpoint.metadata.peer = undefined;
-            endpoint.metadataParsingError = error;
-        }
-        endpoint.rawMetadata.peer = metadata;
-    };
-    removeRemoteEndpoint = (endpointId) => {
-        const endpoint = this.remoteEndpoints[endpointId];
-        if (!endpoint)
-            throw new Error(`Endpoint ${endpointId} not found`);
-        const trackIds = [...endpoint.tracks.values()].map(({ trackId }) => trackId);
-        this.removeTracks(trackIds);
-        delete this.remoteEndpoints[endpointId];
-        this.emit('endpointRemoved', endpoint);
-    };
-    updateRemoteTrack = (data) => {
-        const endpointId = data.endpointId;
-        const endpoint = this.remoteEndpoints[endpointId];
-        if (!endpoint)
-            throw new Error(`Endpoint ${endpointId} not found`);
-        const trackId = data.trackId;
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        this.updateTrackMetadata(remoteTrack.trackContext, data.metadata);
-        this.emit('trackUpdated', remoteTrack.trackContext);
-    };
-    updateTrackMetadata = (trackContext, trackMetadata) => {
-        try {
-            trackContext.metadata = this.trackMetadataParser(trackMetadata);
-            trackContext.metadataParsingError = undefined;
-        }
-        catch (error) {
-            trackContext.metadataParsingError = error;
-            trackContext.metadata = undefined;
-        }
-        trackContext.rawMetadata = trackMetadata;
-    };
-    disableRemoteTrackEncoding = (trackId, encoding) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        remoteTrack.disableTrackEncoding(encoding);
-        this.emit('trackEncodingDisabled', remoteTrack.trackContext, encoding);
-    };
-    enableRemoteTrackEncoding = (trackId, encoding) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        remoteTrack.enableTrackEncoding(encoding);
-        this.emit('trackEncodingEnabled', remoteTrack.trackContext, encoding);
-    };
-    setRemoteTrackEncoding = (trackId, encoding, reason) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        remoteTrack.trackContext.encoding = encoding;
-        remoteTrack.trackContext.encodingReason = reason;
-        remoteTrack.trackContext.emit('encodingChanged', remoteTrack.trackContext);
-    };
-    setRemoteTrackVadStatus = (trackId, vadStatus) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        if (isVadStatus(vadStatus)) {
-            remoteTrack.trackContext.vadStatus = vadStatus;
-            remoteTrack.trackContext.emit('voiceActivityChanged', remoteTrack.trackContext);
-        }
-        else {
-            console.warn('Received unknown vad status: ', vadStatus);
-        }
-    };
-    getRemoteTrackContexts = () => {
-        return Object.values(this.remoteTracks).reduce((acc, current) => ({
-            ...acc,
-            [current.trackContext.trackId]: current.trackContext,
-        }), {});
-    };
-    getRemoteEndpoints = () => {
-        return Object.values(this.remoteEndpoints).reduce((acc, current) => ({ ...acc, [current.id]: current }), {});
-    };
-    setTargetRemoteTrackEncoding = (trackId, variant) => {
-        const remoteTrack = this.remoteTracks[trackId];
-        if (!remoteTrack)
-            throw new Error(`Track ${trackId} not found`);
-        try {
-            remoteTrack.setTargetTrackEncoding(variant);
-            const mediaEvent = generateCustomEvent({
-                type: 'setTargetTrackVariant',
-                data: {
-                    trackId: trackId,
-                    variant,
-                },
-            });
-            this.sendMediaEvent(mediaEvent);
-            this.emit('targetTrackEncodingRequested', {
-                trackId,
-                variant,
-            });
-        }
-        catch (e) {
-            console.warn(e);
-        }
-    };
-    updateMLineIds = (midToTrackId) => {
-        Object.entries(midToTrackId).forEach(([mLineId, trackId]) => {
-            const remoteTrack = this.remoteTracks[trackId];
-            if (remoteTrack) {
-                remoteTrack.setMLineId(mLineId);
-            }
-        });
-    };
-}

package/dist/src/webrtc/tracks/RemoteTrack.d.ts

@@ -1,39 +0,0 @@
-import type { TrackCommon, TrackEncodings, TrackId } from './TrackCommon';
-import type { LocalTrackId, MLineId, Encoding } from '../types';
-import type { TrackContextImpl } from '../internal';
-/**
- * This is a wrapper over `TrackContext` that adds additional properties such as:
- * - `MLineId`: required to generate sdpOffer
- *
- * # Lifecycle, state transitions
- *
- * I identified the following states
- * - on `trackAdded`
- *   - trackContext.stream === null
- *   - trackContext.track === null
- *   - trackContext.trackKind === null
- *   - mLineId === null
- * - on `onSdpAnswer`
- *   - trackContext.stream === null
- *   - trackContext.track === null
- *   - trackContext.trackKind === null
- *   - mLineId !== null
- * - on `trackReady`
- *   - trackContext.stream !== null
- *   - trackContext.track !== null
- *   - trackContext.trackKind !== null
- *   - mLineId !== null
- */
-export declare class RemoteTrack<EndpointMetadata, TrackMetadata> implements TrackCommon {
-    id: TrackId;
-    mLineId: MLineId | null;
-    readonly trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>;
-    readonly encodings: TrackEncodings;
-    private targetEncoding;
-    constructor(id: LocalTrackId, trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>);
-    setMLineId: (mLineId: MLineId) => void;
-    setReady: (stream: MediaStream, track: MediaStreamTrack) => void;
-    disableTrackEncoding: (encoding: Encoding) => void;
-    enableTrackEncoding: (encoding: Encoding) => void;
-    setTargetTrackEncoding: (variant: Encoding) => void;
-}

package/dist/src/webrtc/tracks/RemoteTrack.js

@@ -1,64 +0,0 @@
-import { isTrackKind } from '../internal';
-/**
- * This is a wrapper over `TrackContext` that adds additional properties such as:
- * - `MLineId`: required to generate sdpOffer
- *
- * # Lifecycle, state transitions
- *
- * I identified the following states
- * - on `trackAdded`
- *   - trackContext.stream === null
- *   - trackContext.track === null
- *   - trackContext.trackKind === null
- *   - mLineId === null
- * - on `onSdpAnswer`
- *   - trackContext.stream === null
- *   - trackContext.track === null
- *   - trackContext.trackKind === null
- *   - mLineId !== null
- * - on `trackReady`
- *   - trackContext.stream !== null
- *   - trackContext.track !== null
- *   - trackContext.trackKind !== null
- *   - mLineId !== null
- */
-export class RemoteTrack {
-    id;
-    mLineId = null;
-    trackContext;
-    encodings = { h: false, m: false, l: false };
-    // todo this field is not exposed
-    targetEncoding = null;
-    constructor(id, trackContext) {
-        this.id = id;
-        this.trackContext = trackContext;
-    }
-    setMLineId = (mLineId) => {
-        this.mLineId = mLineId;
-    };
-    setReady = (stream, track) => {
-        if (!isTrackKind(track.kind))
-            throw new Error('Track has no kind');
-        this.trackContext.stream = stream;
-        this.trackContext.track = track;
-        this.trackContext.trackKind = track.kind;
-    };
-    disableTrackEncoding = (encoding) => {
-        this.encodings[encoding] = false;
-    };
-    enableTrackEncoding = (encoding) => {
-        this.encodings[encoding] = true;
-    };
-    setTargetTrackEncoding = (variant) => {
-        // todo implement validation
-        this.targetEncoding = variant;
-        const trackContext = this.trackContext;
-        if (!trackContext.simulcastConfig?.enabled) {
-            throw new Error('The track does not support changing its target variant');
-        }
-        const isValidTargetEncoding = !trackContext.simulcastConfig.activeEncodings.includes(variant);
-        if (isValidTargetEncoding) {
-            throw new Error(`The track does not support variant ${variant}`);
-        }
-    };
-}