@pexip/media-control 17.2.0 → 17.4.0

package/dist/displayMedia.d.ts

@@ -0,0 +1,10 @@
+import type { DisplayMediaOptions } from './types';
+/**
+ * A fallback implementation of `monitorTypeSurfaces` limitation when it is not
+ * supported by the current browser and the source of the `displaySurface` is
+ * available.
+ *
+ * @param constraints - The constraints used to request display media.
+ * @param stream - The MediaStream returned from the requesting display media.
+ */
+export declare const limitSharingMonitorInterface: (constraints: DisplayMediaOptions, stream: MediaStream) => MediaStream;

package/dist/displayMedia.js

@@ -0,0 +1,31 @@
+import { stopMediaStream } from './devices';
+/**
+ * A fallback implementation of `monitorTypeSurfaces` limitation when it is not
+ * supported by the current browser and the source of the `displaySurface` is
+ * available.
+ *
+ * @param constraints - The constraints used to request display media.
+ * @param stream - The MediaStream returned from the requesting display media.
+ */
+export const limitSharingMonitorInterface = (constraints, stream) => {
+    // Fallback implementation of `monitorTypeSurfaces`
+    if (!constraints.monitorTypeSurfaces ||
+        constraints.monitorTypeSurfaces !== 'exclude') {
+        return stream;
+    }
+    for (const track of stream.getTracks()) {
+        const { displaySurface } = track.getSettings();
+        if (!displaySurface || displaySurface !== 'monitor') {
+            continue;
+        }
+        stopMediaStream(stream);
+        throw new TypeError('MonitorSharingNotAllowed', {
+            cause: {
+                monitorTypeSurfaces: constraints.monitorTypeSurfaces,
+                track,
+                displaySurface,
+            },
+        });
+    }
+    return stream;
+};

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import type { MediaDeviceInfoLike, MediaDeviceKinds, MediaDeviceRequest } from './types';
+import { MediaDeviceFailure } from './types';
+export interface InputNotFoundErrorParams {
+    input: MediaTrackConstraints | boolean | undefined;
+    kind: MediaDeviceKinds;
+    devices: MediaDeviceInfoLike[];
+}
+export declare const isInputNotFoundError: ({ input, kind, devices }: InputNotFoundErrorParams) => (error: string) => boolean;
+export declare const normalizeGetUserMediaError: (browserError: Error, constraints: MediaStreamConstraints, devices: MediaDeviceInfoLike[]) => MediaDeviceFailure | string;
+export declare const normalizeDeviceError: ({ audio, video, streamingAudioInput, streamingVideoInput, }: {
+    streamingAudioInput?: boolean | undefined;
+    streamingVideoInput?: boolean | undefined;
+} & MediaDeviceRequest) => false | MediaDeviceFailure;

package/dist/errors.js

@@ -0,0 +1,105 @@
+import { isMediaTrackConstraints } from './typeGuards';
+import { extractDeviceId } from './constraints';
+import { MediaDeviceFailure } from './types';
+const isDeviceInUseError = (error) => {
+    return (error === MediaDeviceFailure.NotReadableError ||
+        error === MediaDeviceFailure.TrackStartError);
+};
+const isPermissionDeniedError = (error) => {
+    return (error === MediaDeviceFailure.NotAllowedError ||
+        error === MediaDeviceFailure.PermissionDeniedError);
+};
+export const isInputNotFoundError = ({ input, kind, devices }) => (error) => {
+    if (error === MediaDeviceFailure.NotFoundError) {
+        const hasDevices = devices.some(d => d.kind === kind);
+        if (typeof input === 'boolean') {
+            if (!hasDevices && input) {
+                return true;
+            }
+            return input && !hasDevices;
+        }
+        if (isMediaTrackConstraints(input)) {
+            const [deviceIds, requirement] = extractDeviceId(input);
+            if (requirement === 'ideal') {
+                return !hasDevices;
+            }
+            if (requirement === 'exact') {
+                return !devices.some(device => deviceIds?.some(id => device.kind === kind && id === device.deviceId));
+            }
+        }
+    }
+    return false;
+};
+const normalizeError = (errors, parameters = []) => {
+    const error = errors.find(e => e.fn(...parameters));
+    if (error) {
+        return error.type;
+    }
+    return false;
+};
+export const normalizeGetUserMediaError = (browserError, constraints, devices) => {
+    const isAudioInputNotFoundError = isInputNotFoundError({
+        input: constraints.audio,
+        kind: 'audioinput',
+        devices,
+    });
+    const isVideoInputNotFoundError = isInputNotFoundError({
+        input: constraints.video,
+        kind: 'videoinput',
+        devices,
+    });
+    const areBothInputsNotFoundError = (error) => isAudioInputNotFoundError(error) && isVideoInputNotFoundError(error);
+    const errorsFn = [
+        {
+            fn: isDeviceInUseError,
+            type: MediaDeviceFailure.NotReadableError, // For now just normalize to current spec
+        },
+        {
+            fn: isPermissionDeniedError,
+            type: MediaDeviceFailure.NotAllowedError,
+        },
+        {
+            fn: areBothInputsNotFoundError,
+            type: MediaDeviceFailure.AudioAndVideoDeviceNotFoundError,
+        },
+        {
+            fn: isAudioInputNotFoundError,
+            type: MediaDeviceFailure.AudioInputDeviceNotFoundError,
+        },
+        {
+            fn: isVideoInputNotFoundError,
+            type: MediaDeviceFailure.VideoInputDeviceNotFoundError,
+        },
+    ];
+    const errorMsg = browserError.name === 'Error'
+        ? browserError.message
+        : browserError.name;
+    const error = normalizeError(errorsFn, [errorMsg]);
+    return error ? error : errorMsg;
+};
+export const normalizeDeviceError = ({ audio, video, streamingAudioInput, streamingVideoInput, }) => {
+    let audioError = false;
+    let videoError = false;
+    if (audio) {
+        audioError = !streamingAudioInput;
+    }
+    if (video) {
+        videoError = !streamingVideoInput;
+    }
+    const errorsFn = [
+        {
+            fn: () => audioError && videoError,
+            type: MediaDeviceFailure.AudioAndVideoDeviceNotFoundError,
+        },
+        {
+            fn: () => audioError,
+            type: MediaDeviceFailure.AudioInputDeviceNotFoundError,
+        },
+        {
+            fn: () => videoError,
+            type: MediaDeviceFailure.VideoInputDeviceNotFoundError,
+        },
+    ];
+    const error = normalizeError(errorsFn, []);
+    return error ? error : false;
+};

package/dist/eventEmitter.d.ts

@@ -0,0 +1,119 @@
+import type { MediaDeviceInfoLike } from './types';
+/**
+ * MediaStreamTrack Events
+ *
+ * @remarks
+ * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#Events | Events}
+ *
+ * @beta
+ */
+export declare enum MediaEventType {
+    /**
+     * Sent to the MediaStreamTrack when the value of the muted property is
+     * changed to true, indicating that the track is unable to provide data
+     * temporarily (such as when the network is experiencing a service
+     * malfunction).
+     */
+    Mute = "mute",
+    /**
+     * Sent to the track when data becomes available again, ending the muted state.
+     */
+    Unmute = "unmute",
+    /**
+     * Sent when playback of the track ends (when the value readyState changes to
+     * ended).
+     */
+    Ended = "ended",
+    /**
+     * Fired when a media input or output device is attached to or removed from
+     * the user's computer.
+     *
+     * @remarks
+     * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices#Events | Events}
+     */
+    DevicesChanged = "devices:changed",
+    /**
+     * Found new devices from authorized device list
+     */
+    DevicesFound = "devices:found",
+    /**
+     * Lost devices from authorized device list
+     */
+    DevicesLost = "devices:lost",
+    /**
+     * Lost device from authorized device list
+     */
+    DeviceLost = "device:lost",
+    /**
+     * Unauthorized devices
+     */
+    DevicesUnauthorized = "devices:unauthorized",
+    /**
+     * No Input Devices, and no further device events will be emitted
+     */
+    NoInputDevices = "devices:noinput",
+    /**
+     * Other errors
+     */
+    Error = "error",
+    /**
+     * When stream
+     */
+    Stream = "stream"
+}
+/**
+ * Event object by MediaEventType
+ *
+ * @beta
+ */
+export type Events = {
+    id: string;
+    type: MediaEventType.Mute;
+} | {
+    id: string;
+    type: MediaEventType.Unmute;
+} | {
+    id: string;
+    type: MediaEventType.Ended;
+} | {
+    devices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesChanged;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    unauthorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesFound;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    unauthorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesLost;
+} | {
+    devices: MediaDeviceInfoLike[];
+    authorizedDevices: MediaDeviceInfoLike[];
+    type: MediaEventType.DevicesUnauthorized;
+} | {
+    devices: MediaDeviceInfoLike[];
+    type: MediaEventType.NoInputDevices;
+} | {
+    device: MediaDeviceInfoLike;
+    type: MediaEventType.DeviceLost;
+} | {
+    error: Error;
+    type: MediaEventType.Error;
+} | {
+    facingMode: boolean;
+    stream: MediaStream;
+    type: MediaEventType.Stream;
+    video: boolean;
+};
+export type Dispatch = (event: Events) => void;
+/**
+ * Custom Media Event
+ * @beta
+ */
+export type MediaEvent = CustomEvent<Events>;
+export declare const eventEmitter: () => {
+    dispatch(event: Events): void;
+    subscriber(listener: (event: MediaEvent) => void, onUnsubscribe: () => void): () => void;
+};

package/dist/eventEmitter.js

@@ -0,0 +1,81 @@
+/**
+ * MediaStreamTrack Events
+ *
+ * @remarks
+ * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#Events | Events}
+ *
+ * @beta
+ */
+export var MediaEventType;
+(function (MediaEventType) {
+    /**
+     * Sent to the MediaStreamTrack when the value of the muted property is
+     * changed to true, indicating that the track is unable to provide data
+     * temporarily (such as when the network is experiencing a service
+     * malfunction).
+     */
+    MediaEventType["Mute"] = "mute";
+    /**
+     * Sent to the track when data becomes available again, ending the muted state.
+     */
+    MediaEventType["Unmute"] = "unmute";
+    /**
+     * Sent when playback of the track ends (when the value readyState changes to
+     * ended).
+     */
+    MediaEventType["Ended"] = "ended";
+    /**
+     * Fired when a media input or output device is attached to or removed from
+     * the user's computer.
+     *
+     * @remarks
+     * See MDN {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices#Events | Events}
+     */
+    MediaEventType["DevicesChanged"] = "devices:changed";
+    /**
+     * Found new devices from authorized device list
+     */
+    MediaEventType["DevicesFound"] = "devices:found";
+    /**
+     * Lost devices from authorized device list
+     */
+    MediaEventType["DevicesLost"] = "devices:lost";
+    /**
+     * Lost device from authorized device list
+     */
+    MediaEventType["DeviceLost"] = "device:lost";
+    /**
+     * Unauthorized devices
+     */
+    MediaEventType["DevicesUnauthorized"] = "devices:unauthorized";
+    /**
+     * No Input Devices, and no further device events will be emitted
+     */
+    MediaEventType["NoInputDevices"] = "devices:noinput";
+    /**
+     * Other errors
+     */
+    MediaEventType["Error"] = "error";
+    /**
+     * When stream
+     */
+    MediaEventType["Stream"] = "stream";
+})(MediaEventType || (MediaEventType = {}));
+export const eventEmitter = () => {
+    const element = document.createElement('a');
+    const createEvent = (data) => {
+        return new CustomEvent('data', { detail: data });
+    };
+    return {
+        dispatch(event) {
+            element.dispatchEvent(createEvent(event));
+        },
+        subscriber(listener, onUnsubscribe) {
+            element.addEventListener('data', listener, false);
+            return () => {
+                element.removeEventListener('data', listener, false);
+                onUnsubscribe();
+            };
+        },
+    };
+};

package/dist/getMediaStream.d.ts

@@ -0,0 +1,11 @@
+import type { MediaDeviceRequest } from './types';
+/**
+ * Get MediaStream with provided input constraints
+ *
+ * @returns MediaStream
+ *
+ * @beta
+ */
+export declare const getMediaStream: (request: MediaDeviceRequest & {
+    getDefaultConstraints: () => MediaStreamConstraints;
+}) => Promise<MediaStream>;

package/dist/getMediaStream.js

@@ -0,0 +1,41 @@
+import { MediaDeviceFailure } from './types';
+import { getDevices } from './devices';
+import { getMediaConstraints, relaxInputConstraint } from './constraints';
+import { normalizeGetUserMediaError } from './errors';
+import { logger } from './logger';
+/**
+ * Get MediaStream with provided input constraints
+ *
+ * @returns MediaStream
+ *
+ * @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,
+        defaultConstraints: request.getDefaultConstraints(),
+    });
+    logger.debug({ request, constraints, devices }, '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;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            const devices = await getDevices();
+            throw new Error(normalizeGetUserMediaError(error, constraints, devices));
+        }
+        throw error;
+    }
+};