@livedigital/client 3.48.0 → 3.49.0

package/src/helpers/channelMessageConverter.ts

@@ -1,124 +0,0 @@
-import type { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import type { PeerGroup, PeerResponse, ProducerData, Role } from '../types/common';
-import { TrackLabel } from '../types/common';
-import { ProducerLabel } from '../proto/generated/producer/producer_label';
-import type { Producer as ChannelMessageProducer } from '../proto/generated/producer/producer';
-import type { Peer as ChannelMessagePeer } from '../proto/generated/peer/peer';
-import { PeerGroup as ChannelMessagePeerGroup } from '../proto/generated/peer/peer_group';
-import { PeerRole as ChannelMessagePeerRole } from '../proto/generated/peer/peer_role';
-import { ProducerKind as ChannelMessageProducerKind } from '../proto/generated/producer/producer_kind';
-
-const producerKindToMediaKindMapping: Partial<Record<ChannelMessageProducerKind, MediaKind>> = {
-  [ChannelMessageProducerKind.PRODUCER_KIND_VIDEO]: 'video',
-  [ChannelMessageProducerKind.PRODUCER_KIND_AUDIO]: 'audio',
-};
-
-const channelMessagePeerRoleToPeerRole: Partial<Record<ChannelMessagePeerRole, Role>> = {
-  [ChannelMessagePeerRole.PEER_ROLE_HOST]: 'host',
-  [ChannelMessagePeerRole.PEER_ROLE_AUDIENCE]: 'audience',
-};
-
-const producerLabelToTrackLabelMapping: Partial<Record<ProducerLabel, TrackLabel>> = {
-  [ProducerLabel.PRODUCER_LABEL_CAMERA]: TrackLabel.Camera,
-  [ProducerLabel.PRODUCER_LABEL_MICROPHONE]: TrackLabel.Microphone,
-  [ProducerLabel.PRODUCER_LABEL_SCREEN_VIDEO]: TrackLabel.ScreenVideo,
-  [ProducerLabel.PRODUCER_LABEL_SCREEN_AUDIO]: TrackLabel.ScreenAudio,
-  [ProducerLabel.PRODUCER_LABEL_CUSTOM_VIDEO]: TrackLabel.CustomVideo,
-  [ProducerLabel.PRODUCER_LABEL_CUSTOM_AUDIO]: TrackLabel.CustomAudio,
-  [ProducerLabel.PRODUCER_LABEL_UNKNOWN]: TrackLabel.Unknown,
-  [ProducerLabel.PRODUCER_LABEL_UNSPECIFIED]: TrackLabel.Unknown,
-};
-
-const channelMessagePeerGroupToPeerGroupMapping: Partial<Record<ChannelMessagePeerGroup, PeerGroup>> = {
-  [ChannelMessagePeerGroup.PEER_GROUP_MODERATOR]: 'moderator',
-  [ChannelMessagePeerGroup.PEER_GROUP_USER]: 'user',
-};
-
-export const convertChannelMessageProducerKindToMediaKind =
-  (producerKind: ChannelMessageProducerKind): MediaKind => {
-    const mediaKind = producerKindToMediaKindMapping[producerKind];
-
-    if (!mediaKind) {
-      throw new Error(`Unknown producer kind: ${ producerKind }`);
-    }
-
-    return mediaKind;
-  };
-
-export const convertChannelMessagePeerGroupsToPeerGroups = (
-  peerGroup: ChannelMessagePeerGroup,
-): PeerGroup => {
-  const group = channelMessagePeerGroupToPeerGroupMapping[peerGroup];
-
-  if (!group) {
-    throw new Error(`Unknown peer group: ${ peerGroup }`);
-  }
-
-  return group;
-};
-
-export const convertChannelMessageProducerLabelsToTrackLabels = (
-  producerLabel: ProducerLabel,
-): TrackLabel => {
-  const label = producerLabelToTrackLabelMapping[producerLabel];
-
-  if (!label) {
-    throw new Error(`Unknown producer label: ${ producerLabel }`);
-  }
-
-  return label;
-};
-
-export const convertChannelMessagePeerRoleToRole = (peerRole: ChannelMessagePeerRole): Role => {
-  const role = channelMessagePeerRoleToPeerRole[peerRole];
-
-  if (!role) {
-    throw new Error(`Unknown peer role: ${ peerRole }`);
-  }
-
-  return role;
-};
-
-export const convertChannelMessagePeerToPeerResponse = (
-  peer: ChannelMessagePeer,
-): PeerResponse => {
-  return {
-    id: peer.id,
-    channelIds: peer.channelIds,
-    groups: peer.groups.map(convertChannelMessagePeerGroupsToPeerGroups),
-    producePermissions: peer.producePermissions.map(convertChannelMessageProducerLabelsToTrackLabels),
-    appId: peer.appId,
-    producers: peer.producers.map(convertChannelMessageProducerToProducerData),
-    uid: peer.uid,
-    appData: peer.appData,
-    role: convertChannelMessagePeerRoleToRole(peer.role),
-    loginDate: peer.loginDate as unknown as Date,
-  };
-};
-
-export const convertChannelMessageProducerToProducerData = (
-  producer: ChannelMessageProducer,
-): ProducerData => {
-  return {
-    id: producer.id,
-    kind: convertChannelMessageProducerKindToMediaKind(producer.kind),
-    label: convertChannelMessageProducerLabelsToTrackLabels(producer.label),
-    peerId: producer.peerId,
-    paused: producer.paused,
-    encodings: producer.encodings as unknown as ProducerData['encodings'],
-    maxSpatialLayer: producer.maxSpatialLayer ?? 0,
-  };
-};
-
-export const convertPeerGroupsToChannelMessagePeerGroups = (
-  peerGroup: PeerGroup,
-): ChannelMessagePeerGroup => {
-  switch (peerGroup) {
-    case 'moderator':
-      return ChannelMessagePeerGroup.PEER_GROUP_MODERATOR;
-    case 'user':
-      return ChannelMessagePeerGroup.PEER_GROUP_USER;
-    default:
-      return ChannelMessagePeerGroup.PEER_GROUP_UNSPECIFIED;
-  }
-};

package/src/helpers/common.ts

@@ -1,96 +0,0 @@
-import { LogLevels } from '../constants/common';
-import type { LogLevel } from '../types/common';
-
-declare global {
-  interface Window {
-    _sdkMarks: Set<string>;
-  }
-}
-
-type PlainObject = Record<string, unknown>;
-
-export function isObject(value: unknown): value is PlainObject {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-export function deepEqualObject(object1: PlainObject, object2: PlainObject): boolean {
-  const keysOfObject1 = Object.keys(object1);
-  const keysObObject2 = Object.keys(object2);
-
-  if (keysOfObject1.length !== keysObObject2.length) {
-    return false;
-  }
-
-  let isEquals = true;
-
-  keysOfObject1.forEach((key) => {
-    const object1Element = object1[key];
-    const object2Element = object2[key];
-    const areObjects = isObject(object1Element) && isObject(object2Element);
-
-    const isObjectAndNotEquals = areObjects && !deepEqualObject(object1Element, object2Element);
-    const isNotObjectAndNotEquals = !areObjects && (object1Element !== object2Element);
-
-    if (isObjectAndNotEquals || isNotObjectAndNotEquals) {
-      isEquals = false;
-    }
-  });
-
-  return isEquals;
-};
-
-export function debounce<T extends(...args: never[]) => Promise<void>>(callback: T, delay: number, immediate = false) {
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-
-  return async function debounced(this: unknown, ...args: Parameters<typeof callback>): Promise<void> {
-    const later = async (): Promise<void> => {
-      timeout = null;
-
-      if (!immediate) {
-        await callback.apply(this, args);
-      }
-    };
-
-    const callNow = immediate && !timeout;
-
-    if (typeof timeout === 'number') {
-      clearTimeout(timeout);
-    }
-
-    timeout = setTimeout(later, delay);
-
-    if (callNow) {
-      await callback.apply(this, args);
-    }
-  };
-}
-
-export function prepareLogLevel(level?: LogLevel): LogLevel {
-  return level ?? LogLevels.Error;
-}
-
-export function isAnalyticsActive(flag?: boolean): boolean {
-  return flag ?? true;
-}
-
-export function markSDKInstance(mark: string): void {
-  window._sdkMarks ||= new Set<string>();
-  window._sdkMarks.add(mark);
-}
-
-export function getSDKInstancesMarks(): string[] {
-  return Array.from(window._sdkMarks || []);
-}
-
-export async function safeCall<T>(
-  handler: () => Promise<T>,
-  onError?: (error: unknown) => void,
-): Promise<T | undefined> {
-  try {
-    return await handler();
-  } catch (error) {
-    onError?.(error);
-
-    return undefined;
-  }
-}

package/src/helpers/datetime.ts

@@ -1,11 +0,0 @@
-class DefaultTimeProvider {
-  async sleepMs(ms: number): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  now(): Date {
-    return new Date(Date.now());
-  }
-}
-
-export default DefaultTimeProvider;

package/src/helpers/errors.ts

@@ -1,25 +0,0 @@
-export const hasStringMessage = (value: unknown): value is { message: string } => {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-
-  const { message } = (value as Record<string, unknown>);
-
-  return typeof message === 'string';
-};
-
-export const getErrorMessage = (err: unknown): string | undefined => {
-  if (err instanceof Error) {
-    return err.message;
-  }
-
-  if (typeof err === 'string') {
-    return err;
-  }
-
-  if (hasStringMessage(err)) {
-    return err.message;
-  }
-
-  return undefined;
-};

package/src/helpers/filterStatsCodecs.ts

@@ -1,3 +0,0 @@
-const filterStatsCodecs = (codec: RTCRtpCodecParameters): boolean => codec.mimeType !== 'rtx';
-
-export default filterStatsCodecs;

package/src/helpers/loader.ts

@@ -1,59 +0,0 @@
-import loadScript from 'load-script';
-import DefaultTimeProvider from './datetime';
-
-const timeProvider = new DefaultTimeProvider();
-const MAX_RETRIES_DEFAULT = 3;
-const RETRY_DELAY_DEFAULT = 500;
-
-export const asyncLoadScript = async (
-  url: string,
-): Promise<HTMLScriptElement> => await new Promise((resolve, reject) => {
-  loadScript(
-    url,
-    (err: Error | null, script: HTMLScriptElement) => {
-      if (err) {
-        reject(err);
-
-        return;
-      }
-
-      resolve(script);
-    },
-  );
-});
-
-export const loadScriptWithRetries = async (
-  url: string,
-  maxRetries = MAX_RETRIES_DEFAULT,
-  retryDelayMs = RETRY_DELAY_DEFAULT,
-): Promise<void> => {
-  let retries = 0;
-
-  while (retries < maxRetries) {
-    try {
-      await asyncLoadScript(url);
-
-      return;
-    } catch (error) {
-      retries += 1;
-
-      if (retries < maxRetries) {
-        await timeProvider.sleepMs(retryDelayMs);
-      } else {
-        throw error;
-      }
-    }
-  }
-};
-
-export const loadScriptWithFallback = async (mainUrl: string, fallbackUrl?: string): Promise<void> => {
-  try {
-    await loadScriptWithRetries(mainUrl);
-  } catch (error) {
-    if (!fallbackUrl) {
-      throw error;
-    }
-
-    await loadScriptWithRetries(fallbackUrl);
-  }
-};

package/src/helpers/media.ts

@@ -1,57 +0,0 @@
-import type { Device, types } from 'mediasoup-client';
-import Bowser from 'bowser';
-
-export const detectHandlerName = (userAgent?: string): types.BuiltinHandlerName | undefined => {
-  const ua = userAgent ?? navigator?.userAgent;
-
-  if (!ua) {
-    return undefined;
-  }
-
-  const browser = Bowser.getParser(ua);
-
-  if (browser.satisfies({ 'yandex browser': '>=25' }) && browser.getOSName() === 'iOS') {
-    return undefined;
-  }
-
-  if (browser.satisfies({ 'yandex browser': '>=23.7' })) {
-    return 'Chrome111';
-  }
-
-  if (browser.satisfies({ 'yandex browser': '>=22' })) {
-    return 'Chrome74';
-  }
-
-  if (browser.satisfies({ 'Samsung Internet for Android': '>=17' })) {
-    return 'Chrome111';
-  }
-
-  return undefined;
-};
-
-export const getNewAudioContext = (contextOptions?: AudioContextOptions): AudioContext | null => {
-  const Context = window.AudioContext // Default
-    || (window as unknown as { webkitAudioContext: unknown }).webkitAudioContext // Safari and old versions of Chrome
-    || false;
-
-  if (Context) {
-    return new Context(contextOptions);
-  }
-
-  return null;
-};
-
-export const getSupportedCodecsMimeTypes = (device: Device): string[] => device
-  .rtpCapabilities
-  .codecs
-  ?.reduce((acc: string[], codec: types.RtpCodecCapability) => {
-    const preparedCodec = codec.mimeType?.toLowerCase();
-
-    if (preparedCodec && !acc.includes(preparedCodec)) {
-      acc.push(preparedCodec);
-    }
-
-    return acc;
-  }, []) ?? [];
-
-export const isVp9 = (codecOrMimeType: string): boolean => ['video/vp9', 'vp9'].includes(codecOrMimeType.toLowerCase());

package/src/helpers/peer.ts

@@ -1,19 +0,0 @@
-import type Peer from '../engine/Peer';
-
-interface PeerLogResponse {
-  id: Peer['id'];
-  appId: Peer['appId'];
-  role: Peer['role'];
-  groups: Peer['groups'];
-  producePermissions: Peer['producePermissions'];
-}
-
-export function logResponse(peer: Peer): PeerLogResponse {
-  return {
-    id: peer.id,
-    appId: peer.appId,
-    role: peer.role,
-    groups: peer.groups,
-    producePermissions: peer.producePermissions,
-  };
-}

package/src/helpers/randomString.ts

@@ -1,18 +0,0 @@
-// eslint-disable-next-line
-const hexLUT: string[] = Array.from({ length: 256 }, (_, i) => (i + 256).toString(16).slice(1));
-
-const RANDOM_STR_LENGTH = 24;
-
-export function randomString(len: number = RANDOM_STR_LENGTH): string {
-  const buf = new Uint8Array(len);
-  crypto.getRandomValues(buf);
-
-  let result = '';
-
-  // eslint-disable-next-line
-  for (let i = 0; i < buf.length; i++) {
-    result += hexLUT[buf[i]];
-  }
-
-  return result;
-}

package/src/helpers/retry.ts

@@ -1,74 +0,0 @@
-import { serializeError } from 'serialize-error';
-import DefaultTimeProvider from './datetime';
-import type Logger from '../engine/Logger';
-
-export interface RetryOpts {
-  maxRetries?: number;
-  minBackoffDelayMs?: number;
-  maxBackoffDelayMs?: number;
-  actionName?: string; // human-readable action name for debug purposes
-  logger?: Logger;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  abortOnError?: (error: any) => boolean;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  onError?: (error: any) => Promise<void>;
-}
-
-const timeProvider = new DefaultTimeProvider();
-
-const MAX_RETRIES_DEFAULT = 2;
-const BACKOFF_DELAY_DEFAULT = 50;
-const RETRY_DELAY_FACTOR = 2;
-
-const retryAsync = async <ReturnType>(
-  action: () => Promise<ReturnType>,
-  opts: RetryOpts = {},
-): Promise<ReturnType> => {
-  const maxRetries = opts.maxRetries ?? MAX_RETRIES_DEFAULT;
-  const minBackoffDelayMs = opts.minBackoffDelayMs ?? BACKOFF_DELAY_DEFAULT;
-  let currentAttempt = 0;
-  let lastError: Error | undefined = undefined;
-
-  while (currentAttempt < maxRetries) {
-    currentAttempt += 1;
-
-    try {
-      return await action();
-    } catch (err: unknown) {
-      lastError = err as Error;
-
-      if (opts.logger) {
-        opts.logger.info('Action retry failed', {
-          currentAttempt,
-          actionName: opts.actionName,
-          error: serializeError(err),
-        });
-      }
-
-      if (opts.abortOnError?.(err)) {
-        throw lastError;
-      }
-
-      if (opts.onError) {
-        await opts.onError(err);
-      }
-
-      if (currentAttempt < maxRetries) {
-        const delay = RETRY_DELAY_FACTOR ** (currentAttempt - 1) * minBackoffDelayMs;
-
-        await timeProvider.sleepMs(Math.min(delay, opts.maxBackoffDelayMs ?? delay));
-      }
-    }
-  }
-
-  throw lastError ?? new Error('retryAsync logic failed');
-};
-
-const retry = async <ReturnType extends () => ReturnType>(
-  action: () => ReturnType,
-  opts: RetryOpts = {},
-// eslint-disable-next-line @typescript-eslint/require-await
-): Promise<ReturnType> => await retryAsync(async () => action(), opts);
-
-export { retryAsync };
-export default retry;

package/src/index.ts

@@ -1,171 +0,0 @@
-import 'reflect-metadata';
-import ConfigService from './config/ConfigService';
-import type Engine from './engine';
-import type { IntegrationsService } from './engine/IntegrationsService';
-import type Peer from './engine/Peer';
-import type { TransportsWebRTCStats } from './engine/WebRTCStats/types';
-import EnhancedEventEmitter from './EnhancedEventEmitter';
-import OperationError from './errors/OperationError';
-import { container } from './inversify.config';
-import { TOKEN } from './inversify.tokens';
-import type { ClientParams } from './types/client';
-import type {
-  AvailableMediaDevices,
-  CreateCameraVideoTrackOptions,
-  CreateCustomAudioOptions,
-  CreateCustomVideoOptions,
-  CreateMicrophoneAudioTrackOptions,
-  CreateScreenMediaOptions,
-  JoinChannelParams,
-  Role,
-  TransportsStateInfo,
-} from './types/common';
-import type { ClientObserverEvents } from './types/engine';
-import type { AudioTrack, Track, VideoTrack } from './types/media';
-
-class Client {
-  readonly #engine: Engine;
-
-  private readonly clientEventEmitter: EnhancedEventEmitter;
-
-  readonly canUseNoiseSuppression = true;
-
-  constructor(params: ClientParams) {
-    const { clientEventEmitter, internalEventEmitter } = params;
-
-    container
-      .bind<ConfigService>(TOKEN.Config)
-      .toDynamicValue(() => new ConfigService(params))
-      .inSingletonScope();
-
-    container
-      .bind<EnhancedEventEmitter>(TOKEN.InternalEventEmitter)
-      .toDynamicValue(() => internalEventEmitter ?? new EnhancedEventEmitter())
-      .inSingletonScope();
-
-    container
-      .bind<EnhancedEventEmitter>(TOKEN.ClientEventEmitter)
-      .toDynamicValue(() => clientEventEmitter ?? new EnhancedEventEmitter())
-      .inSingletonScope();
-
-    container.get<IntegrationsService>(TOKEN.IntegrationsService); // instantiate service
-
-    this.clientEventEmitter = container.get<EnhancedEventEmitter>(TOKEN.ClientEventEmitter);
-
-    this.#engine = container.get<Engine>(TOKEN.Engine);
-  }
-
-  get observer(): EnhancedEventEmitter<ClientObserverEvents> {
-    return this.clientEventEmitter;
-  }
-
-  get id(): string | undefined {
-    return this.#engine.myPeerId;
-  }
-
-  get peers(): Peer[] {
-    return this.#engine.getPeers();
-  }
-
-  get availableVideoDevices(): MediaDeviceInfo[] {
-    return this.#engine.system.availableVideoDevices;
-  }
-
-  get availableAudioDevices(): MediaDeviceInfo[] {
-    return this.#engine.system.availableAudioDevices;
-  }
-
-  get effectsSDKInitialized(): boolean {
-    return this.#engine.media.effectsSDKInitialized;
-  }
-
-  async detectDevices(force?: boolean): Promise<AvailableMediaDevices> {
-    try {
-      await this.#engine.system.detectDevices(force);
-    } catch (error) {
-      const errorCode = error instanceof Error ? error.message : 'detect_devices_failed';
-      throw new OperationError(errorCode, error);
-    }
-
-    return {
-      video: this.#engine.system.availableVideoDevices,
-      audio: this.#engine.system.availableAudioDevices,
-    };
-  }
-
-  async initEffectsSDK(): Promise<boolean> {
-    return await this.#engine.media.initEffectsSDK();
-  }
-
-  async join(params: JoinChannelParams): Promise<void> {
-    await this.#engine.join(params);
-  }
-
-  async leave(keepTracks?: boolean): Promise<void> {
-    await this.#engine.release(keepTracks);
-  }
-
-  async confirmActivity(): Promise<void> {
-    await this.#engine.confirmActivity();
-  }
-
-  async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack> {
-    return await this.#engine.createCameraVideoTrack(options);
-  }
-
-  async createMicrophoneAudioTrack(
-    options?: CreateMicrophoneAudioTrackOptions,
-  ): Promise<AudioTrack> {
-    return await this.#engine.createMicrophoneAudioTrack(options);
-  }
-
-  async createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]> {
-    return await this.#engine.createScreenMediaTracks(options);
-  }
-
-  createCustomAudioTrack(options: CreateCustomAudioOptions): Track {
-    return this.#engine.createCustomAudioTrack(options);
-  }
-
-  createCustomVideoTrack(options: CreateCustomVideoOptions): Track {
-    return this.#engine.createCustomVideoTrack(options);
-  }
-
-  async deleteTrack(track: Track): Promise<void> {
-    await this.#engine.deleteTrack(track);
-  }
-
-  async loadPeers(role?: Role): Promise<void> {
-    await this.#engine.loadPeers(role);
-  }
-
-  requestChannelStateSync(): void {
-    this.#engine.requestChannelStateSync();
-  }
-
-  async updateAppData(appData: Record<string, unknown>): Promise<void> {
-    await this.#engine.updateAppData(appData);
-  }
-
-  public async getTransportsInfo(): Promise<TransportsStateInfo> {
-    return await this.#engine.network.getTransportsStateInfo();
-  }
-
-  public setPreferRelay(value: boolean): void {
-    this.#engine.network.setPreferRelay(value);
-  }
-
-  public getPreferRelay(): boolean {
-    return this.#engine.network.getPreferRelay();
-  }
-
-  public transportsStats(): TransportsWebRTCStats | undefined {
-    return this.#engine.transportsStats();
-  }
-
-  public setSignalingServerUrl(url: string): void {
-    this.#engine.setSignalingServerUrl(url);
-  }
-}
-
-export default Client;