@fishjam-cloud/react-client/dist/utils/track.js

React client library for Fishjam

import { Variant } from "@fishjam-cloud/ts-client";
// In most cases, the track is identified by its remote track ID.
// This ID comes from the ts-client `addTrack` method.
// However, we don't have that ID before the `addTrack` method returns it.
//
// The `addTrack` method emits the `localTrackAdded` event.
// This event will refresh the internal state of this object.
// However, in that event handler, we don't yet have the remote track ID.
// Therefore, for that brief moment, we will use the local track ID from the MediaStreamTrack object to identify the track.
const getRemoteOrLocalTrackContext = (tsClient, remoteOrLocalTrackId) => {
    const tracks = tsClient?.getLocalPeer()?.tracks;
    if (!tracks)
        return null;
    const trackByRemoteId = tracks?.get(remoteOrLocalTrackId);
    if (trackByRemoteId)
        return trackByRemoteId;
    const trackByLocalId = [...tracks.values()].find(({ track }) => track?.id === remoteOrLocalTrackId);
    return trackByLocalId ?? null;
};
const getTrackFromContext = (context) => ({
    metadata: context.metadata,
    trackId: context.trackId,
    stream: context.stream,
    simulcastConfig: context.simulcastConfig || null,
    encoding: context.encoding || null,
    track: context.track,
});
export const getRemoteOrLocalTrack = (tsClient, remoteOrLocalTrackId) => {
    const context = getRemoteOrLocalTrackContext(tsClient, remoteOrLocalTrackId);
    if (!context)
        return null;
    return getTrackFromContext(context);
};
export function setupOnEndedCallback(track, getCurrentTrackId, callback) {
    track.addEventListener("ended", async (event) => {
        const trackId = event.target.id;
        if (trackId === getCurrentTrackId()) {
            await callback();
        }
    });
}
const getDisabledEncodings = (activeEncodings = []) => {
    const allEncodings = [Variant.VARIANT_LOW, Variant.VARIANT_MEDIUM, Variant.VARIANT_HIGH];
    return allEncodings.filter((encoding) => !activeEncodings.includes(encoding));
};
export const getConfigAndBandwidthFromProps = (encodings, bandwidthLimits) => {
    if (!encodings)
        return [bandwidthLimits.singleStream, undefined];
    const config = {
        enabled: true,
        enabledVariants: encodings,
        disabledVariants: getDisabledEncodings(encodings),
    };
    const variantEntries = Object.entries(bandwidthLimits.simulcast).map(([key, value]) => [Number(key), value]);
    const bandwidth = new Map(variantEntries);
    return [bandwidth, config];
};
function getCertainTypeTracks(stream, type) {
    if (type === "audio")
        return stream.getAudioTracks();
    return stream.getVideoTracks();
}
export function getTrackFromStream(stream, type) {
    return getCertainTypeTracks(stream, type)[0] ?? null;
}
export function stopStream(stream, type) {
    getCertainTypeTracks(stream, type).forEach((track) => {
        track.enabled = false;
        track.stop();
    });
}