@pexip/media 17.2.0 → 17.4.0

package/dist/previewController.js

@@ -0,0 +1,375 @@
+import { getUserMedia, hasChangedInput, isMediaDeviceInfo, } from '@pexip/media-control';
+import { createAsyncQueue } from '@pexip/utils';
+import { UserMediaStatus } from './types';
+import { buildMedia, cloneMedia, createMediaPipeline, hasSettingsChanged, AUDIO_SETTINGS_KEYS, VIDEO_SETTINGS_KEYS, } from './utils';
+import { isMedia } from './typeGuard';
+import { createModuleLogger } from './logger';
+import { isInitial } from './status';
+import { createGetUserMediaProcess } from './userMedia';
+const DEFAULT_QUEUE_SIZE = 1;
+const DEFAULT_QUEUE_THROTTLE_MS = 500;
+const DEFAULT_QUEUE_DELAY_MS = 100;
+const DEFAULT_QUEUE_DROP_LAST = false;
+const isPreviewInput = (value) => {
+    if (isMediaDeviceInfo(value) || value === undefined) {
+        return true;
+    }
+    return false;
+};
+const extractFeaturesToConstraints = (keysToLookFor, settings) => {
+    if (!settings) {
+        return {};
+    }
+    return keysToLookFor.reduce((set, key) => {
+        if (settings[key] !== undefined) {
+            return { ...set, [key]: settings[key] };
+        }
+        return set;
+    }, {});
+};
+const createEventHandler = (eventHandlers) => (key) => (callback) => {
+    eventHandlers[key] = callback;
+    return () => {
+        eventHandlers[key] = undefined;
+    };
+};
+const getUM = async (constraints) => [
+    await getUserMedia(constraints),
+    UserMediaStatus.PermissionsGranted,
+];
+const createAudioVideoProcessingSettingsChangeDetector = (getCurrentMedia, getPreviewMedia) => {
+    const hasAudioSettingsChanged = hasSettingsChanged(AUDIO_SETTINGS_KEYS);
+    const hasVideoSettingsChanged = hasSettingsChanged(VIDEO_SETTINGS_KEYS);
+    return () => {
+        const currentMedia = getCurrentMedia?.();
+        const previewMedia = getPreviewMedia();
+        const { audio: [mainAudio], video: [mainVideo], } = currentMedia?.getSettings() ?? { audio: [], video: [] };
+        const { audio: [previewAudio], video: [previewVideo], } = previewMedia.getSettings();
+        const changed = hasAudioSettingsChanged(mainAudio, previewAudio) ||
+            hasVideoSettingsChanged(mainVideo, previewVideo);
+        return changed;
+    };
+};
+export const createPreviewStreamController = ({ getCurrentDevices, getCurrentMedia, updateMainStream, onEnded, mediaSignal, queueOptions = {
+    size: DEFAULT_QUEUE_SIZE,
+    throttleInMS: DEFAULT_QUEUE_THROTTLE_MS,
+    delayInMS: DEFAULT_QUEUE_DELAY_MS,
+    dropLast: DEFAULT_QUEUE_DROP_LAST,
+}, processors, }) => {
+    const queue = createAsyncQueue(queueOptions);
+    const eventHandlers = {};
+    const release = () => {
+        if (isInitial(props.media.status)) {
+            props.discardMedia = true;
+        }
+        props.media = buildMedia(() => ({ release }));
+        return Promise.resolve();
+    };
+    const internalProps = {
+        media: buildMedia(() => ({ release })),
+        updatingPreview: false,
+        updatingMain: false,
+        discardMedia: false,
+        initialized: false,
+    };
+    const logger = createModuleLogger({
+        module: 'PreviewStreamController',
+        eventHandlers,
+        props: internalProps,
+    });
+    const cleanUpMainSubscription = () => {
+        if (eventHandlers.unsubscribeMain) {
+            eventHandlers.unsubscribeMain();
+            eventHandlers.unsubscribeMain = undefined;
+        }
+    };
+    const props = new Proxy(internalProps, {
+        get: (target, p) => {
+            return target[p];
+        },
+        set: (target, p, value) => {
+            if (target[p] === value) {
+                return true;
+            }
+            logger.debug({ oldValue: target[p], newValue: value }, `Update Props[${p}]`);
+            switch (p) {
+                case 'media': {
+                    if (!isMedia(value)) {
+                        return false;
+                    }
+                    target[p] = value;
+                    eventHandlers[p]?.(value);
+                    // Unsubscribe main stream signal on change of inputs
+                    cleanUpMainSubscription();
+                    return true;
+                }
+                case 'audioInput':
+                case 'videoInput': {
+                    if (!isPreviewInput(value)) {
+                        return false;
+                    }
+                    target[p] = value;
+                    eventHandlers[p]?.(value);
+                    return true;
+                }
+                case 'updatingMain':
+                case 'updatingPreview': {
+                    if (typeof value !== 'boolean') {
+                        return false;
+                    }
+                    target[p] = value;
+                    eventHandlers[p]?.(value);
+                    return true;
+                }
+                default:
+                    Reflect.set(target, p, value);
+                    return true;
+            }
+        },
+    });
+    const postMediaPipeline = createMediaPipeline(
+    // Ignore the type conversion between tuple and array
+    processors);
+    const initFromMain = (mainMedia) => {
+        if (!mainMedia.stream) {
+            return;
+        }
+        postMediaPipeline
+            .execute(cloneMedia(mainMedia))
+            .then(media => {
+            props.media = media;
+        })
+            .catch((error) => {
+            logger.error({ error }, 'Failed to post process media');
+        })
+            .finally(() => {
+            props.initialized = true;
+            if (props.discardMedia) {
+                void props.media.release();
+            }
+        });
+        props.audioInput = mainMedia.audioInput;
+        props.videoInput = mainMedia.videoInput;
+        props.originalMainAudioInput = mainMedia.audioInput;
+    };
+    const mainMedia = getCurrentMedia();
+    if (mainMedia?.stream) {
+        initFromMain(mainMedia);
+    }
+    else {
+        eventHandlers.unsubscribeMain = mediaSignal.add(initFromMain);
+    }
+    const replaceMainStream = async (constraints) => {
+        logger.debug({ constraints }, 'Replacing main stream');
+        props.updatingMain = true;
+        await updateMainStream(constraints);
+        props.updatingMain = false;
+    };
+    const mediaPipeline = createMediaPipeline(() => [
+        createGetUserMediaProcess(getUM, getCurrentDevices, {
+            initialMedia: props.media,
+            scope: 'PreviewStreamController',
+        }),
+        ...processors,
+    ]);
+    const updatePreviewMedia = async (constraints) => {
+        logger.debug({ constraints }, 'Requesting a new preview stream');
+        await props.media?.release();
+        const media = await mediaPipeline.execute(constraints);
+        if (props.discardMedia) {
+            logger.debug('Discard media');
+            return await media.release();
+        }
+        props.media = media;
+    };
+    const updateAudioInput = async (input) => {
+        props.audioInput = input;
+        const request = {
+            audio: { device: { exact: input } },
+            video: props.videoInput,
+        };
+        try {
+            props.updatingPreview = true;
+            await updatePreviewMedia(request);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                const errorName = error.name === 'Error' ? error.message : error.name;
+                if (errorName === 'NotReadableError') {
+                    try {
+                        logger.debug({ input }, 'NotReadableError, trying to sync main stream AudioInput');
+                        await replaceMainStream({
+                            audio: input,
+                            video: getCurrentMedia()?.videoInput,
+                        });
+                        await updatePreviewMedia(request);
+                    }
+                    catch (err) {
+                        logger.warn({ error: err, input }, 'Unable to recover NotReadableError AudioInput for preview');
+                        if (err instanceof Error) {
+                            return eventHandlers.audioInputError?.(err);
+                        }
+                        throw err;
+                    }
+                }
+                else {
+                    logger.warn({ error, input }, 'Unable to update AudioInput for preview');
+                    eventHandlers.audioInputError?.(error);
+                }
+            }
+            else {
+                logger.error({ error, input }, 'Unable to update AudioInput for preview');
+                throw error;
+            }
+        }
+        finally {
+            props.updatingPreview = false;
+        }
+    };
+    const updateVideoInput = async (input) => {
+        props.videoInput = input;
+        try {
+            props.updatingPreview = true;
+            await updatePreviewMedia({
+                audio: props.audioInput,
+                video: { device: { exact: input } },
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.warn({ error, input }, 'Unable to update VideoInput for preview');
+                return eventHandlers.videoInputError?.(error);
+            }
+            throw error;
+        }
+        finally {
+            props.updatingPreview = false;
+        }
+    };
+    const cleanup = () => {
+        logger.debug('Cleanup preview controller');
+        props.audioInput = undefined;
+        props.videoInput = undefined;
+        onEnded?.();
+    };
+    const hasChangedAudioInput = () => hasChangedInput(props.originalMainAudioInput, props.audioInput);
+    const hasChangedVideoInput = () => hasChangedInput(getCurrentMedia()?.videoInput, props.videoInput);
+    const hasAudioVideoProcessingSettingsChanged = createAudioVideoProcessingSettingsChangeDetector(getCurrentMedia, () => props.media);
+    const hasChanges = () => hasChangedAudioInput() ||
+        hasChangedVideoInput() ||
+        hasAudioVideoProcessingSettingsChanged();
+    const applyChanges = async (force = false) => {
+        const { audioInput, videoInput } = props;
+        const { audio: [previewAudio], video: [previewVideo], } = props.media.getSettings();
+        await props.media.release();
+        cleanUpMainSubscription();
+        if (force || hasChanges()) {
+            const audioSettings = extractFeaturesToConstraints(AUDIO_SETTINGS_KEYS, previewAudio);
+            const videoSettings = extractFeaturesToConstraints(VIDEO_SETTINGS_KEYS, previewVideo);
+            // Omit the width & height settings from the preview so that the one
+            // from the main can be applied
+            delete videoSettings.width;
+            delete videoSettings.height;
+            logger.info({ audioInput, videoInput, audioSettings, videoSettings }, 'Apply changes to main');
+            try {
+                await replaceMainStream({
+                    audio: { device: audioInput, ...audioSettings },
+                    video: { device: videoInput, ...videoSettings },
+                });
+                props.originalMainAudioInput = props.audioInput;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger.warn({ error }, 'Unable to apply changes to main');
+                    return eventHandlers.applyChangesError?.(error);
+                }
+                throw error;
+            }
+        }
+        cleanup();
+    };
+    const revertChanges = async () => {
+        await props.media.release();
+        cleanUpMainSubscription();
+        const mainMedia = getCurrentMedia();
+        const mainStream = mainMedia?.stream;
+        if (mainMedia && mainStream) {
+            // Workaround for iOS Safari bug
+            // https://bugs.webkit.org/show_bug.cgi?id=179363
+            const mainMuted = !!mainStream.getTracks().some(t => t.muted);
+            const current = mainMedia.audioInput;
+            const prev = props.originalMainAudioInput;
+            const audioChanged = hasChangedInput(prev, current);
+            if (mainMuted || audioChanged) {
+                logger.info({
+                    mainMuted,
+                    audioChanged,
+                    currentAudioInput: current,
+                    prevAudioInput: prev,
+                    mainMedia,
+                }, 'Reverting Changes to main');
+                try {
+                    await replaceMainStream({
+                        audio: prev,
+                        video: getCurrentMedia()?.videoInput,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        logger.warn({ error }, 'Unable to revert changes to main');
+                        return eventHandlers.revertChangesError?.(error);
+                    }
+                    throw error;
+                }
+            }
+        }
+        cleanup();
+    };
+    const updateInput = (hasChanged, updater) => (input) => {
+        if (hasChanged(input)) {
+            queue.enqueue(async () => {
+                await updater(input);
+            });
+        }
+    };
+    const toEvenHandler = createEventHandler(eventHandlers);
+    return {
+        get media() {
+            return props.media;
+        },
+        get audioInputChanged() {
+            return hasChangedAudioInput();
+        },
+        get videoInputChanged() {
+            return hasChangedVideoInput();
+        },
+        get inputChanged() {
+            return hasChanges();
+        },
+        get audioInput() {
+            return props.audioInput;
+        },
+        get videoInput() {
+            return props.videoInput;
+        },
+        get updatingPreview() {
+            return props.updatingPreview;
+        },
+        get updatingMain() {
+            return props.updatingMain;
+        },
+        updateAudioInput: updateInput(input => props.initialized && hasChangedInput(props.audioInput, input), updateAudioInput),
+        updateVideoInput: updateInput(input => props.initialized && hasChangedInput(props.videoInput, input), updateVideoInput),
+        onMediaChanged: toEvenHandler('media'),
+        onAudioInputChanged: toEvenHandler('audioInput'),
+        onVideoInputChanged: toEvenHandler('videoInput'),
+        onAudioInputError: toEvenHandler('audioInputError'),
+        onVideoInputError: toEvenHandler('videoInputError'),
+        onApplyChangesError: toEvenHandler('applyChangesError'),
+        onRevertChangesError: toEvenHandler('revertChangesError'),
+        onUpdatingPreview: toEvenHandler('updatingPreview'),
+        onUpdatingMain: toEvenHandler('updatingMain'),
+        applyChanges,
+        revertChanges,
+    };
+};

package/dist/signals.d.ts

@@ -0,0 +1,25 @@
+import type { Signal, SignalVariant } from '@pexip/signal';
+import type { MediaSignals } from './types';
+/**
+ * Create a general signal with consistent scoped name
+ *
+ * @param name - Signal name
+ * @param crucial - Signify if the signal is unmissable. @defaultValue true
+ * @param variant - The variant of the signal @see Signal @defaultValue 'generic'
+ */
+export declare const createMediaSignal: <T = undefined>(name: string, crucial?: boolean, variant?: SignalVariant) => Signal<T>;
+export declare const REQUIRED_SIGNAL_KEYS: readonly ["onMediaChanged", "onVAD", "onSilentDetected"];
+/**
+ * Create and return all required and optional (if specified with `more`),
+ * signals for media to work
+ *
+ * @param more - Keys from `MediaSignalsOptional`, @see MediaSignalsOptional
+ * @param scope - any scope prefix for the generated signal name, @see Signal
+ *
+ * The following signals created by default
+ * - 'onMediaChanged',
+ * - 'onVAD',
+ *
+ * @see REQUIRED_SIGNAL_KEYS
+ */
+export declare const createMediaSignals: <K extends "onDevicesChanged" | "onStatusChanged" | keyof import("./types").StreamTrackSignals>(more: K[], scope?: string) => Pick<Required<MediaSignals>, "onMediaChanged" | "onVAD" | "onSilentDetected" | K>;

package/dist/signals.js

@@ -0,0 +1,38 @@
+import { createSignal } from '@pexip/signal';
+/**
+ * Create a general signal with consistent scoped name
+ *
+ * @param name - Signal name
+ * @param crucial - Signify if the signal is unmissable. @defaultValue true
+ * @param variant - The variant of the signal @see Signal @defaultValue 'generic'
+ */
+export const createMediaSignal = (name, crucial = true, variant = 'generic') => createSignal({
+    name: `media/${name}`,
+    allowEmittingWithoutObserver: !crucial,
+    variant,
+});
+export const REQUIRED_SIGNAL_KEYS = [
+    'onMediaChanged',
+    'onVAD',
+    'onSilentDetected',
+];
+/**
+ * Create and return all required and optional (if specified with `more`),
+ * signals for media to work
+ *
+ * @param more - Keys from `MediaSignalsOptional`, @see MediaSignalsOptional
+ * @param scope - any scope prefix for the generated signal name, @see Signal
+ *
+ * The following signals created by default
+ * - 'onMediaChanged',
+ * - 'onVAD',
+ *
+ * @see REQUIRED_SIGNAL_KEYS
+ */
+export const createMediaSignals = (more, scope = '') => {
+    const signalScope = scope && [scope, ':'].join('');
+    return [...REQUIRED_SIGNAL_KEYS, ...more].reduce((signals, key) => ({
+        ...signals,
+        [key]: createMediaSignal(`${signalScope}${key}`),
+    }), {});
+};

package/dist/status.d.ts

@@ -0,0 +1,35 @@
+import { UserMediaStatus, DeniedDevices } from './types';
+export type UserMediaValidator = (status: UserMediaStatus) => boolean;
+export declare const isFallbackVideo: UserMediaValidator;
+export declare const isFallbackAudio: UserMediaValidator;
+export declare const isFallback: UserMediaValidator;
+export declare const hasNoDevice: UserMediaValidator;
+export declare const hasNoAudioDevices: UserMediaValidator;
+export declare const hasNoVideoDevices: UserMediaValidator;
+export declare const isGrantedOnlyVideoNoAudioDevices: UserMediaValidator;
+export declare const isPromptAudio: UserMediaValidator;
+export declare const isGrantedOnlyVideo: UserMediaValidator;
+export declare const isGrantedOnlyAudioNoVideoDevices: UserMediaValidator;
+export declare const isPromptVideo: UserMediaValidator;
+export declare const isGrantedOnlyAudio: UserMediaValidator;
+export declare const areBothGranted: UserMediaValidator;
+export declare const isGrantedVideo: UserMediaValidator;
+export declare const isGrantedAudio: UserMediaValidator;
+export declare const isGranted: UserMediaValidator;
+export declare const isOnlyAudioError: UserMediaValidator;
+export declare const isOnlyVideoError: UserMediaValidator;
+export declare const isRejected: UserMediaValidator;
+export declare const isRejectedOnlyAudio: UserMediaValidator;
+export declare const isRejectedOnlyVideo: UserMediaValidator;
+export declare const isOverConstrained: UserMediaValidator;
+export declare const isUnknownError: UserMediaValidator;
+export declare const isInitial: UserMediaValidator;
+export declare const isInitialPermissions: UserMediaValidator;
+export declare const isInitialPermissionsNotGranted: UserMediaValidator;
+export declare const isInitialPermissionsGranted: UserMediaValidator;
+export declare const isAudioDeviceInUse: UserMediaValidator;
+export declare const isDeviceInUse: UserMediaValidator;
+export declare const isVideoDeviceInUse: UserMediaValidator;
+export declare const toDeniedDevices: (status?: UserMediaStatus) => DeniedDevices | undefined;
+export declare const getPermissionStatus: (getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus.Initial | UserMediaStatus.InitialPermissionsGranted | UserMediaStatus.InitialPermissionsNotGranted | UserMediaStatus.InitialPermissionsVideoInputDenied | UserMediaStatus.InitialPermissionsAudioInputDenied | UserMediaStatus.InitialPermissionsVideoInputGranted | UserMediaStatus.InitialPermissionsAudioInputGranted | UserMediaStatus.InitialPermissionsGrantedVideoInputDenied | UserMediaStatus.InitialPermissionsGrantedAudioInputDenied | UserMediaStatus.PermissionsRejected>;
+export declare const deriveInitialPermissionStatus: (prevStatus: UserMediaStatus, getPermissionState?: (anyActiveStream?: boolean | undefined) => Promise<import("@pexip/media-control").InputDevicePermission>) => Promise<UserMediaStatus>;

package/dist/status.js

@@ -0,0 +1,199 @@
+import { getInputDevicePermissionState } from '@pexip/media-control';
+import { UserMediaStatus, DeniedDevices } from './types';
+export const isFallbackVideo = status => [
+    UserMediaStatus.PermissionsOnlyVideoinputFallback,
+    UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices,
+    UserMediaStatus.PermissionsGrantedFallback,
+    UserMediaStatus.PermissionsGrantedFallbackVideoinput,
+].includes(status);
+export const isFallbackAudio = status => [
+    UserMediaStatus.PermissionsOnlyAudioinputFallback,
+    UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices,
+    UserMediaStatus.PermissionsGrantedFallback,
+    UserMediaStatus.PermissionsGrantedFallbackAudioinput,
+].includes(status);
+export const isFallback = status => status === UserMediaStatus.PermissionsGrantedFallback ||
+    isFallbackAudio(status) ||
+    isFallbackVideo(status);
+export const hasNoDevice = status => UserMediaStatus.NoDevicesFound === status;
+export const hasNoAudioDevices = status => hasNoDevice(status) ||
+    status === UserMediaStatus.NoAudioDevicesFound ||
+    isGrantedOnlyVideoNoAudioDevices(status);
+export const hasNoVideoDevices = status => hasNoDevice(status) ||
+    status === UserMediaStatus.NoVideoDevicesFound ||
+    isGrantedOnlyAudioNoVideoDevices(status);
+export const isGrantedOnlyVideoNoAudioDevices = status => [
+    UserMediaStatus.PermissionsOnlyVideoinputNoAudioDevices,
+    UserMediaStatus.PermissionsOnlyVideoinputFallbackNoAudioDevices,
+].includes(status);
+export const isPromptAudio = status => [
+    UserMediaStatus.PermissionsOnlyVideoinput,
+    UserMediaStatus.PermissionsOnlyVideoinputFallback,
+].includes(status);
+export const isGrantedOnlyVideo = status => isGrantedOnlyVideoNoAudioDevices(status) ||
+    isPromptAudio(status) ||
+    isRejectedOnlyAudio(status) ||
+    isOnlyAudioError(status);
+export const isGrantedOnlyAudioNoVideoDevices = status => [
+    UserMediaStatus.PermissionsOnlyAudioinputNoVideoDevices,
+    UserMediaStatus.PermissionsOnlyAudioinputFallbackNoVideoDevices,
+].includes(status);
+export const isPromptVideo = status => [
+    UserMediaStatus.PermissionsOnlyAudioinput,
+    UserMediaStatus.PermissionsOnlyAudioinputFallback,
+].includes(status);
+export const isGrantedOnlyAudio = status => isGrantedOnlyAudioNoVideoDevices(status) ||
+    isPromptVideo(status) ||
+    isRejectedOnlyVideo(status) ||
+    isOnlyVideoError(status);
+export const areBothGranted = status => [
+    UserMediaStatus.PermissionsGranted,
+    UserMediaStatus.PermissionsGrantedFallback,
+    UserMediaStatus.PermissionsGrantedFallbackAudioinput,
+    UserMediaStatus.PermissionsGrantedFallbackVideoinput,
+].includes(status);
+export const isGrantedVideo = status => areBothGranted(status) ||
+    isGrantedOnlyVideoNoAudioDevices(status) ||
+    isGrantedOnlyVideo(status);
+export const isGrantedAudio = status => areBothGranted(status) ||
+    isGrantedOnlyAudio(status) ||
+    isGrantedOnlyAudioNoVideoDevices(status);
+export const isGranted = status => isGrantedVideo(status) || isGrantedAudio(status);
+export const isOnlyAudioError = status => [
+    UserMediaStatus.PermissionsRejectedAudioInput,
+    UserMediaStatus.AudioDeviceInUse,
+    UserMediaStatus.AudioOverconstrained,
+    UserMediaStatus.InvalidAudioConstraints,
+    UserMediaStatus.NotSupportedErrorOnlyAudioInput,
+].includes(status);
+export const isOnlyVideoError = status => [
+    UserMediaStatus.PermissionsRejectedVideoInput,
+    UserMediaStatus.VideoDeviceInUse,
+    UserMediaStatus.VideoOverconstrained,
+    UserMediaStatus.InvalidVideoConstraints,
+    UserMediaStatus.NotSupportedErrorOnlyVideoInput,
+].includes(status);
+export const isRejected = status => UserMediaStatus.PermissionsRejected === status;
+export const isRejectedOnlyAudio = status => [
+    UserMediaStatus.PermissionsRejectedAudioInput,
+    UserMediaStatus.InitialPermissionsGrantedAudioInputDenied,
+    UserMediaStatus.InitialPermissionsAudioInputDenied,
+].includes(status);
+export const isRejectedOnlyVideo = status => [
+    UserMediaStatus.PermissionsRejectedVideoInput,
+    UserMediaStatus.InitialPermissionsGrantedVideoInputDenied,
+    UserMediaStatus.InitialPermissionsVideoInputDenied,
+].includes(status);
+export const isOverConstrained = status => [
+    UserMediaStatus.Overconstrained,
+    UserMediaStatus.VideoOverconstrained,
+    UserMediaStatus.AudioOverconstrained,
+].includes(status);
+export const isUnknownError = status => [
+    UserMediaStatus.UnknownError,
+    UserMediaStatus.UnknownErrorOnlyVideoinput,
+    UserMediaStatus.UnknownErrorOnlyAudioinput,
+].includes(status);
+export const isInitial = status => status === UserMediaStatus.Initial;
+export const isInitialPermissions = status => [
+    UserMediaStatus.InitialPermissionsAudioInputDenied,
+    UserMediaStatus.InitialPermissionsAudioInputGranted,
+    UserMediaStatus.InitialPermissionsGranted,
+    UserMediaStatus.InitialPermissionsGrantedAudioInputDenied,
+    UserMediaStatus.InitialPermissionsGrantedVideoInputDenied,
+    UserMediaStatus.InitialPermissionsNotGranted,
+    UserMediaStatus.InitialPermissionsVideoInputDenied,
+    UserMediaStatus.InitialPermissionsVideoInputGranted,
+].includes(status);
+export const isInitialPermissionsNotGranted = status => [
+    UserMediaStatus.InitialPermissionsAudioInputDenied,
+    UserMediaStatus.InitialPermissionsNotGranted,
+    UserMediaStatus.InitialPermissionsVideoInputDenied,
+].includes(status);
+export const isInitialPermissionsGranted = status => [
+    UserMediaStatus.InitialPermissionsGranted,
+    UserMediaStatus.InitialPermissionsGrantedAudioInputDenied,
+    UserMediaStatus.InitialPermissionsGrantedVideoInputDenied,
+].includes(status);
+export const isAudioDeviceInUse = status => status === UserMediaStatus.AudioDeviceInUse;
+export const isDeviceInUse = status => [
+    UserMediaStatus.DevicesInUse,
+    UserMediaStatus.AudioDeviceInUse,
+    UserMediaStatus.VideoDeviceInUse,
+].includes(status);
+export const isVideoDeviceInUse = status => status === UserMediaStatus.VideoDeviceInUse;
+export const toDeniedDevices = (status) => {
+    if (!status) {
+        return undefined;
+    }
+    if (isRejectedOnlyVideo(status)) {
+        return DeniedDevices.Camera;
+    }
+    if (isRejectedOnlyAudio(status)) {
+        return DeniedDevices.Microphone;
+    }
+    if (isRejected(status)) {
+        return DeniedDevices.Both;
+    }
+};
+export const getPermissionStatus = async (getPermissionState = getInputDevicePermissionState) => {
+    const { audio, video } = await getPermissionState();
+    if (audio === 'denied') {
+        if (video === 'denied') {
+            return UserMediaStatus.PermissionsRejected;
+        }
+        if (video === 'granted') {
+            return UserMediaStatus.InitialPermissionsGrantedAudioInputDenied;
+        }
+        if (video === 'prompt') {
+            return UserMediaStatus.InitialPermissionsAudioInputDenied;
+        }
+    }
+    if (audio === 'granted') {
+        if (video === 'denied') {
+            return UserMediaStatus.InitialPermissionsGrantedVideoInputDenied;
+        }
+        if (video === 'granted') {
+            return UserMediaStatus.InitialPermissionsGranted;
+        }
+        if (video === 'prompt') {
+            return UserMediaStatus.InitialPermissionsAudioInputGranted;
+        }
+    }
+    if (audio === 'prompt') {
+        if (video === 'denied') {
+            return UserMediaStatus.InitialPermissionsVideoInputDenied;
+        }
+        if (video === 'granted') {
+            return UserMediaStatus.InitialPermissionsVideoInputGranted;
+        }
+        if (video === 'prompt') {
+            return UserMediaStatus.InitialPermissionsNotGranted;
+        }
+    }
+    return UserMediaStatus.Initial;
+};
+export const deriveInitialPermissionStatus = async (prevStatus, getPermissionState = getInputDevicePermissionState) => {
+    if (isInitialPermissions(prevStatus) || isRejected(prevStatus)) {
+        return prevStatus;
+    }
+    const { audio, video } = await getPermissionState();
+    if (areBothGranted(prevStatus) ||
+        (audio === 'granted' && video === 'granted')) {
+        return UserMediaStatus.InitialPermissionsGranted;
+    }
+    if (isGrantedAudio(prevStatus)) {
+        return isRejectedOnlyVideo(prevStatus)
+            ? UserMediaStatus.InitialPermissionsGrantedVideoInputDenied
+            : UserMediaStatus.InitialPermissionsAudioInputGranted;
+    }
+    if (isGrantedVideo(prevStatus)) {
+        return isRejectedOnlyAudio(prevStatus)
+            ? UserMediaStatus.InitialPermissionsGrantedAudioInputDenied
+            : UserMediaStatus.InitialPermissionsVideoInputGranted;
+    }
+    if (prevStatus === UserMediaStatus.DevicesInUse) {
+        return UserMediaStatus.InitialPermissionsGranted;
+    }
+    return await getPermissionStatus(getPermissionState);
+};

package/dist/typeGuard.d.ts

@@ -0,0 +1,9 @@
+import type { AnalyzerNodeInit } from '@pexip/media-processor';
+import type { Media, AudioContentHint, VideoContentHint } from './types';
+import { UserMediaStatus } from './types';
+export declare const isNonNullObject: (value: unknown) => value is Record<string, unknown>;
+export declare const isUserMediaStatus: (value: unknown) => value is UserMediaStatus;
+export declare const isMedia: (value: unknown) => value is Media;
+export declare const isAnalyzerNodeInitProp: (value: unknown) => value is AnalyzerNodeInit | undefined;
+export declare const isAudioContentHint: (value: unknown) => value is AudioContentHint;
+export declare const isVideoContentHint: (value: unknown) => value is VideoContentHint;