livekit-client 2.19.0 → 2.19.2

package/src/room/Room.test.ts

@@ -1,5 +1,5 @@
 import { ClientInfo_Capability, JoinResponse } from '@livekit/protocol';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import Room from './Room';
 import { roomConnectOptionDefaults, roomOptionDefaults } from './defaults';
 import { RoomEvent } from './events';
@@ -89,3 +89,101 @@ describe('Room signaling options', () => {
     );
   });
 });
+
+describe('Room lifecycle', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Tear down the mocked mediaDevices so other tests see the env they
+    // expected (happy-dom does not provide navigator.mediaDevices by default).
+    if ((navigator as { mediaDevices?: unknown }).mediaDevices) {
+      Object.defineProperty(navigator, 'mediaDevices', {
+        configurable: true,
+        value: undefined,
+      });
+    }
+  });
+
+  it('wraps the constructor-registered devicechange listener in a WeakRef so the Room is GC-eligible (#1940)', async () => {
+    // happy-dom does not provide navigator.mediaDevices. Install a minimal
+    // EventTarget stand-in so the constructor takes the listener-registration
+    // branch and we can observe the registered listener.
+    const mediaDevices = new EventTarget() as EventTarget & {
+      addEventListener: EventTarget['addEventListener'];
+      removeEventListener: EventTarget['removeEventListener'];
+    };
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: mediaDevices,
+    });
+
+    const addSpy = vi.spyOn(mediaDevices, 'addEventListener');
+    const derefSpy = vi.spyOn(WeakRef.prototype, 'deref');
+    const cleanupRegistrySpy = Room.cleanupRegistry
+      ? vi.spyOn(Room.cleanupRegistry, 'register')
+      : undefined;
+
+    const room = new Room();
+    const handleDeviceChangeSpy = vi.spyOn(
+      room as unknown as { handleDeviceChange: (ev: Event) => void },
+      'handleDeviceChange',
+    );
+
+    // Constructor must register exactly one devicechange listener with AbortSignal teardown.
+    const deviceChangeAdds = addSpy.mock.calls.filter(([type]) => type === 'devicechange');
+    expect(deviceChangeAdds).toHaveLength(1);
+    const listener = deviceChangeAdds[0][1] as EventListener;
+    const addOptions = deviceChangeAdds[0][2] as AddEventListenerOptions | undefined;
+    expect(addOptions?.signal).toBeInstanceOf(AbortSignal);
+
+    // FinalizationRegistry must be registered with the Room as the target so the
+    // cleanup callback fires when the user drops their Room reference.
+    if (Room.cleanupRegistry) {
+      expect(cleanupRegistrySpy).toHaveBeenCalledWith(room, expect.any(Function));
+    }
+
+    // While the WeakRef still derefs to the Room, the listener forwards to handleDeviceChange.
+    listener.call(null, new Event('devicechange'));
+    expect(handleDeviceChangeSpy).toHaveBeenCalledTimes(1);
+
+    // Simulate the Room being GC'd by forcing deref to return undefined; the
+    // listener must short-circuit instead of calling handleDeviceChange.
+    derefSpy.mockReturnValue(undefined);
+    listener.call(null, new Event('devicechange'));
+    expect(handleDeviceChangeSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('falls back to a direct devicechange listener when WeakRef/FinalizationRegistry are unavailable (#1944)', async () => {
+    const mediaDevices = new EventTarget() as EventTarget & {
+      addEventListener: EventTarget['addEventListener'];
+      removeEventListener: EventTarget['removeEventListener'];
+    };
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: mediaDevices,
+    });
+
+    // Simulate a legacy browser by stubbing out cleanupRegistry.
+    const originalRegistry = Room.cleanupRegistry;
+    Object.defineProperty(Room, 'cleanupRegistry', {
+      configurable: true,
+      value: false,
+    });
+
+    try {
+      const addSpy = vi.spyOn(mediaDevices, 'addEventListener');
+      const room = new Room();
+      const handleDeviceChange = (room as unknown as { handleDeviceChange: () => void })
+        .handleDeviceChange;
+
+      const deviceChangeAdds = addSpy.mock.calls.filter(([type]) => type === 'devicechange');
+      expect(deviceChangeAdds).toHaveLength(1);
+      // The registered listener is the bare handleDeviceChange method (no WeakRef closure).
+      expect(deviceChangeAdds[0][1]).toBe(handleDeviceChange);
+    } finally {
+      Object.defineProperty(Room, 'cleanupRegistry', {
+        configurable: true,
+        value: originalRegistry,
+      });
+    }
+  });
+});

package/src/room/Room.ts

@@ -373,18 +373,34 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     if (isWeb()) {
-      const abortController = new AbortController();
-
-      // in order to catch device changes prior to room connection we need to register the event in the constructor
-      navigator.mediaDevices?.addEventListener?.('devicechange', this.handleDeviceChange, {
-        signal: abortController.signal,
-      });
+      const cleanupController = new AbortController();
+      let onDeviceChange: () => void;
 
       if (Room.cleanupRegistry) {
+        // Wrap the listener in a WeakRef closure so navigator.mediaDevices does not
+        // strongly retain the Room. When the user drops their Room ref, the
+        // FinalizationRegistry callback aborts the controller and removes the listener.
+        const roomRef = new WeakRef(this);
+        onDeviceChange = () => {
+          const self = roomRef.deref();
+          if (!self) {
+            return;
+          }
+          self.handleDeviceChange();
+        };
         Room.cleanupRegistry.register(this, () => {
-          abortController.abort();
+          cleanupController.abort();
         });
+      } else {
+        // Legacy browsers without WeakRef/FinalizationRegistry: fall back to a
+        // direct listener (matches pre-#1944 behavior).
+        onDeviceChange = this.handleDeviceChange;
       }
+
+      // in order to catch device changes prior to room connection we need to register the event in the constructor
+      navigator.mediaDevices?.addEventListener?.('devicechange', onDeviceChange, {
+        signal: cleanupController.signal,
+      });
     }
   }
 
@@ -755,6 +771,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   static cleanupRegistry =
     typeof FinalizationRegistry !== 'undefined' &&
+    typeof WeakRef !== 'undefined' &&
     new FinalizationRegistry((cleanup: () => void) => {
       cleanup();
     });

package/src/room/rpc/client/RpcClientManager.ts

@@ -86,11 +86,14 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
 
     const completionFuture = new Future<string, RpcError>();
 
+    let responseTimeoutId: ReturnType<typeof setTimeout> | null = null;
     const ackTimeoutId = setTimeout(() => {
       this.pendingAcks.delete(id);
       completionFuture.reject?.(RpcError.builtIn('CONNECTION_TIMEOUT'));
       this.pendingResponses.delete(id);
-      clearTimeout(responseTimeoutId);
+      if (responseTimeoutId !== null) {
+        clearTimeout(responseTimeoutId);
+      }
     }, maxRoundTripLatencyMs);
 
     this.pendingAcks.set(id, {
@@ -114,7 +117,7 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
       remoteClientProtocol,
     );
 
-    const responseTimeoutId = setTimeout(() => {
+    responseTimeoutId = setTimeout(() => {
       this.pendingResponses.delete(id);
       completionFuture.reject?.(RpcError.builtIn('RESPONSE_TIMEOUT'));
     }, responseTimeoutMs);

package/src/room/utils.ts

@@ -794,3 +794,8 @@ export function extractMaxAgeFromRequestHeaders(headers: Headers): number | unde
 export function isCompressionStreamSupported() {
   return typeof CompressionStream !== 'undefined';
 }
+
+export function isPublisherOfferWithJoinSupported() {
+  // we have connectivity issue about publisher offer with join on firefox #1919
+  return isCompressionStreamSupported() && !isFireFox();
+}