@pexip/media-control 18.5.0 → 19.0.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 19.0.0
+
+### Major Changes
+
+- 878fcca: Index devices
+
+  Change to device index instead of Array to store device list, and added the
+  following functions:
+
+  - `function createIndexedDevices(MediaDeviceInfoLike[]): IndexedDevices`
+  - `function isIndexedDevices(t: unknown): t is IndexedDevices`
+  - `function getDeviceId(device: Pick<MediaDeviceInfoLike, 'groupId' | 'deviceId' | 'kind'>): string`
+  - `function reverseDeviceId(id: string): MediaDeviceInfoLike`
+
+  All the device lookup functions are updated to use `IndexedDevices`.
+
+  Also, the artificial `devicechange` before and after `getUserMedia` call are
+  removed.
+
+### Minor Changes
+
+- 6c42e61: Use `exact` constraint when the media device is connected and `ideal`
+  if it is not found.
+- e362a65: Add `isTrackMutedOrEnded` function
+
+### Patch Changes
+
+- Updated dependencies [164a3e2]
+- Updated dependencies [b13010c]
+- Updated dependencies [66a8f72]
+  - @pexip/utils@16.13.0
+
 ## 18.5.0
 
 ### Patch Changes

package/dist/constants.d.ts

@@ -40,4 +40,5 @@ export declare const INCLUDE_EXCLUDE_CONSTRAINT: {
     readonly Exclude: "exclude";
 };
 export type IncludeExcludeConstraint = ExtractObjectValueTypes<typeof INCLUDE_EXCLUDE_CONSTRAINT>;
+export declare const DEVICE_ID_SEPARATOR = ":";
 export {};

package/dist/constants.js

@@ -24,3 +24,4 @@ export const INCLUDE_EXCLUDE_CONSTRAINT = {
     Include: 'include',
     Exclude: 'exclude',
 };
+export const DEVICE_ID_SEPARATOR = ':';

package/dist/constraints.d.ts

@@ -1,4 +1,4 @@
-import type { FacingMode, InputConstraintSet, InputDeviceConstraint, MediaConstraintRequirement, MediaDeviceInfoLike, MediaDeviceRequest, NormalizedConstraintDeviceParameters } from './types';
+import type { FacingMode, InputConstraintSet, InputDeviceConstraint, MediaConstraintRequirement, MediaDeviceInfoLike, MediaDeviceRequest, NormalizedConstraintDeviceParameters, IndexedDevices } from './types';
 import type { ConstrainBooleanKeys, ConstrainDoubleKeys, ConstrainParamKeys, ConstrainRangeParamKeys, ConstrainStringKeys, ConstrainULongKeys, ExtendedConstrainBooleanKeys, ExtendedConstrainDoubleKeys, ExtendedConstrainStringKeys, ExtendedConstrainULongKeys } from './typeGuards';
 /**
  * Check if provided constraint is an `exact` device constraint
@@ -12,7 +12,7 @@ export declare const removeUnsupportedConstraints: (constraints: MediaStreamCons
 /**
  * Merge base constraints with provided base constraints and another constraints
  */
-export declare const mergeConstraints: (baseConstraints: InputConstraintSet | boolean | undefined) => (constraints: InputDeviceConstraint | undefined) => InputConstraintSet | boolean;
+export declare const mergeConstraints: (baseConstraints: InputConstraintSet | boolean | undefined) => (constraints: InputDeviceConstraint | undefined) => InputConstraintSet | boolean | undefined;
 /**
  * Normalize Device
  * Convert any valid `MediaDeviceInfoLike` into `MediaDeviceInfoLike[]`
@@ -52,7 +52,7 @@ export type ConstrainNumberTuple = [
 ];
 export declare const extractConstrainNumber: (key: ConstrainULongKeys | ConstrainDoubleKeys | ExtendedConstrainULongKeys | ExtendedConstrainDoubleKeys) => (constraints: InputConstraintSet) => ConstrainNumberTuple | ConstrainNoneTuple;
 export type ConstrainDeviceTuple = [MediaDeviceInfoLike[], ConstrainParamKeys];
-export declare const extractConstrainDevice: (constraints: InputDeviceConstraint | undefined) => ConstrainDeviceTuple | ConstrainNoneTuple;
+export declare const extractConstrainDevice: (constraints: InputDeviceConstraint | undefined, initialParam?: ConstrainParamKeys) => ConstrainDeviceTuple | ConstrainNoneTuple;
 /**
  * Compare float point number a and b to see if they are closed to be considered
  * as having the same value
@@ -88,7 +88,7 @@ export declare const satisfyConstrainNumber: (constraint: ConstrainNumber | unde
  *
  * @internal
  */
-export declare const resolveMediaDeviceConstraints: (constraints?: InputDeviceConstraint, base?: MediaTrackConstraints | boolean) => MediaTrackConstraints | boolean;
+export declare const resolveMediaDeviceConstraints: (constraints?: InputDeviceConstraint, base?: MediaTrackConstraints | boolean) => MediaTrackConstraints | boolean | undefined;
 /**
  * @remarks
  * Constraint multiple (exact) devices is not supported
@@ -103,10 +103,10 @@ export declare const getMediaConstraints: ({ audio, video, defaultConstraints, }
  * @param constraints - constraints to be applied
  */
 export declare const applyConstraints: (tracks: MediaStreamTrack[] | undefined, constraints: MediaDeviceRequest) => Promise<void>;
-export declare const findDeviceFrom: (devicesToFind: MediaDeviceInfoLike[], deviceList: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[] | undefined;
-export declare const findDeviceFromDeviceConstraints: (device: InputConstraintSet['device'], devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[] | undefined;
-export declare const relaxDevice: (device: InputConstraintSet['device'], devices: MediaDeviceInfoLike[]) => MediaDeviceInfoLike[] | undefined;
-export declare const resolveOnlyDevice: (devices: MediaDeviceInfoLike[]) => true | MediaDeviceInfoLike | undefined;
+export declare const findDeviceFrom: (devicesToFind: MediaDeviceInfoLike[], devices: IndexedDevices) => MediaDeviceInfoLike[];
+export declare const findDeviceFromDeviceConstraints: (device: InputConstraintSet['device'], devices: IndexedDevices) => MediaDeviceInfoLike[] | undefined;
+export declare const relaxDevice: (device: InputConstraintSet['device'], devices: IndexedDevices) => MediaDeviceInfoLike[] | undefined;
+export declare const resolveOnlyDevice: (devices: IndexedDevices) => true | MediaDeviceInfoLike | undefined;
 type ConstrainNumberKeys = ConstrainULongKeys | ConstrainDoubleKeys | ExtendedConstrainDoubleKeys | ExtendedConstrainULongKeys;
 type ConstrainTuples = ConstrainDeviceTuple | ConstrainNumberTuple | ConstrainStringTuple | ConstrainBooleanTuple | ConstrainNoneTuple;
 type ExtractConstraintFn<R extends ConstrainTuples> = (constraints: InputDeviceConstraint | undefined) => R;
@@ -118,7 +118,7 @@ type ConstrainStrings = Record<ConstrainStringKeys | ExtendedConstrainStringKeys
 type ConstrainNumbers = Record<ConstrainNumberKeys, ConstrainNumberTuple | ConstrainNoneTuple>;
 type ConstrainBooleans = Record<ConstrainBooleanKeys | ExtendedConstrainBooleanKeys, ConstrainBooleanTuple | ConstrainNoneTuple>;
 type ConstrainDevices = Record<'device', ConstrainDeviceTuple | ConstrainNoneTuple>;
-type Constraints = ConstrainStrings & ConstrainNumbers & ConstrainBooleans & ConstrainDevices;
+export type Constraints = ConstrainStrings & ConstrainNumbers & ConstrainBooleans & ConstrainDevices;
 /**
  * Extract the constraints with provided keys
  *
@@ -157,16 +157,17 @@ export declare const extractDeviceId: (constraints: InputConstraintSet) => Const
  * @returns `true` means it can be any devices, `undefined` means not found,
  * otherwise, the matched device will be returned
  */
-export declare const findDeviceFromConstraints: (constraints: InputDeviceConstraint | undefined, devices: MediaDeviceInfoLike[]) => boolean | MediaDeviceInfoLike | undefined;
+export declare const findDeviceFromConstraints: (constraints: InputDeviceConstraint | undefined, devices: IndexedDevices) => boolean | MediaDeviceInfoLike | undefined;
 /**
  * Relax input constraints to enable looking up the device by `deviceId` as well
  * as `label` as a fallback as a best effort to get a similar device when
- * possible.
+ * possible. If the the device is found we will use the `exact` constraint otherwise
+ * we will use the `ideal`.
  *
  * @param input - The input constraints to be relaxed
  * @param devices - The current device list
  */
-export declare const relaxInputConstraint: (input: InputDeviceConstraint | undefined, devices: MediaDeviceInfoLike[]) => InputDeviceConstraint | undefined;
+export declare const relaxInputConstraint: (kind: 'audioinput' | 'videoinput', input: InputDeviceConstraint | undefined, devices: IndexedDevices) => InputDeviceConstraint | undefined;
 export declare const getConstraintsHandlers: () => {
     getDefaultConstraints: () => MediaStreamConstraints;
     setDefaultConstraints: (newConstraints: MediaStreamConstraints) => void;

package/dist/constraints.js

@@ -1,6 +1,5 @@
 import { isBoolean, isConstrainBooleanKeys, isConstrainBooleanParameters, isConstrainDOMStringParameters, isConstrainDoubleKeys, isConstrainDoubleRange, isConstrainRange, isConstrainStringKeys, isConstrainULongKeys, isConstrainULongRange, isConstraintDOMString, isConstraintDeviceParameters, isConstraintSetDevice, isDeviceConstraint, isExtendedConstrainBooleanKeys, isExtendedConstrainDoubleKeys, isExtendedConstrainStringKeys, isExtendedConstrainULongKeys, isFacingMode, isFloat, isInputConstraintSet, isInteger, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaTrackConstraintSetKey, isMediaTrackConstraints, isNumber, isUndefined, } from './typeGuards';
 import { logger } from './logger';
-import { findDevice } from './utils';
 /**
  * Check if provided constraint is an `exact` device constraint
  */
@@ -61,9 +60,12 @@ export const mergeConstraints = (baseConstraints) => (constraints) => {
         if (isDeviceConstraint(constraints)) {
             return { device: constraints };
         }
-        return constraints ?? false;
+        return constraints;
     }
-    if (!constraints) {
+    if (constraints === undefined) {
+        return undefined;
+    }
+    if (constraints === false) {
         return false;
     }
     if (isDeviceConstraint(constraints)) {
@@ -165,7 +167,7 @@ export const toArray = (t) => {
 export const NONE = [undefined, 'ideal'];
 export const extractConstrainString = (key) => (constraints) => {
     const constraint = constraints[key];
-    if (!constraint) {
+    if (constraint === undefined) {
         return NONE;
     }
     if (isConstraintDOMString(constraint)) {
@@ -234,7 +236,7 @@ export const extractConstrainNumber = (key) => (constraints) => {
     }
     return NONE;
 };
-export const extractConstrainDevice = (constraints) => {
+export const extractConstrainDevice = (constraints, initialParam = 'ideal') => {
     if (!constraints ||
         isBoolean(constraints) ||
         (Array.isArray(constraints) && !constraints.length)) {
@@ -246,7 +248,7 @@ export const extractConstrainDevice = (constraints) => {
     if (isMediaDeviceInfo(device) || isMediaDeviceInfoArray(device)) {
         const normalized = normalizeDevice(device);
         if (normalized) {
-            return [normalized, 'ideal'];
+            return [normalized, initialParam];
         }
     }
     if (isConstraintDeviceParameters(device)) {
@@ -389,7 +391,7 @@ export const resolveMediaDeviceConstraints = (constraints, base) => {
     if (constraints && isMediaTrackConstraints(base)) {
         return base;
     }
-    return !!constraints;
+    return constraints === undefined ? constraints : !!constraints;
 };
 /**
  * @remarks
@@ -429,43 +431,43 @@ export const applyConstraints = async (tracks, constraints) => {
         return [];
     }));
 };
-export const findDeviceFrom = (devicesToFind, deviceList) => {
-    const devicesFound = devicesToFind.flatMap(device => {
-        const found = findDevice(device)(deviceList);
-        if (found) {
-            return [found];
+export const findDeviceFrom = (devicesToFind, devices) => devicesToFind.flatMap(device => devices.get(device));
+const findDeviceFromDeviceId = (constrainDeviceIds, devices) => {
+    for (const deviceId of constrainDeviceIds) {
+        const device = devices.get({ deviceId, kind: 'audioinput' }).at(0) ??
+            devices.get({ deviceId, kind: 'videoinput' }).at(0) ??
+            devices.get({ deviceId, kind: 'audiooutput' }).at(0);
+        if (device) {
+            return device;
         }
-        return [];
-    });
-    if (devicesFound.length) {
-        return devicesFound;
     }
-    return undefined;
 };
 export const findDeviceFromDeviceConstraints = (device, devices) => {
     const normalized = normalizeDeviceConstraint(device);
     if (normalized) {
         const { ideal, exact } = normalized;
         if (exact) {
-            return findDeviceFrom(exact, devices);
+            const found = findDeviceFrom(exact, devices);
+            return found.length ? found : undefined;
         }
         if (ideal) {
-            return findDeviceFrom(ideal, devices);
+            const found = findDeviceFrom(ideal, devices);
+            return found.length ? found : undefined;
         }
     }
 };
 export const relaxDevice = (device, devices) => {
     const found = findDeviceFromDeviceConstraints(device, devices);
-    if (found) {
+    if (found?.length) {
         return found;
     }
     // Return the original with normalized form
     return normalizeDevice(device);
 };
 export const resolveOnlyDevice = (devices) => {
-    switch (devices.length) {
+    switch (devices.size('audioinput') + devices.size('videoinput')) {
         case 1:
-            return devices[0];
+            return devices.first('audioinput') ?? devices.first('videoinput');
         case 0:
             return undefined;
         default:
@@ -580,8 +582,7 @@ export const findDeviceFromConstraints = (constraints, devices) => {
         return constraints ? resolveOnlyDevice(devices) : constraints;
     }
     if (constraints === undefined ||
-        !devices.length ||
-        devices.some(device => !device.label) ||
+        !(devices.size('audioinput') + devices.size('videoinput')) ||
         (Array.isArray(constraints) && !constraints.length)) {
         return undefined;
     }
@@ -598,10 +599,7 @@ export const findDeviceFromConstraints = (constraints, devices) => {
     }
     const [ConstrainDeviceIds, deviceIdParam] = extractConstraints('deviceId')(constraints);
     if (ConstrainDeviceIds) {
-        const deviceFound = devices.find(device => {
-            const id = ConstrainDeviceIds.find(id => id && device.label && device.deviceId === id);
-            return !!id;
-        });
+        const deviceFound = findDeviceFromDeviceId(ConstrainDeviceIds, devices);
         if (deviceFound) {
             return deviceFound;
         }
@@ -614,16 +612,33 @@ export const findDeviceFromConstraints = (constraints, devices) => {
 /**
  * Relax input constraints to enable looking up the device by `deviceId` as well
  * as `label` as a fallback as a best effort to get a similar device when
- * possible.
+ * possible. If the the device is found we will use the `exact` constraint otherwise
+ * we will use the `ideal`.
  *
  * @param input - The input constraints to be relaxed
  * @param devices - The current device list
  */
-export const relaxInputConstraint = (input, devices) => {
-    if (devices.length === 0 || !input || typeof input === 'boolean') {
+export const relaxInputConstraint = (kind, input, devices) => {
+    if (devices.size(kind) === 0 || !input || typeof input === 'boolean') {
         return input;
     }
-    const [device, param] = extractConstrainDevice(input);
+    let found = false;
+    if (isMediaDeviceInfo(input)) {
+        found = Boolean(devices.get(input).length);
+    }
+    else if (isMediaDeviceInfoArray(input)) {
+        found = Boolean(input.some(device => devices.get(device).length > 0));
+    }
+    else if (isInputConstraintSet(input)) {
+        found = Boolean(findDeviceFromDeviceConstraints(input.device, devices));
+    }
+    else {
+        const [ConstrainDeviceIds] = extractConstraints('deviceId')(input);
+        if (ConstrainDeviceIds) {
+            found = Boolean(findDeviceFromDeviceId(ConstrainDeviceIds, devices));
+        }
+    }
+    const [device, param] = extractConstrainDevice(input, found ? 'exact' : 'ideal');
     const relaxedDevice = relaxDevice(device, devices);
     const otherConstraints = isInputConstraintSet(input) ? input : {};
     return relaxedDevice

package/dist/devices.d.ts

@@ -1,5 +1,4 @@
-import type { MediaDeviceInfoLike, MediaInput, MediaDeviceRequest, InputDeviceConstraint, InputConstraintSet, InputDevicePermission, FacingMode } from './types';
-import { MediaDeviceKinds } from './types';
+import type { FacingMode, IndexedDevices, InputConstraintSet, InputDeviceConstraint, InputDevicePermission, MediaDeviceInfoLike, MediaDeviceRequest, MediaDeviceTrackInfo, MediaInput } from './types';
 /**
  * DeviceChange Event
  *
@@ -31,6 +30,7 @@ interface ToKeyOptions {
  * @beta
  */
 export declare const toKey: ({ id, kind, label }: ToKeyOptions) => string;
+export declare const toMediaDeviceInputKind: (track: Pick<MediaStreamTrack, 'kind'>) => 'audioinput' | 'videoinput';
 /**
  * Future proofing: in case we want to alter the values or type returned
  * by {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices | enumerateDevices}
@@ -66,27 +66,7 @@ export declare const createTrackDevicesChanges: (prevDevices?: MediaDeviceInfoLi
  * @beta
  */
 export declare const deviceChanged: (fn: (event: DeviceChangedChanges) => void) => () => void;
-export declare const extractDeviceInfo: (track: MediaStreamTrack) => {
-    kind: MediaDeviceKinds;
-    deviceId: string;
-    groupId: string;
-    label: string;
-    settings: {
-        aspectRatio?: number | undefined;
-        autoGainControl?: boolean | undefined;
-        channelCount?: number | undefined;
-        displaySurface?: string | undefined;
-        echoCancellation?: boolean | undefined;
-        facingMode?: string | undefined;
-        frameRate?: number | undefined;
-        height?: number | undefined;
-        noiseSuppression?: boolean | undefined;
-        sampleRate?: number | undefined;
-        sampleSize?: number | undefined;
-        width?: number | undefined;
-        latency?: number | undefined;
-    };
-};
+export declare const extractDeviceInfo: (track: MediaStreamTrack) => MediaDeviceTrackInfo;
 /**
  * Convert `MediaStreamTrack` to `MediaDeviceInfoLike`
  *
@@ -128,7 +108,7 @@ export declare const toMediaDeviceInfo: (info: MediaDeviceInfoLike) => {
  *
  * @beta
  */
-export declare const findMediaInputFromMediaStreamTrack: (devices: MediaDeviceInfoLike[]) => (track?: MediaStreamTrack | undefined) => MediaDeviceInfoLike | undefined;
+export declare const findMediaInputFromMediaStreamTrack: (devices: IndexedDevices) => (track?: MediaStreamTrack | undefined) => MediaDeviceInfoLike | undefined;
 /**
  * Find media input from media stream
  *
@@ -140,31 +120,48 @@ export declare const findMediaInputFromMediaStreamTrack: (devices: MediaDeviceIn
  *
  * @beta
  */
-export declare const findMediaInputFromStream: (devices: MediaDeviceInfoLike[]) => (stream: MediaStream | undefined) => MediaInput;
+export declare const findMediaInputFromStream: (devices: IndexedDevices) => (stream: MediaStream | undefined) => MediaInput;
 export declare const compareDeviceConstraintAndTrackDevice: (device: MediaDeviceInfoLike | undefined) => (constraint: InputConstraintSet['device']) => boolean;
-export declare const isRequestedResolution: (request: InputDeviceConstraint | undefined, response: MediaDeviceInfoLike | undefined) => boolean;
-export declare const isRequestedInputDevice: (request: InputDeviceConstraint | undefined, response: MediaDeviceInfoLike | undefined) => boolean;
+export declare const isRequestedResolution: (request: InputDeviceConstraint | undefined, response: MediaTrackSettings | undefined) => boolean;
+export declare const isRequestedInputDevice: (request: InputDeviceConstraint | undefined, response: MediaDeviceInfoLike | MediaDeviceTrackInfo | undefined) => boolean;
 /**
  * Compare request and the input to see if the request has been fulfilled
  */
 export declare const isRequestedInputTrack: (request: InputDeviceConstraint | undefined, current: MediaStreamTrack | MediaDeviceInfoLike | undefined) => boolean;
-export declare const hasRequestingDevice: (request: InputDeviceConstraint | undefined, kind: MediaDeviceKind, currentDevices: MediaDeviceInfoLike[]) => boolean;
 /**
- * Decide if we should send a new gUM request based on the inputs
+ * Check if there is a requesting device with respecting to the current devices
  *
  * @param request - Requesting input device constraint
- * @param tracks - The current media stream tracks
- * @param currentDevices - The current list of device of the same kind of the
- * request
+ * @param kind - The kind of the device
+ * @param currentDevices - The current indexed devices
+ */
+export declare const hasRequestingDevice: (request: InputDeviceConstraint | undefined, kind: MediaDeviceKind, currentDevices: IndexedDevices) => boolean;
+/**
+ * Check if the track is muted or 'ended'
+ * @param track - The media stream tracks
+ */
+export declare const isTrackMutedOrEnded: (track: MediaStreamTrack) => boolean;
+interface DeviceRequestParams {
+    kind: 'audioinput' | 'videoinput';
+    permission: PermissionState;
+    request: InputDeviceConstraint | undefined;
+    tracks: MediaStreamTrack[];
+    currentDevices: IndexedDevices;
+}
+/**
+ * Decide if we should send a new gUM request
+ *
+ * @param deviceRequestParams - @see DeviceRequestParams
  *
  * @returns `true` means the request should be conducted, otherwise `false`.
  */
-export declare const shouldRequestDevice: (request: InputDeviceConstraint | undefined, tracks: MediaStreamTrack[], currentDevices: MediaDeviceInfoLike[]) => boolean;
-export declare const resolveInputDevice: (tracksOrDevice: MediaDeviceInfoLike | MediaStreamTrack[] | undefined, findInput: ReturnType<typeof findMediaInputFromMediaStreamTrack>) => MediaDeviceInfo | MediaDeviceInfoLike | MediaStreamTrack | undefined;
+export declare const shouldRequestDevice: ({ kind, permission, request, tracks, currentDevices, }: DeviceRequestParams) => boolean;
+export declare const resolveInputDevice: (tracksOrDevice: MediaDeviceInfoLike | MediaStreamTrack[] | undefined, findInput: ReturnType<typeof findMediaInputFromMediaStreamTrack>) => MediaDeviceInfoLike | MediaStreamTrack | undefined;
+export declare const isStreamingRequestingDevice: (request: InputDeviceConstraint | undefined, trackOrDevice: MediaDeviceInfoLike | MediaStreamTrack[] | undefined, devices: IndexedDevices) => boolean;
 export declare const isStreamingRequestedDevicesBase: (request: MediaDeviceRequest, tracksOrDevices: {
     audio?: MediaDeviceInfoLike | MediaStreamTrack[];
     video?: MediaDeviceInfoLike | MediaStreamTrack[];
-}, devices: MediaDeviceInfoLike[]) => {
+}, devices: IndexedDevices) => {
     audio: boolean;
     video: boolean;
 };
@@ -178,7 +175,7 @@ export declare const isStreamingRequestedDevicesBase: (request: MediaDeviceReque
  * audio - The stream is using the same device as requested if `true`
  * video - The stream is using the same device as requested if `true`
  */
-export declare const isStreamingRequestedDevices: (request: MediaDeviceRequest, stream: MediaStream | undefined, devices: MediaDeviceInfoLike[]) => {
+export declare const isStreamingRequestedDevices: (request: MediaDeviceRequest, stream: MediaStream | undefined, devices: IndexedDevices) => {
     audio: boolean;
     video: boolean;
 };
@@ -202,19 +199,24 @@ export declare const findPermissionGrantedDevices: (devices: MediaDeviceInfoLike
  * stream and there is no device with label, 'prompt' will be returned
  * otherwise, 'denied'.
  *
- * @param devices - The current devices
- * @param anyActiveStream - Has ever got an active stream to help the fallback to
+ * @param anyGrantedDevice - Any permission granted device
+ * @param anyLiveTrack - Has ever got a live track
  * guess the state more accurately
  */
-export declare const toPermissionState: (devices: MediaDeviceInfoLike[], anyActiveStream?: boolean) => PermissionState;
+export declare const toPermissionState: (anyGrantedDevice: boolean, anyLiveTrack?: boolean) => PermissionState;
+export declare const queryPermissionFallback: (name: 'camera' | 'microphone', everActiveTrack?: boolean, getDevices?: () => Promise<MediaDeviceInfo[]>) => Promise<PermissionState>;
+export declare const queryPermission: (name: 'camera' | 'microphone', everActiveTrack?: boolean, getDevices?: () => Promise<MediaDeviceInfo[]>) => Promise<PermissionState>;
 /**
  * A wrapper for `navigator.permissions.query` with fallback to use
  * `navigator.mediaDevices.enumerateDevices` to guess the `PermissionState`
  *
- * @param anyActiveStream - Has ever got an active stream to help the fallback to
+ * @param anyActiveAudioTrack - Has ever got an active audio to help the fallback to
+ * guess the state more accurately
+ * @param anyActiveVideoTrack - Has ever got an active video to help the fallback to
  * guess the state more accurately
+ * @param getDevices - A function to get the list of devices, e.g. navigator.mediaDevices.enumerateDevices
  */
-export declare const getInputDevicePermissionState: (anyActiveStream?: boolean) => Promise<InputDevicePermission>;
+export declare const getInputDevicePermissionState: (anyActiveAudioTrack?: boolean, anyActiveVideoTrack?: boolean, getDevices?: () => Promise<MediaDeviceInfo[]>) => Promise<InputDevicePermission>;
 /**
  * Find current audio output id to be used to set as sinkId
  *

package/dist/devices.js

@@ -1,14 +1,25 @@
+import { assert } from '@pexip/utils';
 import { MediaDeviceKinds } from './types';
-import { extractConstrainNumber, extractConstrainString, normalizeDeviceConstraint, toArray, relaxInputConstraint, satisfyConstrainNumber, extractConstraintsWithKeys, } from './constraints';
-import { isMediaDeviceInfo, isConstraintSetDevice, isInputConstraintSet, isConstrainDOMStringParameters, isConstraintDOMString, isMediaStreamTrack, } from './typeGuards';
-import { findDevice, compareDevices, isSameDeviceKind, not, isAudioInput, isVideoInput, isAudioOutput, isDeviceGranted, } from './utils';
-const SEPARATOR = ':';
+import { extractConstrainNumber, extractConstrainString, extractConstraintsWithKeys, normalizeDeviceConstraint, satisfyConstrainNumber, toArray, } from './constraints';
+import { isConstrainDOMStringParameters, isConstraintDOMString, isConstraintSetDevice, isInputConstraintSet, isMediaDeviceInfo, isMediaDeviceTrackInfo, isMediaStreamTrack, } from './typeGuards';
+import { compareDevices, findDevice, isAudioInput, isAudioOutput, isDeviceGranted, isSameDeviceKind, isVideoInput, not, } from './utils';
+import { DEVICE_ID_SEPARATOR } from './constants';
 /**
  * Convert provided info to key for Map
  *
  * @beta
  */
-export const toKey = ({ id, kind, label }) => [kind, id, label].join(SEPARATOR);
+export const toKey = ({ id, kind, label }) => [kind, id, label].join(DEVICE_ID_SEPARATOR);
+export const toMediaDeviceInputKind = (track) => {
+    switch (track.kind) {
+        case 'audio':
+            return 'audioinput';
+        case 'video':
+            return 'videoinput';
+        default:
+            throw new Error('Invalid track kind');
+    }
+};
 /**
  * Future proofing: in case we want to alter the values or type returned
  * by {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/enumerateDevices | enumerateDevices}
@@ -108,6 +119,7 @@ export const extractDeviceInfo = (track) => {
         ? MediaDeviceKinds.AUDIOINPUT
         : MediaDeviceKinds.VIDEOINPUT;
     return {
+        id: track.id,
         kind,
         deviceId: deviceId ?? '',
         groupId: groupId ?? '',
@@ -155,13 +167,6 @@ export const compareMediaDeviceToMediaTrack = (track) => (device) => {
     }
     return sameKind && sameLabel;
 };
-const toMediaDeviceInfoLikeJSON = (info) => ({
-    deviceId: info.deviceId,
-    groupId: info.groupId,
-    kind: info.kind,
-    label: info.label,
-    settings: info.settings,
-});
 export const toMediaDeviceInfo = (info) => ({
     deviceId: info.deviceId,
     groupId: info.groupId,
@@ -180,25 +185,20 @@ export const toMediaDeviceInfo = (info) => ({
  * @beta
  */
 export const findMediaInputFromMediaStreamTrack = (devices) => (track) => {
-    if (!devices.length || !track) {
+    if (!track) {
         return undefined;
     }
-    const settings = track.getSettings();
-    const devicesWithSameKind = devices.filter(d => d.kind === `${track.kind}input`);
-    // There is no need to compare since it is only device
-    const onlyDevice = devicesWithSameKind[0];
-    if (devicesWithSameKind.length === 1 && onlyDevice) {
-        onlyDevice.settings = settings;
-        onlyDevice.toJSON = () => toMediaDeviceInfoLikeJSON(onlyDevice);
-        return onlyDevice;
-    }
-    const device = devicesWithSameKind.find(compareMediaDeviceToMediaTrack(track));
-    if (device) {
-        device.settings = settings;
-        device.toJSON = () => toMediaDeviceInfoLikeJSON(device);
-        return device;
+    const kind = toMediaDeviceInputKind(track);
+    if (!devices.size(kind)) {
+        return undefined;
     }
-    return device;
+    const settings = track.getSettings();
+    const devicesFound = devices.get({
+        kind,
+        label: track.label,
+        deviceId: settings.deviceId,
+    });
+    return devicesFound[0];
 };
 /**
  * Find media input from media stream
@@ -212,7 +212,7 @@ export const findMediaInputFromMediaStreamTrack = (devices) => (track) => {
  * @beta
  */
 export const findMediaInputFromStream = (devices) => (stream) => {
-    if (!stream || !devices.length) {
+    if (!stream) {
         return {};
     }
     const findMediaInput = findMediaInputFromMediaStreamTrack(devices);
@@ -228,7 +228,9 @@ export const compareDeviceConstraintAndTrackDevice = (device) => (constraint) =>
     const normalized = normalizeDeviceConstraint(constraint);
     if (normalized) {
         const requestingDevices = Object.values(normalized).flatMap(t => (Array.isArray(t) ? t : [t]));
-        const compare = compareDevices(device, device.label ? 'label' : 'deviceId');
+        const compare = compareDevices(device, 
+        // Always use `deviceId` for exact constraints
+        !!normalized.exact || !device.label ? 'deviceId' : 'label');
         return requestingDevices.some(compare);
     }
     return false;
@@ -240,7 +242,7 @@ export const isRequestedResolution = (request, response) => {
     if (isInputConstraintSet(request)) {
         const [width] = extractConstrainNumber('width')(request);
         const [height] = extractConstrainNumber('height')(request);
-        const { width: responseWidth = 0, height: responseHeight = 0 } = response.settings ?? {};
+        const { width: responseWidth = 0, height: responseHeight = 0 } = response ?? {};
         const portrait = responseHeight >= responseWidth;
         const resultWidth = portrait ? responseHeight : responseWidth;
         const resultHeight = portrait ? responseWidth : responseHeight;
@@ -275,10 +277,12 @@ export const isRequestedInputDevice = (request, response) => {
                     .some(id => id === deviceId);
             }
         }
-        const facingMode = response.settings?.facingMode;
-        if (request.facingMode && facingMode) {
-            const [facingModes] = extractConstrainString('facingMode')(request);
-            return facingModes?.some(fm => fm === facingMode) ?? true;
+        if (isMediaDeviceTrackInfo(response)) {
+            const facingMode = response.settings.facingMode;
+            if (request.facingMode && facingMode) {
+                const [facingModes] = extractConstrainString('facingMode')(request);
+                return facingModes?.some(fm => fm === facingMode) ?? true;
+            }
         }
         return true;
     }
@@ -304,6 +308,13 @@ export const isRequestedInputTrack = (request, current) => {
     return true;
 };
 const extractDevice = extractConstraintsWithKeys(['device', 'deviceId']);
+/**
+ * Check if there is a requesting device with respecting to the current devices
+ *
+ * @param request - Requesting input device constraint
+ * @param kind - The kind of the device
+ * @param currentDevices - The current indexed devices
+ */
 export const hasRequestingDevice = (request, kind, currentDevices) => {
     if (!request) {
         return false;
@@ -312,44 +323,52 @@ export const hasRequestingDevice = (request, kind, currentDevices) => {
     // No device specified
     if ((!devices || devices.length === 0) &&
         (!deviceIds || deviceIds.length === 0)) {
-        return currentDevices.some(device => device.kind === kind);
+        return Boolean(currentDevices.size(kind));
     }
     // Has device specified
-    const find = (device) => findDevice(device)(currentDevices);
-    return (devices?.some(device => find(device)) ??
-        deviceIds?.some(deviceId => find({ kind, deviceId, label: '', groupId: '' })) ??
+    return (devices?.some(device => currentDevices.get(device).length) ??
+        deviceIds?.some(deviceId => currentDevices.get({ kind, deviceId }).length) ??
         false);
 };
 /**
- * Decide if we should send a new gUM request based on the inputs
+ * Check if the track is muted or 'ended'
+ * @param track - The media stream tracks
+ */
+export const isTrackMutedOrEnded = (track) => track.readyState === 'ended' || track.muted;
+/**
+ * Decide if we should send a new gUM request
  *
- * @param request - Requesting input device constraint
- * @param tracks - The current media stream tracks
- * @param currentDevices - The current list of device of the same kind of the
- * request
+ * @param deviceRequestParams - @see DeviceRequestParams
  *
  * @returns `true` means the request should be conducted, otherwise `false`.
  */
-export const shouldRequestDevice = (request, tracks, currentDevices) => {
-    if (!request || !currentDevices.some(device => device.label)) {
-        return false;
-    }
-    const { kind } = currentDevices[0] ?? {};
-    if (!kind || currentDevices.some(device => device.kind !== kind)) {
-        throw new Error('Expect a single kind of device');
-    }
-    const [track] = tracks;
-    if (tracks.length === 0 ||
-        tracks.some(track => track.readyState === 'ended' || track.muted)) {
-        return true;
-    }
-    if (isRequestedInputTrack(request, track)) {
+export const shouldRequestDevice = ({ kind, permission, request, tracks, currentDevices, }) => {
+    if (!request) {
         return false;
     }
-    if (hasRequestingDevice(request, kind, currentDevices)) {
-        return true;
+    switch (permission) {
+        case 'prompt':
+            return true;
+        case 'granted': {
+            if (currentDevices.size(kind) === 0) {
+                return false;
+            }
+            if (tracks.length === 0 || tracks.some(isTrackMutedOrEnded)) {
+                return true;
+            }
+            const [track] = tracks;
+            assert(track);
+            if (isRequestedInputTrack(request, track)) {
+                return false;
+            }
+            if (hasRequestingDevice(request, kind, currentDevices)) {
+                return true;
+            }
+            return false;
+        }
+        default:
+            return false;
     }
-    return false;
 };
 export const resolveInputDevice = (tracksOrDevice, findInput) => {
     if (isMediaDeviceInfo(tracksOrDevice)) {
@@ -363,14 +382,20 @@ export const resolveInputDevice = (tracksOrDevice, findInput) => {
     }
     return undefined;
 };
-export const isStreamingRequestedDevicesBase = (request, tracksOrDevices, devices) => {
-    const audioRequest = relaxInputConstraint(request.audio, devices);
-    const videoRequest = relaxInputConstraint(request.video, devices);
+export const isStreamingRequestingDevice = (request, trackOrDevice, devices) => {
+    if (request === undefined) {
+        return true;
+    }
     const findInput = findMediaInputFromMediaStreamTrack(devices);
-    const audioInput = resolveInputDevice(tracksOrDevices.audio, findInput);
-    const videoInput = resolveInputDevice(tracksOrDevices.video, findInput);
-    const audio = isRequestedInputTrack(audioRequest, audioInput);
-    const video = isRequestedInputTrack(videoRequest, videoInput);
+    const input = resolveInputDevice(trackOrDevice, findInput);
+    if (!input) {
+        return Boolean(request) === Boolean(input);
+    }
+    return isRequestedInputTrack(request, input);
+};
+export const isStreamingRequestedDevicesBase = (request, tracksOrDevices, devices) => {
+    const audio = isStreamingRequestingDevice(request.audio, tracksOrDevices.audio, devices);
+    const video = isStreamingRequestingDevice(request.video, tracksOrDevices.video, devices);
     return { audio, video };
 };
 /**
@@ -407,41 +432,51 @@ export const findPermissionGrantedDevices = (devices) => devices.filter(isDevice
  * stream and there is no device with label, 'prompt' will be returned
  * otherwise, 'denied'.
  *
- * @param devices - The current devices
- * @param anyActiveStream - Has ever got an active stream to help the fallback to
+ * @param anyGrantedDevice - Any permission granted device
+ * @param anyLiveTrack - Has ever got a live track
  * guess the state more accurately
  */
-export const toPermissionState = (devices, anyActiveStream = false) => {
-    const granted = devices.some(device => device.label);
-    if (anyActiveStream) {
-        return granted ? 'granted' : 'denied';
+export const toPermissionState = (anyGrantedDevice, anyLiveTrack = false) => {
+    if (anyLiveTrack) {
+        return anyGrantedDevice ? 'granted' : 'denied';
     }
-    return granted ? 'granted' : 'prompt';
+    return anyGrantedDevice ? 'granted' : 'prompt';
 };
-/**
- * A wrapper for `navigator.permissions.query` with fallback to use
- * `navigator.mediaDevices.enumerateDevices` to guess the `PermissionState`
- *
- * @param anyActiveStream - Has ever got an active stream to help the fallback to
- * guess the state more accurately
- */
-export const getInputDevicePermissionState = async (anyActiveStream = false) => {
+export const queryPermissionFallback = async (name, everActiveTrack = false, getDevices = () => navigator.mediaDevices.enumerateDevices()) => {
+    const devices = await getDevices();
+    const kind = name === 'camera' ? 'videoinput' : 'audioinput';
+    return toPermissionState(devices.some(device => device.kind === kind && isDeviceGranted(device)), everActiveTrack);
+};
+export const queryPermission = async (name, everActiveTrack = false, getDevices = () => navigator.mediaDevices.enumerateDevices()) => {
     try {
         // @ts-expect-error -- Typings/dom.d.ts change blocks upgrade to typescript 4.4
-        const video = await navigator.permissions.query({ name: 'camera' });
-        // @ts-expect-error -- Typings/dom.d.ts change blocks upgrade to typescript 4.4
-        const audio = await navigator.permissions.query({ name: 'microphone' });
-        return { video: video.state, audio: audio.state };
+        const { state } = await navigator.permissions.query({ name });
+        // Firefox v133 added permission API but always returns granted but
+        // based on the device label, it is actually not granted, so we need to
+        // fallback to use `enumerateDevices` to guess the state
+        if (state === 'granted') {
+            return await queryPermissionFallback(name, everActiveTrack, getDevices);
+        }
+        return state;
     }
     catch {
-        const devices = await getDevices();
-        return ['videoinput', 'audioinput'].reduce((permission, kind) => {
-            const state = toPermissionState(devices.filter(device => device.kind === kind), anyActiveStream);
-            permission[kind === 'audioinput' ? 'audio' : 'video'] = state;
-            return permission;
-        }, { video: 'prompt', audio: 'prompt' });
+        return await queryPermissionFallback(name, everActiveTrack, getDevices);
     }
 };
+/**
+ * A wrapper for `navigator.permissions.query` with fallback to use
+ * `navigator.mediaDevices.enumerateDevices` to guess the `PermissionState`
+ *
+ * @param anyActiveAudioTrack - Has ever got an active audio to help the fallback to
+ * guess the state more accurately
+ * @param anyActiveVideoTrack - Has ever got an active video to help the fallback to
+ * guess the state more accurately
+ * @param getDevices - A function to get the list of devices, e.g. navigator.mediaDevices.enumerateDevices
+ */
+export const getInputDevicePermissionState = async (anyActiveAudioTrack = false, anyActiveVideoTrack = false, getDevices = () => navigator.mediaDevices.enumerateDevices()) => ({
+    audio: await queryPermission('microphone', anyActiveAudioTrack, getDevices),
+    video: await queryPermission('camera', anyActiveVideoTrack, getDevices),
+});
 /**
  * Find current audio output id to be used to set as sinkId
  *

package/dist/getMediaStream.js

@@ -1,6 +1,5 @@
-import { MediaDeviceFailure } from './types';
 import { getDevices } from './devices';
-import { getMediaConstraints, relaxInputConstraint } from './constraints';
+import { getMediaConstraints } from './constraints';
 import { normalizeGetUserMediaError } from './errors';
 import { logger } from './logger';
 /**
@@ -11,25 +10,16 @@ import { logger } from './logger';
  * @beta
  */
 export const getMediaStream = async (request) => {
-    if (!request.audio && !request.video) {
-        throw new Error(MediaDeviceFailure.MissingConstraintsError);
-    }
-    const devices = await getDevices();
-    const audio = relaxInputConstraint(request.audio, devices);
-    const video = relaxInputConstraint(request.video, devices);
     const constraints = getMediaConstraints({
-        audio,
-        video,
+        audio: request.audio,
+        video: request.video,
         defaultConstraints: request.getDefaultConstraints(),
     });
-    logger.debug({ request, constraints, devices }, 'Constraints used for getting media');
+    logger.debug({ request, constraints }, 'Constraints used for getting media');
     try {
         // Track device changes before and after the getUserMedia call to keep
         // track of authorized/unauthorized devices
-        navigator.mediaDevices.dispatchEvent(new Event('devicechange'));
-        const stream = await navigator.mediaDevices.getUserMedia(constraints);
-        navigator.mediaDevices.dispatchEvent(new Event('devicechange'));
-        return stream;
+        return await navigator.mediaDevices.getUserMedia(constraints);
     }
     catch (error) {
         if (error instanceof Error) {

package/dist/index.d.ts

@@ -7,13 +7,13 @@
  *
  * @packageDocumentation
  */
-import { DeviceChangedChanges, areMultipleFacingModeSupported, areTracksEnabled, createTrackDevicesChanges, deviceChanged, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getInputDevicePermissionState, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, muteStreamTrack, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike } from './devices';
-import { compareDevices, findDevice, isAudioOutput, isVideoInput, isAudioInput, isDeviceGranted } from './utils';
-import { mergeConstraints, relaxInputConstraint, findDeviceFromConstraints, isExactDeviceConstraint, extractConstraintsWithKeys, applyConstraints, getValueFromConstrainNumber, getFacingModeFromConstraintString, extractConstrainDevice } from './constraints';
+import { DeviceChangedChanges, areMultipleFacingModeSupported, areTracksEnabled, createTrackDevicesChanges, deviceChanged, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getInputDevicePermissionState, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isStreamingRequestingDevice, isTrackMutedOrEnded, muteStreamTrack, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, toMediaDeviceInputKind } from './devices';
+import { compareDevices, createIndexedDevices, findDevice, getDeviceId, isAudioInput, isAudioOutput, isDeviceGranted, isVideoInput, reverseDeviceId } from './utils';
+import { applyConstraints, extractConstrainDevice, extractConstraintsWithKeys, findDeviceFromConstraints, getFacingModeFromConstraintString, getValueFromConstrainNumber, isExactDeviceConstraint, mergeConstraints, relaxInputConstraint, resolveMediaDeviceConstraints } from './constraints';
 import { MediaEvent, Events, MediaEventType } from './eventEmitter';
 import { createStreamTrackEventSubscriptions } from './streams';
-import { MediaDeviceRequest, MediaDeviceFailure, MediaDeviceKinds, MediaDeviceInfoLike, MediaStreamTrackLike, MediaInput, Unsubscribe, StreamTrackEventHandlers, InputConstraintSet, FacingMode, DisplayMediaOptions } from './types';
-import { isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isFacingMode } from './typeGuards';
+import { DisplayMediaOptions, FacingMode, IndexedDevices, InputConstraintSet, InputDeviceConstraint, MediaDeviceFailure, MediaDeviceInfoLike, MediaDeviceKinds, MediaDeviceRequest, MediaInput, MediaStreamTrackLike, StreamTrackEventHandlers, Unsubscribe } from './types';
+import { isFacingMode, isIndexedDevices, isInputConstraintSet, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack } from './typeGuards';
 export { setLogger } from './logger';
 declare const 
 /**
@@ -33,7 +33,7 @@ setDefaultConstraints: (newConstraints: MediaStreamConstraints) => void,
  */
 subscribe: (listener: (event: MediaEvent) => void) => () => void;
 export { getUserMedia, setDefaultConstraints, subscribe };
-export { DeviceChangedChanges, DisplayMediaOptions, Events, FacingMode, InputConstraintSet, MediaDeviceFailure, MediaDeviceInfoLike, MediaDeviceKinds, MediaDeviceRequest, MediaEvent, MediaEventType, MediaInput, MediaStreamTrackLike, StreamTrackEventHandlers, Unsubscribe, applyConstraints, areMultipleFacingModeSupported, areTracksEnabled, compareDevices, createStreamTrackEventSubscriptions, createTrackDevicesChanges, deviceChanged, extractConstraintsWithKeys, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDevice, findDeviceFromConstraints, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getFacingModeFromConstraintString, getInputDevicePermissionState, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, extractConstrainDevice, };
+export { DeviceChangedChanges, DisplayMediaOptions, Events, FacingMode, IndexedDevices, InputConstraintSet, InputDeviceConstraint, MediaDeviceFailure, MediaDeviceInfoLike, MediaDeviceKinds, MediaDeviceRequest, MediaEvent, MediaEventType, MediaInput, MediaStreamTrackLike, StreamTrackEventHandlers, Unsubscribe, applyConstraints, areMultipleFacingModeSupported, areTracksEnabled, compareDevices, createIndexedDevices, createStreamTrackEventSubscriptions, createTrackDevicesChanges, deviceChanged, extractConstrainDevice, extractConstraintsWithKeys, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDevice, findDeviceFromConstraints, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDeviceId, getDevices, getFacingModeFromConstraintString, getInputDevicePermissionState, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isIndexedDevices, isInputConstraintSet, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isStreamingRequestingDevice, isTrackMutedOrEnded, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, resolveMediaDeviceConstraints, reverseDeviceId, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, toMediaDeviceInputKind, };
 export * from './constants';
 export * from './displayMedia';
 /**

package/dist/index.js

@@ -7,13 +7,13 @@
  *
  * @packageDocumentation
  */
-import { areMultipleFacingModeSupported, areTracksEnabled, createTrackDevicesChanges, deviceChanged, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getInputDevicePermissionState, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, muteStreamTrack, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, } from './devices';
-import { compareDevices, findDevice, isAudioOutput, isVideoInput, isAudioInput, isDeviceGranted, } from './utils';
-import { mergeConstraints, getConstraintsHandlers, relaxInputConstraint, findDeviceFromConstraints, isExactDeviceConstraint, extractConstraintsWithKeys, applyConstraints, getValueFromConstrainNumber, getFacingModeFromConstraintString, extractConstrainDevice, } from './constraints';
+import { areMultipleFacingModeSupported, areTracksEnabled, createTrackDevicesChanges, deviceChanged, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getInputDevicePermissionState, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isStreamingRequestingDevice, isTrackMutedOrEnded, muteStreamTrack, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, toMediaDeviceInputKind, } from './devices';
+import { compareDevices, createIndexedDevices, findDevice, getDeviceId, isAudioInput, isAudioOutput, isDeviceGranted, isVideoInput, reverseDeviceId, } from './utils';
+import { applyConstraints, extractConstrainDevice, extractConstraintsWithKeys, findDeviceFromConstraints, getConstraintsHandlers, getFacingModeFromConstraintString, getValueFromConstrainNumber, isExactDeviceConstraint, mergeConstraints, relaxInputConstraint, resolveMediaDeviceConstraints, } from './constraints';
 import { eventEmitter, MediaEventType } from './eventEmitter';
 import { handleMediaStream, createStreamTrackEventSubscriptions, } from './streams';
 import { MediaDeviceFailure, MediaDeviceKinds, } from './types';
-import { isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isFacingMode, } from './typeGuards';
+import { isFacingMode, isIndexedDevices, isInputConstraintSet, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, } from './typeGuards';
 import { createStreamTrackMap } from './streamTrackMap';
 export { setLogger } from './logger';
 const state = () => {
@@ -100,6 +100,6 @@ setDefaultConstraints,
  */
 subscribe, } = state();
 export { getUserMedia, setDefaultConstraints, subscribe };
-export { MediaDeviceFailure, MediaDeviceKinds, MediaEventType, applyConstraints, areMultipleFacingModeSupported, areTracksEnabled, compareDevices, createStreamTrackEventSubscriptions, createTrackDevicesChanges, deviceChanged, extractConstraintsWithKeys, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDevice, findDeviceFromConstraints, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getFacingModeFromConstraintString, getInputDevicePermissionState, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, extractConstrainDevice, };
+export { MediaDeviceFailure, MediaDeviceKinds, MediaEventType, applyConstraints, areMultipleFacingModeSupported, areTracksEnabled, compareDevices, createIndexedDevices, createStreamTrackEventSubscriptions, createTrackDevicesChanges, deviceChanged, extractConstrainDevice, extractConstraintsWithKeys, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDevice, findDeviceFromConstraints, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDeviceId, getDevices, getFacingModeFromConstraintString, getInputDevicePermissionState, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isIndexedDevices, isInputConstraintSet, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isStreamingRequestingDevice, isTrackMutedOrEnded, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, resolveMediaDeviceConstraints, reverseDeviceId, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, toMediaDeviceInputKind, };
 export * from './constants';
 export * from './displayMedia';

package/dist/typeGuards.d.ts

@@ -1,4 +1,4 @@
-import type { ConstraintDeviceParameters, DeviceConstraint, InputConstraintSet } from './types';
+import type { ConstraintDeviceParameters, DeviceConstraint, IndexedDevices, InputConstraintSet, MediaDeviceTrackInfo } from './types';
 export declare const isBoolean: (t: unknown) => t is boolean;
 export declare const isUndefined: (t: unknown) => t is undefined;
 /**
@@ -86,4 +86,6 @@ export declare const isInputConstraintSet: (t: unknown) => t is InputConstraintS
  */
 export declare const isMediaStreamTrack: (m: unknown) => m is MediaStreamTrack;
 export declare const isFacingMode: (s: unknown) => s is "user" | "environment" | "left" | "right";
+export declare const isIndexedDevices: (t: unknown) => t is IndexedDevices;
+export declare const isMediaDeviceTrackInfo: (t: unknown) => t is MediaDeviceTrackInfo;
 export {};

package/dist/typeGuards.js

@@ -146,6 +146,12 @@ export const isConstraintDeviceParameters = isConstrainDOMParameters(t => isMedi
 export const isConstraintSetDevice = (t) => isMediaDeviceInfo(t) ||
     isMediaDeviceInfoArray(t) ||
     isConstraintDeviceParameters(t);
+const EXTENDED_CONSTRAIN_KEYS = [
+    ...EXTENDED_CONSTRAIN_DOUBLE_KEYS,
+    ...EXTENDED_CONSTRAIN_STRING_KEYS,
+    ...EXTENDED_CONSTRAIN_U_LONG_KEYS,
+    ...EXTENDED_CONSTRAIN_BOOLEAN_KEYS,
+];
 export const isExtendedConstraint = (t) => {
     if (typeof t !== 'object' || t === null) {
         return false;
@@ -154,12 +160,7 @@ export const isExtendedConstraint = (t) => {
         const { device } = t;
         return isConstraintSetDevice(device);
     }
-    return [
-        ...EXTENDED_CONSTRAIN_DOUBLE_KEYS,
-        ...EXTENDED_CONSTRAIN_STRING_KEYS,
-        ...EXTENDED_CONSTRAIN_U_LONG_KEYS,
-        ...EXTENDED_CONSTRAIN_BOOLEAN_KEYS,
-    ].some(key => hasOwn(t, key));
+    return EXTENDED_CONSTRAIN_KEYS.some(key => hasOwn(t, key));
 };
 export const isInputConstraintSet = (t) => {
     if (typeof t !== 'object' || t === null) {
@@ -184,3 +185,25 @@ export const isFacingMode = (s) => {
     }
     return false;
 };
+export const isIndexedDevices = (t) => {
+    if (typeof t === 'object' && t !== null) {
+        if ('get' in t &&
+            'size' in t &&
+            typeof t.get === 'function' &&
+            typeof t.size === 'function') {
+            return true;
+        }
+    }
+    return false;
+};
+export const isMediaDeviceTrackInfo = (t) => {
+    if (typeof t === 'object' && t !== null) {
+        return ('deviceId' in t &&
+            'groupId' in t &&
+            'kind' in t &&
+            'label' in t &&
+            'id' in t &&
+            'settings' in t);
+    }
+    return false;
+};

package/dist/types.d.ts

@@ -4,9 +4,33 @@
  * @beta
  */
 export type MediaDeviceInfoLike = Omit<MediaDeviceInfo, 'toJSON'> & {
-    settings?: MediaTrackSettings;
     toJSON?: MediaDeviceInfo['toJSON'];
 };
+export type MediaDeviceTrackInfo = MediaDeviceInfoLike & {
+    id: string;
+    settings: MediaTrackSettings;
+};
+export type IndexedDeviceMap = {
+    [Key in MediaDeviceInfo['kind']]: {
+        deviceId: Map<MediaDeviceInfoLike['deviceId'], MediaDeviceInfoLike>;
+        label: Map<MediaDeviceInfoLike['label'], MediaDeviceInfoLike[]>;
+        size: number;
+    };
+};
+export interface IndexedDevices {
+    /**
+     * Get devices by kind and device id or label
+     * When both `deviceId` and `label` are provided, it will use `deviceId` to
+     * to find the device, and when it's not found, it will use `label` to find
+     *
+     * @param device - the device to find
+     * @returns found devices otherwise empty array
+     */
+    get(device?: Pick<Partial<MediaDeviceInfoLike>, 'deviceId' | 'groupId' | 'label' | 'kind'>): MediaDeviceInfoLike[];
+    size(kind?: MediaDeviceKind): number;
+    first(kind: MediaDeviceInfo['kind']): MediaDeviceInfoLike | undefined;
+    toJSON(): Record<MediaDeviceKind, MediaDeviceInfoLike[]>;
+}
 export type DeviceConstraint = MediaDeviceInfoLike | MediaDeviceInfoLike[];
 export interface NormalizedConstraintDeviceParameters {
     exact?: MediaDeviceInfoLike[];

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { MediaDeviceInfoLike } from './types';
+import type { MediaDeviceInfoLike, IndexedDevices } from './types';
 import { MediaDeviceKinds } from './types';
 export declare const isSameDeviceKind: (kind: MediaDeviceKinds) => (device: MediaDeviceInfoLike) => boolean;
 export declare const isAudioInput: (device: MediaDeviceInfoLike) => boolean;
@@ -14,6 +14,31 @@ export declare const isAudioOutput: (device: MediaDeviceInfoLike) => boolean;
  **/
 export declare const isDeviceGranted: (device: MediaDeviceInfoLike) => boolean;
 export declare const not: <T = void>(fn: (arg: T) => boolean) => (arg: T) => boolean;
+/**
+ * Create a device ID from provided `device`.
+ * The device ID here is in the format of `groupId:deviceId:kind`, be default.
+ *
+ * @param device - The device to create the ID from
+ * @param separator - The separator to use to join the device ID
+ */
+export declare const getDeviceId: (device: Pick<MediaDeviceInfoLike, 'groupId' | 'deviceId' | 'kind'>, separator?: string) => string;
+/**
+ * Reverse the device ID to its original form i.e. `MediaDeviceInfo`
+ * The device ID here is in the format of `groupId:deviceId:kind`, be default.
+ *
+ * @param id - The device ID to reverse
+ * @param separator - The separator used to split the device ID
+ */
+export declare const reverseDeviceId: (id: string, separator?: string) => {
+    deviceId: string;
+    groupId: string;
+    kind: MediaDeviceKind;
+};
+/**
+ * Create an `IndexedDevices` construct from provided `devices` which index the
+ * device by device ID or kind.
+ */
+export declare const createIndexedDevices: (devices: MediaDeviceInfoLike[]) => IndexedDevices;
 /**
  * Compare 2 devices to see if they are the same by `deviceId` or `label` as
  * a fallback
@@ -22,7 +47,7 @@ export declare const not: <T = void>(fn: (arg: T) => boolean) => (arg: T) => boo
  */
 export declare const compareDevices: (deviceInfo: MediaDeviceInfoLike, key?: Exclude<keyof MediaDeviceInfoLike, 'kind' | 'settings'>) => (anotherDeviceInfo: MediaDeviceInfoLike) => boolean;
 /**
- * Lookup the the `device` from `devices` list
+ * Lookup the `device` from `devices` list
  *
  * @remarks
  * When we cannot find the device by `deviceId`, we compare the label as last

package/dist/utils.js

@@ -1,4 +1,6 @@
+import { assert } from '@pexip/utils';
 import { MediaDeviceKinds } from './types';
+import { DEVICE_ID_SEPARATOR } from './constants';
 export const isSameDeviceKind = (kind) => (device) => device.kind === kind;
 export const isAudioInput = isSameDeviceKind(MediaDeviceKinds.AUDIOINPUT);
 export const isVideoInput = isSameDeviceKind(MediaDeviceKinds.VIDEOINPUT);
@@ -13,6 +15,126 @@ export const isAudioOutput = isSameDeviceKind(MediaDeviceKinds.AUDIOOUTPUT);
  **/
 export const isDeviceGranted = (device) => Boolean(device.label);
 export const not = (fn) => (arg) => !fn(arg);
+/**
+ * Create a device ID from provided `device`.
+ * The device ID here is in the format of `groupId:deviceId:kind`, be default.
+ *
+ * @param device - The device to create the ID from
+ * @param separator - The separator to use to join the device ID
+ */
+export const getDeviceId = (device, separator = DEVICE_ID_SEPARATOR) => [device.groupId, device.deviceId, device.kind].join(separator);
+/**
+ * Reverse the device ID to its original form i.e. `MediaDeviceInfo`
+ * The device ID here is in the format of `groupId:deviceId:kind`, be default.
+ *
+ * @param id - The device ID to reverse
+ * @param separator - The separator used to split the device ID
+ */
+export const reverseDeviceId = (id, separator = DEVICE_ID_SEPARATOR) => {
+    const [groupId, deviceId, kind] = id.split(separator);
+    assert(groupId !== undefined, `Invalid id[${id}] format: groupId`);
+    assert(deviceId !== undefined, `Invalid id[${id}] format: deviceId`);
+    assert(kind === 'audioinput' ||
+        kind === 'videoinput' ||
+        kind === 'audiooutput', `Invalid id[${id}] format: kind`);
+    return { deviceId, groupId, kind: kind };
+};
+/**
+ * Create an `IndexedDevices` construct from provided `devices` which index the
+ * device by device ID or kind.
+ */
+export const createIndexedDevices = (devices) => {
+    const emptyIndex = {
+        audioinput: {
+            deviceId: new Map(),
+            label: new Map(),
+            get size() {
+                return this.deviceId.size;
+            },
+        },
+        audiooutput: {
+            deviceId: new Map(),
+            label: new Map(),
+            get size() {
+                return this.deviceId.size;
+            },
+        },
+        videoinput: {
+            deviceId: new Map(),
+            label: new Map(),
+            get size() {
+                return this.deviceId.size;
+            },
+        },
+        size(kind) {
+            switch (kind) {
+                case 'audioinput':
+                    return this.audioinput.size;
+                case 'audiooutput':
+                    return this.audiooutput.size;
+                case 'videoinput':
+                    return this.videoinput.size;
+                default:
+                    return (this.audioinput.size +
+                        this.audiooutput.size +
+                        this.videoinput.size);
+            }
+        },
+        get(deviceToFind) {
+            const { deviceId, kind, label } = deviceToFind ?? {};
+            if (!kind) {
+                return [
+                    ...this.get({ ...deviceToFind, kind: 'audioinput' }),
+                    ...this.get({ ...deviceToFind, kind: 'audiooutput' }),
+                    ...this.get({ ...deviceToFind, kind: 'videoinput' }),
+                ];
+            }
+            const deviceIdMap = this[kind].deviceId;
+            const findSimilarDevices = (label) => {
+                const foundSimilar = this[kind].label.get(label);
+                return foundSimilar ? foundSimilar : [];
+            };
+            if (deviceId !== undefined) {
+                const foundExact = deviceIdMap.get(deviceId);
+                if (!foundExact && label) {
+                    return findSimilarDevices(label);
+                }
+                return foundExact ? [foundExact] : [];
+            }
+            if (label) {
+                return findSimilarDevices(label);
+            }
+            return [...deviceIdMap.values()];
+        },
+        first(kind) {
+            if (!kind) {
+                return;
+            }
+            for (const device of this[kind].deviceId.values()) {
+                return device;
+            }
+        },
+        toJSON() {
+            return {
+                audioinput: this.get({ kind: 'audioinput' }),
+                videoinput: this.get({ kind: 'videoinput' }),
+                audiooutput: this.get({ kind: 'audiooutput' }),
+            };
+        },
+    };
+    return devices.reduce((acc, device) => {
+        // We don't want to index devices that are not granted
+        if (device.label && device.deviceId !== undefined) {
+            acc[device.kind].deviceId.set(device.deviceId, device);
+        }
+        if (device.label) {
+            const labelDevices = acc[device.kind].label.get(device.label) ?? [];
+            labelDevices.push(device);
+            acc[device.kind].label.set(device.label, labelDevices);
+        }
+        return acc;
+    }, emptyIndex);
+};
 /**
  * Compare 2 devices to see if they are the same by `deviceId` or `label` as
  * a fallback
@@ -22,7 +144,7 @@ export const not = (fn) => (arg) => !fn(arg);
 export const compareDevices = (deviceInfo, key = 'deviceId') => (anotherDeviceInfo) => deviceInfo.kind === anotherDeviceInfo.kind &&
     deviceInfo[key] === anotherDeviceInfo[key];
 /**
- * Lookup the the `device` from `devices` list
+ * Lookup the `device` from `devices` list
  *
  * @remarks
  * When we cannot find the device by `deviceId`, we compare the label as last

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pexip/media-control",
-  "version": "18.5.0",
+  "version": "19.0.0",
   "homepage": "https://gitlab.com/pexip/zoo",
   "bugs": "https://gitlab.com/pexip/zoo/issues",
   "repository": {
@@ -28,10 +28,11 @@
     "typecheck": "yarn tsc --noEmit -p tsconfig.build.json"
   },
   "dependencies": {
-    "@pexip/utils": "16.12.1"
+    "@pexip/utils": "16.13.0"
   },
   "devDependencies": {
-    "@pexip/bundler": "17.0.0",
+    "@jest/globals": "^29.7.0",
+    "@pexip/bundler": "17.1.0",
     "@swc/core": "^1.4.6",
     "@swc/jest": "^0.2.36",
     "@types/uuid": "^8.3.0",
@@ -40,7 +41,7 @@
     "jest-junit": "^16.0.0",
     "prettier": "^3.2.5",
     "typescript": "~5.3.0",
-    "uuid": "^9.0.0"
+    "uuid": "^11.0.0"
   },
   "publishConfig": {
     "access": "public",