@fishjam-cloud/webrtc-client 0.25.2 → 0.25.3

package/dist/webrtc-client/src/tracks/Local.js

@@ -1,243 +0,0 @@
-import { MediaEvent as PeerMediaEvent, MediaEvent_DisableTrackVariant, MediaEvent_EnableTrackVariant, MediaEvent_RenegotiateTracks, MediaEvent_SdpOffer, MediaEvent_TrackBitrates, MediaEvent_UpdateEndpointMetadata, MediaEvent_UpdateTrackMetadata, } from '@fishjam-cloud/protobufs/peer';
-import { Variant } from '@fishjam-cloud/protobufs/shared';
-import { isTrackKind, TrackContextImpl } from '../internal';
-import { LocalTrack } from './LocalTrack';
-/**
- * This class encapsulates methods related to handling the list of local tracks and local endpoint.
- * It stores and mutates part of the client state for this local peer.
- * It emits local events for local tracks and endpoints,
- * and delegates mutation logic to the appropriate `LocalTrack` objects.
- * It's responsible for creating `MidToTrackId` record which is required in `sdpOffer`
- */
-export class Local {
-    localTracks = {};
-    localEndpoint = {
-        id: '',
-        type: 'webrtc',
-        metadata: undefined,
-        tracks: new Map(),
-    };
-    emit;
-    sendMediaEvent;
-    connection = null;
-    constructor(emit, sendMediaEvent) {
-        this.emit = emit;
-        this.sendMediaEvent = sendMediaEvent;
-    }
-    updateSenders = () => {
-        Object.values(this.localTracks).forEach((localTrack) => {
-            localTrack.updateSender();
-        });
-    };
-    updateMLineIds = (midToTrackIds) => {
-        Object.entries(midToTrackIds).forEach(([mid, trackId]) => {
-            this.localTracks[trackId]?.setMLineId(mid);
-        });
-    };
-    updateConnection = (connection) => {
-        this.connection = connection;
-        Object.values(this.localTracks).forEach((track) => {
-            track.updateConnection(connection);
-        });
-    };
-    createSdpOfferEvent = (sdpOffer) => {
-        const trackIdToMetadataJson = this.getTrackIdToMetadataJson();
-        const trackIdToBitrates = this.getTrackIdToTrackBitrates();
-        const midToTrackId = this.getMidToTrackId();
-        return MediaEvent_SdpOffer.create({
-            sdp: sdpOffer.sdp,
-            midToTrackId,
-            trackIdToBitrates,
-            trackIdToMetadataJson,
-        });
-    };
-    addTrack = (connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
-        const trackContext = new TrackContextImpl(this.localEndpoint, trackId, trackMetadata, simulcastConfig);
-        trackContext.track = track;
-        trackContext.stream = stream;
-        trackContext.maxBandwidth = maxBandwidth;
-        if (!isTrackKind(track.kind))
-            throw new Error('Track has no kind');
-        trackContext.trackKind = track.kind;
-        this.localEndpoint.tracks.set(trackId, trackContext);
-        const trackManager = new LocalTrack(connection, trackId, trackContext);
-        this.localTracks[trackId] = trackManager;
-        return trackManager;
-    };
-    getTrackByMidOrNull = (mid) => {
-        return Object.values(this.localTracks).find((track) => track.mLineId === mid) ?? null;
-    };
-    removeTrack = (trackId) => {
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        trackManager.removeFromConnection();
-        const renegotiateTracks = MediaEvent_RenegotiateTracks.create({});
-        this.sendMediaEvent({ renegotiateTracks });
-        this.localEndpoint.tracks.delete(trackId);
-        delete this.localTracks[trackId];
-    };
-    replaceTrack = async (webrtc, trackId, newTrack) => {
-        // TODO add validation to track.kind, you cannot replace video with audio
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        await trackManager.replaceTrack(newTrack, webrtc);
-    };
-    setEndpointMetadata = (metadata) => {
-        this.localEndpoint.metadata = metadata;
-    };
-    getEndpoint = () => {
-        return this.localEndpoint;
-    };
-    setTrackBandwidth = async (trackId, bandwidth) => {
-        // FIXME: maxBandwidth in TrackContext is not updated
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        await trackManager.setTrackBandwidth(bandwidth);
-        const trackBitrates = MediaEvent_TrackBitrates.create({
-            trackId,
-            variantBitrates: [{ variant: Variant.VARIANT_UNSPECIFIED, bitrate: bandwidth }],
-        });
-        this.sendMediaEvent(PeerMediaEvent.create({ trackBitrates }));
-        this.emit('localTrackBandwidthSet', {
-            trackId,
-            bandwidth,
-        });
-    };
-    getTrackIdToTrack = () => {
-        const entries = Object.values(this.localTracks).map((track) => [track.id, track.trackContext]);
-        return new Map(entries);
-    };
-    setLocalEndpointId = (endpointId) => {
-        this.localEndpoint.id = endpointId;
-    };
-    setEncodingBandwidth = async (trackId, rid, bandwidth) => {
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        await trackManager.setEncodingBandwidth(rid, bandwidth);
-        const bitrates = trackManager.getTrackBitrates();
-        let variantBitrates = [];
-        if (typeof bitrates === 'number') {
-            variantBitrates = [{ variant: Variant.VARIANT_UNSPECIFIED, bitrate: bitrates }];
-        }
-        else if (bitrates) {
-            variantBitrates = Object.entries(bitrates).map(([variant, bitrate]) => ({
-                variant: Number(variant),
-                bitrate,
-            }));
-        }
-        const trackBitrates = MediaEvent_TrackBitrates.create({
-            trackId,
-            variantBitrates,
-        });
-        this.sendMediaEvent(PeerMediaEvent.create({ trackBitrates }));
-        this.emit('localTrackEncodingBandwidthSet', {
-            trackId,
-            rid,
-            bandwidth,
-        });
-    };
-    updateEndpointMetadata = (metadata) => {
-        this.localEndpoint.metadata = metadata;
-        const updateEndpointMetadata = MediaEvent_UpdateEndpointMetadata.create({
-            metadataJson: JSON.stringify(this.localEndpoint.metadata),
-        });
-        this.sendMediaEvent({ updateEndpointMetadata });
-        this.emit('localEndpointMetadataChanged', {
-            metadata: this.localEndpoint.metadata,
-        });
-    };
-    updateLocalTrackMetadata = (trackId, metadata) => {
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        trackManager.updateTrackMetadata(metadata);
-        const trackContext = trackManager.trackContext;
-        const updateTrackMetadata = MediaEvent_UpdateTrackMetadata.create({
-            trackId,
-            metadataJson: metadata ? JSON.stringify(metadata) : undefined,
-        });
-        switch (trackContext.negotiationStatus) {
-            case 'done':
-                this.sendMediaEvent({ updateTrackMetadata });
-                this.emit('localTrackMetadataChanged', {
-                    trackId,
-                    metadata: trackContext.metadata,
-                });
-                break;
-            case 'offered':
-                trackContext.pendingMetadataUpdate = true;
-                break;
-            case 'awaiting':
-                // We don't need to do anything
-                break;
-        }
-    };
-    disableLocalTrackEncoding = async (trackId, encoding) => {
-        const localTrack = this.localTracks[trackId];
-        if (!localTrack)
-            throw new Error(`Track ${trackId} not found`);
-        await localTrack.disableTrackEncoding(encoding);
-        const disableTrackVariant = MediaEvent_DisableTrackVariant.create({ trackId, variant: encoding });
-        this.sendMediaEvent(PeerMediaEvent.create({ disableTrackVariant }));
-        this.emit('localTrackEncodingEnabled', {
-            trackId,
-            encoding,
-        });
-    };
-    enableLocalTrackEncoding = async (trackId, variant) => {
-        const trackManager = this.localTracks[trackId];
-        if (!trackManager)
-            throw new Error(`Cannot find ${trackId}`);
-        await trackManager.enableTrackEncoding(variant);
-        const enableTrackVariant = MediaEvent_EnableTrackVariant.create({ trackId, variant });
-        this.sendMediaEvent(PeerMediaEvent.create({ enableTrackVariant }));
-        this.emit('localTrackEncodingEnabled', {
-            trackId,
-            encoding: variant,
-        });
-    };
-    getTrackIdToMetadataJson = () => Object.values(this.localTracks).reduce((acc, { id, trackContext }) => ({ ...acc, [id]: JSON.stringify(trackContext.metadata) }), {});
-    // TODO add bitrates
-    getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce((acc, { id }) => ({ ...acc, [id]: { bitrate: 1_500_000 } }), {});
-    getMidToTrackId = () => {
-        if (!this.connection)
-            return {};
-        // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
-        // - not yet negotiated tracks: tracks added in this negotiation, data will be transmitted after successful negotiation
-        const mappingFromTransceivers = this.getTransceiverMapping();
-        // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
-        // - negotiated muted tracks: tracks added in previous negotiation, data is not being transmitted but can be transmitted in the future
-        const mappingFromLocalNegotiatedTracks = Object.values(this.localTracks)
-            .filter((track) => !!track.mLineId)
-            .reduce((acc, { id, mLineId }) => ({ ...acc, [mLineId]: id }), {});
-        return { ...mappingFromTransceivers, ...mappingFromLocalNegotiatedTracks };
-    };
-    getTransceiverMapping = () => {
-        if (!this.connection)
-            return {};
-        return this.connection
-            .getConnection()
-            .getTransceivers()
-            .filter((transceiver) => Boolean(transceiver.sender.track?.id && transceiver.mid))
-            .reduce((acc, { sender, mid }) => {
-            const localTrack = Object.values(this.localTracks).find((track) => track.mediaStreamTrackId === sender.track.id);
-            if (!localTrack)
-                throw new Error('Local track not found');
-            return { ...acc, [mid]: localTrack.id };
-        }, {});
-    };
-    setLocalTrackStatusToOffered = () => {
-        Object.values(this.localTracks).forEach((localTrack) => {
-            localTrack.trackContext.negotiationStatus = 'offered';
-        });
-    };
-    addAllTracksToConnection = () => {
-        Object.values(this.localTracks).forEach((localTrack) => {
-            localTrack.addTrackToConnection();
-        });
-    };
-}

package/dist/webrtc-client/src/tracks/LocalTrack.d.ts

@@ -1,61 +0,0 @@
-import { Variant } from '@fishjam-cloud/protobufs/shared';
-import type { Bitrates } from '../bitrate';
-import type { ConnectionManager } from '../ConnectionManager';
-import type { TrackContextImpl } from '../internal';
-import type { BandwidthLimit, LocalTrackId, MediaStreamTrackId, MLineId } from '../types';
-import type { WebRTCEndpoint } from '../webRTCEndpoint';
-import type { TrackCommon, TrackEncodings, TrackId } from './TrackCommon';
-/**
- * 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 declare class LocalTrack implements TrackCommon {
-    readonly id: TrackId;
-    mediaStreamTrackId: MediaStreamTrackId | null;
-    mLineId: MLineId | null;
-    readonly trackContext: TrackContextImpl;
-    private sender;
-    readonly encodings: TrackEncodings;
-    connection: ConnectionManager | undefined;
-    constructor(connection: ConnectionManager | undefined, id: LocalTrackId, trackContext: TrackContextImpl);
-    updateSender: () => void;
-    updateConnection: (connection: ConnectionManager) => void;
-    disableTrackEncoding: (encoding: Variant) => Promise<void>;
-    addTrackToConnection: () => void;
-    private updateEncodings;
-    removeFromConnection: () => void;
-    replaceTrack: (newTrack: MediaStreamTrack | null, webrtc: WebRTCEndpoint) => Promise<void>;
-    setTrackBandwidth: (bandwidth: BandwidthLimit) => Promise<void>;
-    setEncodingBandwidth(variant: Variant, bandwidth: BandwidthLimit): Promise<void>;
-    updateTrackMetadata: (metadata: unknown) => void;
-    enableTrackEncoding: (encoding: Variant) => Promise<void>;
-    setMLineId: (mLineId: MLineId) => void;
-    private isNotSimulcastTrack;
-    getTrackBitrates: () => Bitrates | undefined;
-    createTrackVariantBitratesEvent: () => void;
-}

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

@@ -1,212 +0,0 @@
-import { Variant } from '@fishjam-cloud/protobufs/shared';
-import { defaultBitrates, defaultSimulcastBitrates, UNLIMITED_BANDWIDTH } from '../bitrate';
-import { encodingToVariantMap, getEncodingParameters } from './encodings';
-import { emitMutableEvents, getActionType } from './muteTrackUtils';
-import { createTransceiverConfig } from './transceivers';
-/**
- * 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 = {
-        [Variant.UNRECOGNIZED]: false,
-        [Variant.VARIANT_UNSPECIFIED]: false,
-        [Variant.VARIANT_LOW]: false,
-        [Variant.VARIANT_MEDIUM]: false,
-        [Variant.VARIANT_HIGH]: false,
-    };
-    connection;
-    constructor(connection, id, trackContext) {
-        this.connection = connection;
-        this.id = id;
-        this.trackContext = trackContext;
-        // todo maybe we could remove this object and use sender.getParameters().encodings.encodingParameter.active instead
-        if (trackContext.track?.id) {
-            this.mediaStreamTrackId = trackContext.track?.id;
-        }
-    }
-    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 && encodingToVariantMap[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);
-    };
-    updateEncodings = () => {
-        const enabledVariants = this.trackContext.simulcastConfig?.enabledVariants;
-        if (this.trackContext?.track?.kind === 'video' && enabledVariants) {
-            this.encodings[Variant.VARIANT_LOW] = enabledVariants.some((e) => e === Variant.VARIANT_LOW);
-            this.encodings[Variant.VARIANT_MEDIUM] = enabledVariants.some((e) => e === Variant.VARIANT_MEDIUM);
-            this.encodings[Variant.VARIANT_HIGH] = enabledVariants.some((e) => e === Variant.VARIANT_HIGH);
-        }
-    };
-    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);
-        }
-        const action = getActionType(this.trackContext.track, newTrack);
-        this.trackContext.track = newTrack;
-        this.mediaStreamTrackId = newTrack?.id ?? null;
-        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(variant, bandwidth) {
-        if (!this.sender)
-            throw new Error(`RTCRtpSender for track ${this.id} not found`);
-        const parameters = this.sender.getParameters();
-        const encoding = parameters.encodings.find((enc) => enc.rid && encodingToVariantMap[enc.rid] === variant);
-        if (!encoding) {
-            return Promise.reject(`Encoding with Variant '${variant}' doesn't exist`);
-        }
-        else if (bandwidth === 0) {
-            delete encoding.maxBitrate;
-        }
-        else {
-            encoding.maxBitrate = bandwidth * 1024;
-        }
-        return this.sender.setParameters(parameters);
-    }
-    updateTrackMetadata = (metadata) => {
-        this.trackContext.metadata = metadata;
-    };
-    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 && encodingToVariantMap[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);
-    };
-    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)
-            return undefined;
-        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 variant = encodingToVariantMap[encoding.rid] ?? Variant.VARIANT_UNSPECIFIED;
-            acc[variant] = encoding.maxBitrate || defaultSimulcastBitrates[variant];
-            return acc;
-        }, {});
-    };
-    createTrackVariantBitratesEvent = () => {
-        // TODO implement this when simulcast is supported
-        // return generateCustomEvent({
-        //   type: 'trackVariantBitrates',
-        //   data: {
-        //     trackId: this.id,
-        //     variantBitrates: this.getTrackBitrates(),
-        //   },
-        // });
-    };
-}

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

@@ -1,39 +0,0 @@
-import { type MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
-import type { SimulcastConfig } from '..';
-import type { ConnectionManager } from '../ConnectionManager';
-import type { TrackBandwidthLimit } from '../types';
-import type { WebRTCEndpoint } from '../webRTCEndpoint';
-import type { Local } from './Local';
-/**
- * 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 {
-    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, sendMediaEvent: (mediaEvent: PeerMediaEvent) => void);
-    isNegotiationInProgress: () => boolean;
-    cleanUp: () => void;
-    parseAddTrack: (track: MediaStreamTrack, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
-    addTrackHandler: (trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: unknown | undefined, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
-    removeTrackHandler: (trackId: string) => void;
-    replaceTrackHandler: (webrtc: WebRTCEndpoint, trackId: string, newTrack: MediaStreamTrack | null) => Promise<void>;
-    getEndpointId: () => string;
-    updateConnection: (connection: ConnectionManager) => void;
-    updateSenders: () => void;
-}

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

@@ -1,76 +0,0 @@
-import { MediaEvent_RenegotiateTracks } from '@fishjam-cloud/protobufs/peer';
-/**
- * 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();
-        }
-        this.sendMediaEvent({ renegotiateTracks: MediaEvent_RenegotiateTracks.create() });
-    };
-    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/webrtc-client/src/tracks/Remote.d.ts

@@ -1,32 +0,0 @@
-import type { MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
-import type { MediaEvent_Track } from '@fishjam-cloud/protobufs/server';
-import { MediaEvent_VadNotification_Status } from '@fishjam-cloud/protobufs/server';
-import type { Variant } from '@fishjam-cloud/protobufs/shared';
-import type { EndpointWithTrackContext } from '../internal';
-import type { EncodingReason, MetadataJson, RemoteTrackId, TrackContext, WebRTCEndpointEvents } from '../types';
-import { RemoteTrack } from './RemoteTrack';
-import type { EndpointId, TrackId } from './TrackCommon';
-export declare class Remote {
-    private readonly remoteTracks;
-    private readonly remoteEndpoints;
-    private readonly emit;
-    private readonly sendMediaEvent;
-    constructor(emit: <E extends keyof Required<WebRTCEndpointEvents>>(event: E, ...args: Parameters<Required<WebRTCEndpointEvents>[E]>) => void, sendMediaEvent: (mediaEvent: PeerMediaEvent) => void);
-    getTrackByMid: (mid: string) => RemoteTrack;
-    addTracks: (endpointId: EndpointId, tracks: Record<TrackId, MediaEvent_Track>) => void;
-    removeTracks: (trackIds: TrackId[]) => void;
-    private removeRemoteTrack;
-    addRemoteEndpoint: (endpointId: string, metadataJson?: MetadataJson, tracks?: Record<RemoteTrackId, MediaEvent_Track>, sendNotification?: boolean) => void;
-    private addEndpoint;
-    updateRemoteEndpoint: (endpointId: string, metadataJson?: MetadataJson) => void;
-    removeRemoteEndpoint: (endpointId: EndpointId) => void;
-    updateRemoteTrack: (endpointId: string, trackId: string, metadataJson?: MetadataJson) => void;
-    disableRemoteTrackEncoding: (trackId: TrackId, encoding: Variant) => void;
-    enableRemoteTrackEncoding: (trackId: TrackId, encoding: Variant) => void;
-    setRemoteTrackEncoding: (trackId: TrackId, encoding: Variant, reason?: EncodingReason) => void;
-    setRemoteTrackVadStatus: (trackId: TrackId, vadStatus: MediaEvent_VadNotification_Status) => void;
-    getRemoteTrackContexts: () => Record<string, TrackContext>;
-    getRemoteEndpoints: () => Record<string, EndpointWithTrackContext>;
-    setTargetRemoteTrackEncoding: (trackId: TrackId, variant: Variant) => void;
-    updateMLineIds: (midToTrackIds: Record<string, string>) => void;
-}