@stream-io/video-client 1.43.0 → 1.44.0

package/src/devices/devicePersistence.ts

@@ -0,0 +1,106 @@
+import { isReactNative } from '../helpers/platforms';
+import { videoLoggerSystem } from '../logger';
+
+export type DevicePersistenceOptions = {
+  /**
+   * Enables device preference persistence on web.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Storage key for persisted preferences.
+   * @default '@stream-io/device-preferences'
+   */
+  storageKey?: string;
+};
+
+export type DevicePreferenceKey = 'microphone' | 'camera' | 'speaker';
+
+export type LocalDevicePreference = {
+  selectedDeviceId: string;
+  selectedDeviceLabel: string;
+  muted?: boolean;
+};
+
+export type LocalDevicePreferences = {
+  [type in DevicePreferenceKey]?:
+    | LocalDevicePreference
+    | LocalDevicePreference[];
+};
+
+export const defaultDeviceId = 'default';
+
+const isLocalStorageAvailable = (): boolean =>
+  typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+
+export const normalize = (
+  options: DevicePersistenceOptions | undefined,
+): Required<DevicePersistenceOptions> => {
+  return {
+    storageKey: options?.storageKey ?? `@stream-io/device-preferences`,
+    enabled:
+      isLocalStorageAvailable() && !isReactNative()
+        ? (options?.enabled ?? true)
+        : false,
+  };
+};
+
+export const createSyntheticDevice = (
+  deviceId: string,
+  kind: MediaDeviceKind,
+): MediaDeviceInfo => {
+  return { deviceId, kind, label: '', groupId: '' } as MediaDeviceInfo;
+};
+
+export const readPreferences = (storageKey: string): LocalDevicePreferences => {
+  try {
+    const raw = window.localStorage.getItem(storageKey) || '{}';
+    return JSON.parse(raw) as LocalDevicePreferences;
+  } catch {
+    return {};
+  }
+};
+
+export const writePreferences = (
+  currentDevice: MediaDeviceInfo | undefined,
+  deviceKey: DevicePreferenceKey,
+  muted: boolean | undefined,
+  storageKey: string,
+) => {
+  if (!isLocalStorageAvailable()) return;
+
+  const selectedDeviceId = currentDevice?.deviceId ?? defaultDeviceId;
+  const selectedDeviceLabel = currentDevice?.label ?? '';
+
+  const preferences = readPreferences(storageKey);
+  const preferenceHistory = [preferences[deviceKey] ?? []]
+    .flat()
+    .filter(
+      (p) =>
+        p.selectedDeviceId !== selectedDeviceId &&
+        (p.selectedDeviceLabel === '' ||
+          p.selectedDeviceLabel !== selectedDeviceLabel),
+    );
+
+  const nextPreferences: LocalDevicePreferences = {
+    ...preferences,
+    [deviceKey]: [
+      {
+        selectedDeviceId,
+        selectedDeviceLabel,
+        ...(typeof muted === 'boolean' ? { muted } : {}),
+      } satisfies LocalDevicePreference,
+      ...preferenceHistory,
+    ].slice(0, 3),
+  };
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(nextPreferences));
+  } catch (err) {
+    const logger = videoLoggerSystem.getLogger('DevicePersistence');
+    logger.error('failed to save device preferences', err);
+  }
+};
+
+export const toPreferenceList = (
+  preference?: LocalDevicePreference | LocalDevicePreference[],
+): LocalDevicePreference[] => (preference ? [preference].flat() : []);

package/src/devices/devices.ts

@@ -134,7 +134,7 @@ export const getAudioDevices = lazy((tracer?: Tracer) => {
     getDeviceChangeObserver(tracer),
     getAudioBrowserPermission().asObservable(),
   ).pipe(
-    startWith(undefined),
+    startWith([]),
     concatMap(() =>
       getDevices(getAudioBrowserPermission(), 'audioinput', tracer),
     ),
@@ -153,7 +153,7 @@ export const getVideoDevices = lazy((tracer?: Tracer) => {
     getDeviceChangeObserver(tracer),
     getVideoBrowserPermission().asObservable(),
   ).pipe(
-    startWith(undefined),
+    startWith([]),
     concatMap(() =>
       getDevices(getVideoBrowserPermission(), 'videoinput', tracer),
     ),
@@ -172,7 +172,7 @@ export const getAudioOutputDevices = lazy((tracer?: Tracer) => {
     getDeviceChangeObserver(tracer),
     getAudioBrowserPermission().asObservable(),
   ).pipe(
-    startWith(undefined),
+    startWith([]),
     concatMap(() =>
       getDevices(getAudioBrowserPermission(), 'audiooutput', tracer),
     ),

package/src/helpers/__tests__/DynascaleManager.test.ts

@@ -30,7 +30,9 @@ describe('DynascaleManager', () => {
     call = new Call({
       id: 'id',
       type: 'default',
-      streamClient: new StreamClient('api-key'),
+      streamClient: new StreamClient('api-key', {
+        devicePersistence: { enabled: false },
+      }),
       clientStore: new StreamVideoWriteableStateStore(),
     });
     call.setSortParticipantsBy(noopComparator());

package/src/helpers/clientUtils.ts

@@ -7,7 +7,7 @@ import type {
 import { StreamClient } from '../coordinator/connection/client';
 import { getSdkInfo } from './client-details';
 import { SdkType } from '../gen/video/sfu/models/models';
-import type { StreamVideoClientOptions } from '../StreamVideoClient';
+import type { StreamVideoClientOptions } from '../types';
 
 /**
  * Utility function to get the instance key.

package/src/permissions/PermissionsContext.ts

@@ -58,6 +58,7 @@ export class PermissionsContext {
         return false;
       default:
         ensureExhausted(trackType, 'Unknown track type');
+        return false;
     }
   };
 

package/src/sorting/presets.ts

@@ -102,7 +102,7 @@ export const paginatedLayoutSortPreset = combineComparators(
  * The sorting preset for livestreams and audio rooms.
  */
 export const livestreamOrAudioRoomSortPreset = combineComparators(
-  ifInvisibleBy(
+  ifInvisibleOrUnknownBy(
     combineComparators(
       dominantSpeaker,
       speaking,

package/src/store/CallState.ts

@@ -1042,7 +1042,7 @@ export class CallState {
   ) => {
     const participant = this.findParticipantBySessionId(sessionId);
     if (!participant) {
-      this.logger.warn(`Participant with sessionId ${sessionId} not found`);
+      this.logger.debug(`Participant with sessionId ${sessionId} not found`);
       return;
     }
 

package/src/types.ts

@@ -4,20 +4,25 @@ import type {
   VideoDimension,
 } from './gen/video/sfu/models/models';
 import type {
+  AudioSettingsRequestDefaultDeviceEnum,
   CallRecordingStartedEventRecordingTypeEnum,
   JoinCallRequest,
   MemberResponse,
   OwnCapability,
   ReactionResponse,
-  AudioSettingsRequestDefaultDeviceEnum,
   StartRecordingRequest,
   StartRecordingResponse,
 } from './gen/coordinator';
 import type { StreamClient } from './coordinator/connection/client';
+import type {
+  RejectReason,
+  StreamClientOptions,
+  TokenProvider,
+  User,
+} from './coordinator/connection/types';
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
-import { RejectReason } from './coordinator/connection/types';
 
 export type StreamReaction = Pick<
   ReactionResponse,
@@ -334,6 +339,48 @@ export type CallConstructor = {
   clientStore: StreamVideoWriteableStateStore;
 };
 
+type StreamVideoClientBaseOptions = {
+  apiKey: string;
+  options?: StreamClientOptions;
+};
+
+type StreamVideoClientOptionsWithoutUser = StreamVideoClientBaseOptions & {
+  user?: undefined;
+  token?: never;
+  tokenProvider?: never;
+};
+
+type GuestUser = Extract<User, { type: 'guest' }>;
+type AnonymousUser = Extract<User, { type: 'anonymous' }>;
+type AuthenticatedUser = Exclude<User, GuestUser | AnonymousUser>;
+
+type StreamVideoClientOptionsWithGuestUser = StreamVideoClientBaseOptions & {
+  user: GuestUser;
+  token?: never;
+  tokenProvider?: never;
+};
+
+type StreamVideoClientOptionsWithAnonymousUser =
+  StreamVideoClientBaseOptions & {
+    user: AnonymousUser;
+    token?: string;
+    tokenProvider?: TokenProvider;
+  };
+
+type StreamVideoClientOptionsWithAuthenticatedUser =
+  StreamVideoClientBaseOptions & {
+    user: AuthenticatedUser;
+  } & (
+      | { token: string; tokenProvider?: TokenProvider }
+      | { token?: string; tokenProvider: TokenProvider }
+    );
+
+export type StreamVideoClientOptions =
+  | StreamVideoClientOptionsWithoutUser
+  | StreamVideoClientOptionsWithGuestUser
+  | StreamVideoClientOptionsWithAnonymousUser
+  | StreamVideoClientOptionsWithAuthenticatedUser;
+
 export type CallRecordingType = CallRecordingStartedEventRecordingTypeEnum;
 export type StartCallRecordingFnType = {
   (): Promise<StartRecordingResponse>;