@privateid/ultrapass-web-sdk 1.3.0 → 1.3.1-1300478

package/dist/application/modules/support/camera/services/BaseCameraService.js

@@ -1,279 +1,279 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/* eslint-disable import/prefer-default-export */
-/* eslint-disable lines-between-class-members */
-import { CameraFaceMode, } from '../camera.types';
-import { printLogs, setDefaultCameraDeviceId } from '../../../global/shared.utils';
-import { isBackCameraLabel, isMobileDevice, startVideo } from '../camera.utils';
-export class BaseCameraService {
-    constructor(permissionsService) {
-        /** Current video element ID being used for camera stream */
-        this.videoElementId = null;
-        /** Selected camera device ID */
-        this.currentDeviceId = null;
-        /** Current camera facing mode (front/back) */
-        this.faceMode = CameraFaceMode.front;
-        /** Active media stream from the camera */
-        this.mediaStream = null;
-        /** List of available media devices (cameras) */
-        this.mediaDevices = null;
-        /** Observer to monitor unauthorized video source changes */
-        this.videoMutationObserver = null;
-        this.permissionsService = permissionsService;
-    }
-    prepareCameraResult(stream, devices, faceMode, videoElementId) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const tracks = stream.getVideoTracks();
-            // Validation: check if there are video tracks
-            if (!tracks || tracks.length === 0) {
-                printLogs('[BaseCameraService] prepareCameraResult: No video tracks in stream', '', 'ERROR');
-                throw new Error('NO_VIDEO_TRACKS');
-            }
-            const track = tracks[0];
-            // Validation: check if track is ready
-            if (track.readyState !== 'live') {
-                printLogs('[BaseCameraService] prepareCameraResult: Track not ready, waiting...', track.readyState, 'WARN');
-                // Wait for track to be ready
-                yield new Promise((resolve) => {
-                    if (track.readyState === 'live') {
-                        resolve();
-                    }
-                    else {
-                        const onReady = () => {
-                            track.removeEventListener('unmute', onReady);
-                            resolve();
-                        };
-                        track.addEventListener('unmute', onReady);
-                        // Safety timeout
-                        setTimeout(() => {
-                            track.removeEventListener('unmute', onReady);
-                            resolve();
-                        }, 2000);
-                    }
-                });
-            }
-            const capabilities = track.getCapabilities ? track.getCapabilities() : null;
-            let settings = track.getSettings ? track.getSettings() : null;
-            // On some Android devices, getSettings() might return null initially
-            // Try to wait and retry getting settings
-            if (!settings) {
-                printLogs('[BaseCameraService] prepareCameraResult: Could not get track settings, retrying...', '', 'WARN');
-                yield new Promise((resolve) => setTimeout(resolve, 500));
-                settings = track.getSettings ? track.getSettings() : null;
-                if (!settings) {
-                    // Last resort: create minimal settings object from track properties
-                    printLogs('[BaseCameraService] prepareCameraResult: Still no settings, creating fallback', '', 'WARN');
-                    settings = {
-                        deviceId: this.currentDeviceId || undefined,
-                        width: ((_b = (_a = track.getConstraints) === null || _a === void 0 ? void 0 : _a.call(track)) === null || _b === void 0 ? void 0 : _b.width) || undefined,
-                        height: ((_d = (_c = track.getConstraints) === null || _c === void 0 ? void 0 : _c.call(track)) === null || _d === void 0 ? void 0 : _d.height) || undefined,
-                        facingMode: faceMode === CameraFaceMode.back ? 'environment' : 'user',
-                    };
-                    printLogs('[BaseCameraService] prepareCameraResult: Using fallback settings', settings, 'WARN');
-                }
-            }
-            printLogs('[BaseCameraService] prepareCameraResult settings: ', settings);
-            if (capabilities) {
-                printLogs('[BaseCameraService] prepareCameraResult capabilities: ', capabilities);
-            }
-            printLogs('[BaseCameraService] prepareCameraResult stream', stream);
-            yield startVideo(videoElementId, stream);
-            this.setMediaStream(stream);
-            this.setMediaDevices(devices);
-            return {
-                // TODO: what does this status represents? Should it be `success`?
-                status: true,
-                stream,
-                devices,
-                faceMode,
-                settings,
-                capabilities,
-                errorMessage: null,
-            };
-        });
-    }
-    // function to wait until the camera is released before opening it again
-    static waitForCameraRelease(targetDeviceId, targetFaceMode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isDesktop = !isMobileDevice();
-            const maxAttempts = isDesktop ? 5 : 10; // desktop can try less times
-            const delayMs = isDesktop ? 100 : 150; // desktop can use shorter delay
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                try {
-                    // build constraints based on target deviceId or faceMode
-                    const testConstraints = {
-                        audio: false,
-                        video: targetDeviceId
-                            ? { deviceId: { exact: targetDeviceId } }
-                            : { facingMode: targetFaceMode === CameraFaceMode.back ? 'environment' : 'user' },
-                    };
-                    printLogs(`[waitForCameraRelease] Attempt ${attempt + 1} - Testing camera availability`, testConstraints);
-                    const testStream = yield navigator.mediaDevices.getUserMedia(testConstraints);
-                    // if succeeded, camera is released
-                    testStream.getTracks().forEach((track) => track.stop());
-                    printLogs(`[waitForCameraRelease] Camera released after ${attempt} attempts`, '');
-                    // Wait a bit more to ensure the track is really closed
-                    yield new Promise((resolve) => setTimeout(resolve, 100));
-                    return;
-                }
-                catch (error) {
-                    // Camera still busy, wait and try again
-                    printLogs(`[waitForCameraRelease] Attempt ${attempt + 1}/${maxAttempts} - Camera still busy: ${error.name}`, '');
-                    yield new Promise((resolve) => setTimeout(resolve, delayMs));
-                }
-            }
-            // If reached here, couldn't verify but let's proceed
-            printLogs('[waitForCameraRelease] Max attempts reached, proceeding anyway', '', 'WARN');
-        });
-    }
-    closeCamera(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // TODO: Control devices, elements and streams only on SDK side to avoid issues with multiple SDK instances
-                const video = element || this.getVideoElementId();
-                const videoEl = document.getElementById(video);
-                const streamFromElement = videoEl === null || videoEl === void 0 ? void 0 : videoEl.srcObject;
-                printLogs('[BaseCameraService] closeCamera streamFromElement:', this.mediaStream);
-                if (streamFromElement) {
-                    const tracks = streamFromElement.getTracks();
-                    tracks.forEach((track) => {
-                        printLogs('[BaseCameraService] closeCamera Stopping track:', track.label);
-                        track.stop();
-                    });
-                    videoEl.srcObject = null;
-                    // Wait for all tracks to finish stopping
-                    yield Promise.all(tracks.map((track) => new Promise((resolve) => {
-                        if (track.readyState === 'ended') {
-                            resolve();
-                        }
-                        else {
-                            // eslint-disable-next-line no-param-reassign
-                            track.onended = () => resolve();
-                            setTimeout(() => resolve(), 1000);
-                        }
-                    })));
-                }
-                this.closeMediaStream();
-                this.setCurrentDeviceId(null);
-                this.setMediaDevices(null);
-                this.closeVideoMutationObserver();
-                // backoff to ensure camera hardware is released
-                yield new Promise((resolve) => setTimeout(resolve, 200));
-                printLogs('[BaseCameraService] closeCamera: hardware released', '');
-            }
-            catch (error) {
-                printLogs(`[BaseCameraService] closeCamera error: `, error, 'ERROR');
-            }
-        });
-    }
-    cameraSwitch(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.getVideoElementId())
-                return null;
-            const mediaDevices = this.getMediaDevices();
-            // Security check: This is to prevent switching when no devices are available normally caused by race conditions where we have on attenpt to switch
-            // on "road" and the user tried to switch camera very fast multiple times what cause the race condition on browsers. To avoid this we just check if we have devices available before switching."
-            if (!mediaDevices || mediaDevices.length === 0) {
-                printLogs('[BaseCameraService] cameraSwitch: No media devices available', '', 'WARN');
-                return null;
-            }
-            const selectedDevice = mediaDevices.find((dev) => dev.deviceId === params.deviceId);
-            // An additional security check to avoid switching to a non existing device
-            if (!selectedDevice) {
-                printLogs('[BaseCameraService] cameraSwitch: Device not found', params.deviceId, 'WARN');
-                return null;
-            }
-            const resolvedFaceMode = isBackCameraLabel(selectedDevice.label)
-                ? CameraFaceMode.back
-                : CameraFaceMode.front;
-            printLogs('[BaseCameraService] cameraSwitch deviceId:', params.deviceId);
-            yield this.closeCamera();
-            yield BaseCameraService.waitForCameraRelease(params.deviceId, resolvedFaceMode);
-            const result = yield this.openCamera({
-                videoElementId: this.getVideoElementId(),
-                deviceId: params.deviceId,
-                requestFaceMode: resolvedFaceMode,
-            });
-            if (!result) {
-                printLogs('[BaseCameraService] cameraSwitch: Failed to open camera', '', 'ERROR');
-                return null;
-            }
-            return {
-                capabilities: result.capabilities,
-                settings: result.settings,
-            };
-        });
-    }
-    isActive() {
-        return this.mediaStream !== null;
-    }
-    // Video Element ID
-    setVideoElementId(videoElementId) {
-        this.videoElementId = videoElementId;
-    }
-    getVideoElementId() {
-        return this.videoElementId;
-    }
-    // Video Element DOM
-    getVideoElementDOM() {
-        if (!this.videoElementId)
-            return null;
-        return document.getElementById(this.videoElementId);
-    }
-    // Face Mode
-    setFaceMode(faceMode) {
-        this.faceMode = faceMode;
-    }
-    getFaceMode() {
-        return this.faceMode;
-    }
-    // Media Stream
-    setMediaStream(mediaStream) {
-        this.mediaStream = mediaStream;
-    }
-    getMediaStream() {
-        return this.mediaStream;
-    }
-    closeMediaStream() {
-        if (this.mediaStream) {
-            this.mediaStream.getTracks().forEach((track) => track.stop());
-        }
-    }
-    // Media Devices
-    setMediaDevices(devices) {
-        this.mediaDevices = devices;
-    }
-    getMediaDevices() {
-        return this.mediaDevices;
-    }
-    // Current Device
-    setCurrentDeviceId(deviceId) {
-        this.currentDeviceId = deviceId;
-        setDefaultCameraDeviceId(deviceId);
-    }
-    getCurrentDeviceId() {
-        return this.currentDeviceId;
-    }
-    // Video Mutation Observer
-    getVideoMutationObserver() {
-        return this.videoMutationObserver;
-    }
-    closeVideoMutationObserver() {
-        if (this.videoMutationObserver) {
-            this.videoMutationObserver.disconnect();
-            this.videoMutationObserver = null;
-        }
-    }
-    checkVideoElementIsReady() {
-        return this.getVideoElementDOM() && this.getVideoElementDOM().readyState === 4;
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable import/prefer-default-export */
+/* eslint-disable lines-between-class-members */
+import { CameraFaceMode, } from '../camera.types';
+import { printLogs, setDefaultCameraDeviceId } from '../../../global/shared.utils';
+import { isBackCameraLabel, isMobileDevice, startVideo } from '../camera.utils';
+export class BaseCameraService {
+    constructor(permissionsService) {
+        /** Current video element ID being used for camera stream */
+        this.videoElementId = null;
+        /** Selected camera device ID */
+        this.currentDeviceId = null;
+        /** Current camera facing mode (front/back) */
+        this.faceMode = CameraFaceMode.front;
+        /** Active media stream from the camera */
+        this.mediaStream = null;
+        /** List of available media devices (cameras) */
+        this.mediaDevices = null;
+        /** Observer to monitor unauthorized video source changes */
+        this.videoMutationObserver = null;
+        this.permissionsService = permissionsService;
+    }
+    prepareCameraResult(stream, devices, faceMode, videoElementId) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const tracks = stream.getVideoTracks();
+            // Validation: check if there are video tracks
+            if (!tracks || tracks.length === 0) {
+                printLogs('[BaseCameraService] prepareCameraResult: No video tracks in stream', '', 'ERROR');
+                throw new Error('NO_VIDEO_TRACKS');
+            }
+            const track = tracks[0];
+            // Validation: check if track is ready
+            if (track.readyState !== 'live') {
+                printLogs('[BaseCameraService] prepareCameraResult: Track not ready, waiting...', track.readyState, 'WARN');
+                // Wait for track to be ready
+                yield new Promise((resolve) => {
+                    if (track.readyState === 'live') {
+                        resolve();
+                    }
+                    else {
+                        const onReady = () => {
+                            track.removeEventListener('unmute', onReady);
+                            resolve();
+                        };
+                        track.addEventListener('unmute', onReady);
+                        // Safety timeout
+                        setTimeout(() => {
+                            track.removeEventListener('unmute', onReady);
+                            resolve();
+                        }, 2000);
+                    }
+                });
+            }
+            const capabilities = track.getCapabilities ? track.getCapabilities() : null;
+            let settings = track.getSettings ? track.getSettings() : null;
+            // On some Android devices, getSettings() might return null initially
+            // Try to wait and retry getting settings
+            if (!settings) {
+                printLogs('[BaseCameraService] prepareCameraResult: Could not get track settings, retrying...', '', 'WARN');
+                yield new Promise((resolve) => setTimeout(resolve, 500));
+                settings = track.getSettings ? track.getSettings() : null;
+                if (!settings) {
+                    // Last resort: create minimal settings object from track properties
+                    printLogs('[BaseCameraService] prepareCameraResult: Still no settings, creating fallback', '', 'WARN');
+                    settings = {
+                        deviceId: this.currentDeviceId || undefined,
+                        width: ((_b = (_a = track.getConstraints) === null || _a === void 0 ? void 0 : _a.call(track)) === null || _b === void 0 ? void 0 : _b.width) || undefined,
+                        height: ((_d = (_c = track.getConstraints) === null || _c === void 0 ? void 0 : _c.call(track)) === null || _d === void 0 ? void 0 : _d.height) || undefined,
+                        facingMode: faceMode === CameraFaceMode.back ? 'environment' : 'user',
+                    };
+                    printLogs('[BaseCameraService] prepareCameraResult: Using fallback settings', settings, 'WARN');
+                }
+            }
+            printLogs('[BaseCameraService] prepareCameraResult settings: ', settings);
+            if (capabilities) {
+                printLogs('[BaseCameraService] prepareCameraResult capabilities: ', capabilities);
+            }
+            printLogs('[BaseCameraService] prepareCameraResult stream', stream);
+            yield startVideo(videoElementId, stream);
+            this.setMediaStream(stream);
+            this.setMediaDevices(devices);
+            return {
+                // TODO: what does this status represents? Should it be `success`?
+                status: true,
+                stream,
+                devices,
+                faceMode,
+                settings,
+                capabilities,
+                errorMessage: null,
+            };
+        });
+    }
+    // function to wait until the camera is released before opening it again
+    static waitForCameraRelease(targetDeviceId, targetFaceMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isDesktop = !isMobileDevice();
+            const maxAttempts = isDesktop ? 5 : 10; // desktop can try less times
+            const delayMs = isDesktop ? 100 : 150; // desktop can use shorter delay
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                try {
+                    // build constraints based on target deviceId or faceMode
+                    const testConstraints = {
+                        audio: false,
+                        video: targetDeviceId
+                            ? { deviceId: { exact: targetDeviceId } }
+                            : { facingMode: targetFaceMode === CameraFaceMode.back ? 'environment' : 'user' },
+                    };
+                    printLogs(`[waitForCameraRelease] Attempt ${attempt + 1} - Testing camera availability`, testConstraints);
+                    const testStream = yield navigator.mediaDevices.getUserMedia(testConstraints);
+                    // if succeeded, camera is released
+                    testStream.getTracks().forEach((track) => track.stop());
+                    printLogs(`[waitForCameraRelease] Camera released after ${attempt} attempts`, '');
+                    // Wait a bit more to ensure the track is really closed
+                    yield new Promise((resolve) => setTimeout(resolve, 100));
+                    return;
+                }
+                catch (error) {
+                    // Camera still busy, wait and try again
+                    printLogs(`[waitForCameraRelease] Attempt ${attempt + 1}/${maxAttempts} - Camera still busy: ${error.name}`, '');
+                    yield new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+            // If reached here, couldn't verify but let's proceed
+            printLogs('[waitForCameraRelease] Max attempts reached, proceeding anyway', '', 'WARN');
+        });
+    }
+    closeCamera(element) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // TODO: Control devices, elements and streams only on SDK side to avoid issues with multiple SDK instances
+                const video = element || this.getVideoElementId();
+                const videoEl = document.getElementById(video);
+                const streamFromElement = videoEl === null || videoEl === void 0 ? void 0 : videoEl.srcObject;
+                printLogs('[BaseCameraService] closeCamera streamFromElement:', this.mediaStream);
+                if (streamFromElement) {
+                    const tracks = streamFromElement.getTracks();
+                    tracks.forEach((track) => {
+                        printLogs('[BaseCameraService] closeCamera Stopping track:', track.label);
+                        track.stop();
+                    });
+                    videoEl.srcObject = null;
+                    // Wait for all tracks to finish stopping
+                    yield Promise.all(tracks.map((track) => new Promise((resolve) => {
+                        if (track.readyState === 'ended') {
+                            resolve();
+                        }
+                        else {
+                            // eslint-disable-next-line no-param-reassign
+                            track.onended = () => resolve();
+                            setTimeout(() => resolve(), 1000);
+                        }
+                    })));
+                }
+                this.closeMediaStream();
+                this.setCurrentDeviceId(null);
+                this.setMediaDevices(null);
+                this.closeVideoMutationObserver();
+                // backoff to ensure camera hardware is released
+                yield new Promise((resolve) => setTimeout(resolve, 200));
+                printLogs('[BaseCameraService] closeCamera: hardware released', '');
+            }
+            catch (error) {
+                printLogs(`[BaseCameraService] closeCamera error: `, error, 'ERROR');
+            }
+        });
+    }
+    cameraSwitch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getVideoElementId())
+                return null;
+            const mediaDevices = this.getMediaDevices();
+            // Security check: This is to prevent switching when no devices are available normally caused by race conditions where we have on attenpt to switch
+            // on "road" and the user tried to switch camera very fast multiple times what cause the race condition on browsers. To avoid this we just check if we have devices available before switching."
+            if (!mediaDevices || mediaDevices.length === 0) {
+                printLogs('[BaseCameraService] cameraSwitch: No media devices available', '', 'WARN');
+                return null;
+            }
+            const selectedDevice = mediaDevices.find((dev) => dev.deviceId === params.deviceId);
+            // An additional security check to avoid switching to a non existing device
+            if (!selectedDevice) {
+                printLogs('[BaseCameraService] cameraSwitch: Device not found', params.deviceId, 'WARN');
+                return null;
+            }
+            const resolvedFaceMode = isBackCameraLabel(selectedDevice.label)
+                ? CameraFaceMode.back
+                : CameraFaceMode.front;
+            printLogs('[BaseCameraService] cameraSwitch deviceId:', params.deviceId);
+            yield this.closeCamera();
+            yield BaseCameraService.waitForCameraRelease(params.deviceId, resolvedFaceMode);
+            const result = yield this.openCamera({
+                videoElementId: this.getVideoElementId(),
+                deviceId: params.deviceId,
+                requestFaceMode: resolvedFaceMode,
+            });
+            if (!result) {
+                printLogs('[BaseCameraService] cameraSwitch: Failed to open camera', '', 'ERROR');
+                return null;
+            }
+            return {
+                capabilities: result.capabilities,
+                settings: result.settings,
+            };
+        });
+    }
+    isActive() {
+        return this.mediaStream !== null;
+    }
+    // Video Element ID
+    setVideoElementId(videoElementId) {
+        this.videoElementId = videoElementId;
+    }
+    getVideoElementId() {
+        return this.videoElementId;
+    }
+    // Video Element DOM
+    getVideoElementDOM() {
+        if (!this.videoElementId)
+            return null;
+        return document.getElementById(this.videoElementId);
+    }
+    // Face Mode
+    setFaceMode(faceMode) {
+        this.faceMode = faceMode;
+    }
+    getFaceMode() {
+        return this.faceMode;
+    }
+    // Media Stream
+    setMediaStream(mediaStream) {
+        this.mediaStream = mediaStream;
+    }
+    getMediaStream() {
+        return this.mediaStream;
+    }
+    closeMediaStream() {
+        if (this.mediaStream) {
+            this.mediaStream.getTracks().forEach((track) => track.stop());
+        }
+    }
+    // Media Devices
+    setMediaDevices(devices) {
+        this.mediaDevices = devices;
+    }
+    getMediaDevices() {
+        return this.mediaDevices;
+    }
+    // Current Device
+    setCurrentDeviceId(deviceId) {
+        this.currentDeviceId = deviceId;
+        setDefaultCameraDeviceId(deviceId);
+    }
+    getCurrentDeviceId() {
+        return this.currentDeviceId;
+    }
+    // Video Mutation Observer
+    getVideoMutationObserver() {
+        return this.videoMutationObserver;
+    }
+    closeVideoMutationObserver() {
+        if (this.videoMutationObserver) {
+            this.videoMutationObserver.disconnect();
+            this.videoMutationObserver = null;
+        }
+    }
+    checkVideoElementIsReady() {
+        return this.getVideoElementDOM() && this.getVideoElementDOM().readyState === 4;
+    }
+}
 //# sourceMappingURL=BaseCameraService.js.map

package/dist/application/modules/support/camera/services/DesktopCameraService.d.ts

@@ -1,5 +1,5 @@
-import { BaseCameraService } from './BaseCameraService';
-import { CameraOpenResult, OpenCameraProps } from '../camera.types';
-export declare class DesktopCameraService extends BaseCameraService {
-    openCamera(props: OpenCameraProps): Promise<CameraOpenResult>;
-}
+import { BaseCameraService } from './BaseCameraService';
+import { CameraOpenResult, OpenCameraProps } from '../camera.types';
+export declare class DesktopCameraService extends BaseCameraService {
+    openCamera(props: OpenCameraProps): Promise<CameraOpenResult>;
+}