livekit-client 1.14.0 → 1.14.2

package/src/room/track/LocalTrack.ts

@@ -34,7 +34,7 @@ export default abstract class LocalTrack extends Track {
 
   protected processorElement?: HTMLMediaElement;
 
-  protected processor?: TrackProcessor<typeof this.kind>;
+  protected processor?: TrackProcessor<this['kind']>;
 
   protected processorLock: Mutex;
 
@@ -163,6 +163,12 @@ export default abstract class LocalTrack extends Track {
       throw new Error('cannot get dimensions for audio tracks');
     }
 
+    if (getBrowser()?.os === 'iOS') {
+      // browsers report wrong initial resolution on iOS.
+      // when slightly delaying the call to .getSettings(), the correct resolution is being reported
+      await sleep(10);
+    }
+
     const started = Date.now();
     while (Date.now() - started < timeout) {
       const dims = this.dimensions;
@@ -396,10 +402,7 @@ export default abstract class LocalTrack extends Track {
    * @param showProcessedStreamLocally
    * @returns
    */
-  async setProcessor(
-    processor: TrackProcessor<typeof this.kind>,
-    showProcessedStreamLocally = true,
-  ) {
+  async setProcessor(processor: TrackProcessor<this['kind']>, showProcessedStreamLocally = true) {
     const unlock = await this.processorLock.lock();
     try {
       log.debug('setting up processor');

package/src/room/track/LocalVideoTrack.ts

@@ -284,7 +284,8 @@ export default class LocalVideoTrack extends LocalTrack {
 
   /**
    * @internal
-   * Sets codecs that should be publishing
+   * Sets codecs that should be publishing, returns new codecs that have not yet
+   * been published
    */
   async setPublishingCodecs(codecs: SubscribedCodec[]): Promise<VideoCodec[]> {
     log.debug('setting publishing codecs', {

package/src/room/track/RemoteTrack.ts

@@ -29,14 +29,16 @@ export default abstract class RemoteTrack extends Track {
   /** @internal */
   setMediaStream(stream: MediaStream) {
     // this is needed to determine when the track is finished
-    // we send each track down in its own MediaStream, so we can assume the
-    // current track is the only one that can be removed.
     this.mediaStream = stream;
-    stream.onremovetrack = () => {
-      this.receiver = undefined;
-      this._currentBitrate = 0;
-      this.emit(TrackEvent.Ended, this);
+    const onRemoveTrack = (event: MediaStreamTrackEvent) => {
+      if (event.track === this._mediaStreamTrack) {
+        stream.removeEventListener('removetrack', onRemoveTrack);
+        this.receiver = undefined;
+        this._currentBitrate = 0;
+        this.emit(TrackEvent.Ended, this);
+      }
     };
+    stream.addEventListener('removetrack', onRemoveTrack);
   }
 
   start() {

package/src/room/track/options.ts

@@ -109,6 +109,13 @@ export interface TrackPublishOptions extends TrackPublishDefaults {
    * Source of track, camera, microphone, or screen
    */
   source?: Track.Source;
+
+  /**
+   * Set stream name for the track. Audio and video tracks with the same stream name
+   * will be placed in the same `MediaStream` and offer better synchronization.
+   * By default, camera and microphone will be placed in a stream; as would screen_share and screen_share_audio
+   */
+  stream?: string;
 }
 
 export interface CreateLocalTracksOptions {
@@ -294,13 +301,6 @@ export function isBackupCodec(codec: string): codec is BackupVideoCodec {
   return !!backupCodecs.find((backup) => backup === codec);
 }
 
-export function isCodecEqual(c1: string | undefined, c2: string | undefined): boolean {
-  return (
-    c1?.toLowerCase().replace(/audio\/|video\//y, '') ===
-    c2?.toLowerCase().replace(/audio\/|video\//y, '')
-  );
-}
-
 /**
  * scalability modes for svc.
  */

package/src/room/track/utils.ts

@@ -1,10 +1,13 @@
+import { cloneDeep } from '../../utils/cloneDeep';
 import { isSafari, sleep } from '../utils';
 import { Track } from './Track';
-import type {
-  AudioCaptureOptions,
-  CreateLocalTracksOptions,
-  ScreenShareCaptureOptions,
-  VideoCaptureOptions,
+import {
+  type AudioCaptureOptions,
+  type CreateLocalTracksOptions,
+  type ScreenShareCaptureOptions,
+  type VideoCaptureOptions,
+  VideoCodec,
+  videoCodecs,
 } from './options';
 import type { AudioTrack } from './types';
 
@@ -13,9 +16,7 @@ export function mergeDefaultOptions(
   audioDefaults?: AudioCaptureOptions,
   videoDefaults?: VideoCaptureOptions,
 ): CreateLocalTracksOptions {
-  const opts: CreateLocalTracksOptions = {
-    ...options,
-  };
+  const opts: CreateLocalTracksOptions = cloneDeep(options) ?? {};
   if (opts.audio === true) opts.audio = {};
   if (opts.video === true) opts.video = {};
 
@@ -181,3 +182,11 @@ export function screenCaptureToDisplayMediaStreamOptions(
     systemAudio: options.systemAudio,
   };
 }
+
+export function mimeTypeToVideoCodecString(mimeType: string) {
+  const codec = mimeType.split('/')[1].toLowerCase() as VideoCodec;
+  if (!videoCodecs.includes(codec)) {
+    throw Error(`Video codec not supported: ${codec}`);
+  }
+  return codec;
+}

package/src/room/utils.ts

@@ -61,6 +61,9 @@ export function supportsAV1(): boolean {
 
 export function supportsVP9(): boolean {
   if (!('getCapabilities' in RTCRtpSender)) {
+    return false;
+  }
+  if (isFireFox()) {
     // technically speaking FireFox supports VP9, but SVC publishing is broken
     // https://bugzilla.mozilla.org/show_bug.cgi?id=1633876
     return false;

package/src/utils/cloneDeep.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cloneDeep } from './cloneDeep';
+
+describe('cloneDeep', () => {
+  beforeEach(() => {
+    global.structuredClone = vi.fn((val) => {
+      return JSON.parse(JSON.stringify(val));
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should clone a simple object', () => {
+    const structuredCloneSpy = vi.spyOn(global, 'structuredClone');
+
+    const original = { name: 'John', age: 30 };
+    const cloned = cloneDeep(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(structuredCloneSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should clone an object with nested properties', () => {
+    const structuredCloneSpy = vi.spyOn(global, 'structuredClone');
+
+    const original = { name: 'John', age: 30, children: [{ name: 'Mark', age: 7 }] };
+    const cloned = cloneDeep(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(cloned?.children).not.toBe(original.children);
+    expect(structuredCloneSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should use JSON namespace as a fallback', () => {
+    const structuredCloneSpy = vi.spyOn(global, 'structuredClone');
+    const serializeSpy = vi.spyOn(JSON, 'stringify');
+    const deserializeSpy = vi.spyOn(JSON, 'parse');
+
+    global.structuredClone = undefined as any;
+
+    const original = { name: 'John', age: 30 };
+    const cloned = cloneDeep(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(structuredCloneSpy).not.toHaveBeenCalled();
+    expect(serializeSpy).toHaveBeenCalledTimes(1);
+    expect(deserializeSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/utils/cloneDeep.ts

@@ -0,0 +1,11 @@
+export function cloneDeep<T>(value: T) {
+  if (typeof value === 'undefined') {
+    return;
+  }
+
+  if (typeof structuredClone === 'function') {
+    return structuredClone(value);
+  } else {
+    return JSON.parse(JSON.stringify(value)) as T;
+  }
+}

package/src/version.ts

@@ -1,4 +1,4 @@
 import { version as v } from '../package.json';
 
 export const version = v;
-export const protocolVersion = 9;
+export const protocolVersion = 10;