@jaak.ai/stamps 2.0.0-dev.58 → 2.0.1

package/dist/collection/services/CameraService.js

@@ -1,18 +1,14 @@
 export class CameraService {
+    logger;
     eventBus;
     availableCameras = [];
     selectedCameraId = null;
     deviceType = 'desktop';
     preferredCameraFacing = null;
     preferredCamera = 'auto';
-    // Optimization: Static caches for performance
-    static cameraCapabilitiesCache = new Map();
-    static deviceEnumerationCache = null;
-    static CACHE_DURATION = 30000; // 30 seconds
-    // Stream management for optimization
-    currentStreamPromise;
-    lastStreamConstraints;
-    constructor(eventBus, preferredCamera = 'auto') {
+    isManuallySelected = false;
+    constructor(logger, eventBus, preferredCamera = 'auto') {
+        this.logger = logger;
         this.eventBus = eventBus;
         this.preferredCamera = preferredCamera;
     }
@@ -29,21 +25,18 @@ export class CameraService {
         else {
             this.deviceType = 'desktop';
         }
+        this.logger.state('DISPOSITIVO_DETECTADO', {
+            deviceType: this.deviceType,
+            userAgent: navigator.userAgent,
+            screenDimensions: { width: window.innerWidth, height: window.innerHeight }
+        });
         return this.deviceType;
     }
     async enumerateDevices() {
         try {
-            // Check cache first for optimization
-            const now = Date.now();
-            if (CameraService.deviceEnumerationCache &&
-                (now - CameraService.deviceEnumerationCache.timestamp) < CameraService.CACHE_DURATION) {
-                this.availableCameras = CameraService.deviceEnumerationCache.devices;
-                await this.setInitialCameraPreference();
-                this.eventBus.emit('camera-changed', this.selectedCameraId);
-                return this.availableCameras;
-            }
             const permissionStatus = await this.checkCameraPermission();
             if (permissionStatus === 'denied') {
+                this.logger.error('Permiso de cámara denegado por el usuario');
                 return [];
             }
             if (permissionStatus === 'prompt') {
@@ -52,16 +45,24 @@ export class CameraService {
             }
             const devices = await navigator.mediaDevices.enumerateDevices();
             this.availableCameras = devices.filter(device => device.kind === 'videoinput');
-            // Cache the results for optimization
-            CameraService.deviceEnumerationCache = {
-                devices: this.availableCameras,
-                timestamp: now
-            };
-            await this.setInitialCameraPreference();
+            this.logger.state('CAMARAS_DETECTADAS', {
+                count: this.availableCameras.length,
+                cameras: this.availableCameras.map(cam => ({
+                    id: cam.deviceId,
+                    label: cam.label || 'Unknown Camera'
+                }))
+            });
+            this.setInitialCameraPreference();
+            this.logger.state('PREFERENCIA_INICIAL_APLICADA', {
+                selectedCameraId: this.selectedCameraId,
+                preferredCameraFacing: this.preferredCameraFacing,
+                preferredCamera: this.preferredCamera
+            });
             this.eventBus.emit('camera-changed', this.selectedCameraId);
             return this.availableCameras;
         }
         catch (error) {
+            this.logger.error('Error al enumerar cámaras disponibles:', error);
             this.handleCameraPermissionError(error);
             return [];
         }
@@ -82,6 +83,8 @@ export class CameraService {
         }
         this.selectedCameraId = cameraId;
         this.updatePreferredFacing(camera);
+        this.isManuallySelected = true; // Mark as manually selected
+        this.savePreference();
         this.eventBus.emit('camera-changed', cameraId);
     }
     getPreferredFacing() {
@@ -90,20 +93,14 @@ export class CameraService {
     async setupCamera(constraints) {
         try {
             const finalConstraints = constraints || await this.getMaxResolution();
-            // Optimization: Check if we can reuse existing stream with same constraints
-            if (this.currentStreamPromise && this.constraintsEqual(finalConstraints, this.lastStreamConstraints)) {
-                return await this.currentStreamPromise;
-            }
-            // Create new stream promise for lazy loading
-            this.currentStreamPromise = navigator.mediaDevices.getUserMedia({
+            const stream = await navigator.mediaDevices.getUserMedia({
                 video: finalConstraints,
                 audio: false
             });
-            this.lastStreamConstraints = finalConstraints;
-            const stream = await this.currentStreamPromise;
             return stream;
         }
         catch (error) {
+            this.logger.error('Error en setupCamera, intentando con restricciones básicas:', error);
             // Fallback to basic constraints if getMaxResolution fails
             const basicConstraints = {
                 width: { ideal: 1280 },
@@ -113,21 +110,65 @@ export class CameraService {
             if (this.deviceType !== 'desktop' && this.preferredCameraFacing) {
                 basicConstraints.facingMode = this.preferredCameraFacing;
             }
-            this.currentStreamPromise = navigator.mediaDevices.getUserMedia({
+            this.logger.state('USANDO_RESTRICCIONES_BASICAS', { constraints: basicConstraints });
+            return await navigator.mediaDevices.getUserMedia({
                 video: basicConstraints,
                 audio: false
             });
-            this.lastStreamConstraints = basicConstraints;
-            return await this.currentStreamPromise;
         }
     }
     async switchCamera(cameraId) {
         const selectedCamera = this.availableCameras.find(cam => cam.deviceId === cameraId);
         if (!selectedCamera) {
+            this.logger.warn('Cámara seleccionada no encontrada, re-enumerando dispositivos...');
             await this.enumerateDevices();
             return;
         }
         await this.setSelectedCamera(cameraId);
+        this.logger.state('CAMARA_CAMBIADA', {
+            label: selectedCamera.label,
+            deviceId: selectedCamera.deviceId,
+            isManuallySelected: this.isManuallySelected
+        });
+    }
+    async flipToNextCamera() {
+        if (!this.isMultipleCamerasAvailable())
+            return;
+        const currentIndex = this.availableCameras.findIndex(camera => camera.deviceId === this.selectedCameraId);
+        const nextIndex = (currentIndex + 1) % this.availableCameras.length;
+        const nextCamera = this.availableCameras[nextIndex];
+        await this.switchCamera(nextCamera.deviceId);
+    }
+    savePreference() {
+        try {
+            const preference = {
+                cameraId: this.selectedCameraId,
+                facing: this.preferredCameraFacing,
+                timestamp: Date.now()
+            };
+            localStorage.setItem('jaak-stamps-camera-preference', JSON.stringify(preference));
+            this.logger.state('PREFERENCIA_CAMARA_GUARDADA', preference);
+        }
+        catch (error) {
+            this.logger.warn('Error al guardar preferencia de cámara:', error);
+        }
+    }
+    loadPreference() {
+        try {
+            const saved = localStorage.getItem('jaak-stamps-camera-preference');
+            if (saved) {
+                const preference = JSON.parse(saved);
+                const isStillAvailable = this.availableCameras.some(camera => camera.deviceId === preference.cameraId);
+                if (isStillAvailable) {
+                    this.selectedCameraId = preference.cameraId;
+                    this.preferredCameraFacing = preference.facing;
+                    this.logger.state('PREFERENCIA_CAMARA_CARGADA', preference);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn('Error al cargar preferencia de cámara:', error);
+        }
     }
     isRearCamera(stream) {
         const videoTrack = stream.getVideoTracks()[0];
@@ -136,18 +177,13 @@ export class CameraService {
         const settings = videoTrack.getSettings();
         return settings.facingMode === 'environment';
     }
-    async getCameraInfo() {
-        const availableCamerasWithAutofocus = await Promise.all(this.availableCameras.map(async (camera) => {
-            const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
-            return {
+    getCameraInfo() {
+        return {
+            availableCameras: this.availableCameras.map(camera => ({
                 id: camera.deviceId,
                 label: camera.label || 'Unknown Camera',
-                selected: camera.deviceId === this.selectedCameraId,
-                hasAutofocus
-            };
-        }));
-        return {
-            availableCameras: availableCamerasWithAutofocus,
+                selected: camera.deviceId === this.selectedCameraId
+            })),
             selectedCameraId: this.selectedCameraId,
             deviceType: this.deviceType,
             isMultipleCamerasAvailable: this.isMultipleCamerasAvailable(),
@@ -163,6 +199,7 @@ export class CameraService {
             return permission.state;
         }
         catch (error) {
+            this.logger.warn('No se pudo verificar permisos de cámara:', error);
             return 'prompt';
         }
     }
@@ -170,48 +207,35 @@ export class CameraService {
         this.availableCameras = [];
         this.eventBus.emit('error', new Error(`Camera permission error: ${error.message}`));
     }
-    async setInitialCameraPreference() {
+    setInitialCameraPreference() {
         if (this.availableCameras.length === 0)
             return;
+        // Clear any existing localStorage preferences to ensure fresh start
+        localStorage.removeItem('jaak-stamps-camera-preference');
+        this.logger.state('APLICANDO_PREFERENCIA_INICIAL', {
+            preferredCamera: this.preferredCamera,
+            availableCamerasCount: this.availableCameras.length
+        });
+        this.isManuallySelected = false; // Reset manual selection flag
         if (this.preferredCamera === 'front') {
-            await this.selectFrontCamera();
+            this.selectFrontCamera();
         }
         else if (this.preferredCamera === 'back') {
-            await this.selectBackCamera();
+            this.selectBackCamera();
         }
         else {
-            await this.selectAutoCamera();
-        }
-    }
-    async checkCameraAutofocus(deviceId) {
-        try {
-            // Check cache first for optimization
-            if (CameraService.cameraCapabilitiesCache.has(deviceId)) {
-                const cached = CameraService.cameraCapabilitiesCache.get(deviceId);
-                return typeof cached === 'boolean' ? cached : false;
-            }
-            const stream = await navigator.mediaDevices.getUserMedia({
-                video: { deviceId: { exact: deviceId } }
-            });
-            const videoTrack = stream.getVideoTracks()[0];
-            const capabilities = videoTrack.getCapabilities();
-            stream.getTracks().forEach(track => track.stop());
-            const hasFocusMode = capabilities.focusMode && Array.isArray(capabilities.focusMode) && capabilities.focusMode.length > 0;
-            const hasAutofocus = hasFocusMode && (capabilities.focusMode.includes('continuous') ||
-                capabilities.focusMode.includes('auto'));
-            // Cache the result for future use
-            CameraService.cameraCapabilitiesCache.set(deviceId, hasAutofocus);
-            return hasAutofocus;
-        }
-        catch (error) {
-            // Cache negative result to avoid repeated failures
-            CameraService.cameraCapabilitiesCache.set(deviceId, false);
-            return false;
+            this.selectAutoCamera();
         }
     }
-    async selectFrontCamera() {
+    selectFrontCamera() {
         this.preferredCameraFacing = 'user';
-        const frontCameras = this.availableCameras.filter(camera => {
+        this.logger.state('BUSCANDO_CAMARA_FRONTAL', {
+            availableCameras: this.availableCameras.map(cam => ({
+                id: cam.deviceId,
+                label: cam.label
+            }))
+        });
+        const frontCamera = this.availableCameras.find(camera => {
             const label = camera.label.toLowerCase();
             return label.includes('front') ||
                 label.includes('user') ||
@@ -219,24 +243,24 @@ export class CameraService {
                 label.includes('frontal') ||
                 (!label.includes('back') && !label.includes('rear') && !label.includes('environment'));
         });
-        let selectedCamera = null;
-        if (frontCameras.length > 0) {
-            for (const camera of frontCameras) {
-                const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
-                if (hasAutofocus) {
-                    selectedCamera = camera;
-                    break;
-                }
-            }
-            if (!selectedCamera) {
-                selectedCamera = frontCameras[0];
-            }
-        }
-        this.selectedCameraId = selectedCamera ? selectedCamera.deviceId : this.availableCameras[0].deviceId;
+        // If not found, use the first camera (usually front on mobile)
+        this.selectedCameraId = frontCamera ? frontCamera.deviceId : this.availableCameras[0].deviceId;
+        this.logger.state('CAMARA_FRONTAL_SELECCIONADA', {
+            found: !!frontCamera,
+            label: frontCamera?.label || this.availableCameras[0].label,
+            deviceId: this.selectedCameraId
+        });
     }
-    async selectBackCamera() {
+    selectBackCamera() {
         this.preferredCameraFacing = 'environment';
-        const backCameras = this.availableCameras.filter(camera => {
+        this.logger.state('BUSCANDO_CAMARA_TRASERA', {
+            availableCameras: this.availableCameras.map(cam => ({
+                id: cam.deviceId,
+                label: cam.label
+            }))
+        });
+        // Try to find rear camera with multiple detection methods
+        let backCamera = this.availableCameras.find(camera => {
             const label = camera.label.toLowerCase();
             return label.includes('back') ||
                 label.includes('rear') ||
@@ -244,33 +268,34 @@ export class CameraService {
                 label.includes('trasera') ||
                 label.includes('posterior');
         });
-        let selectedCamera = null;
-        if (backCameras.length > 0) {
-            for (const camera of backCameras) {
-                const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
-                if (hasAutofocus) {
-                    selectedCamera = camera;
-                    break;
-                }
-            }
-            if (!selectedCamera) {
-                selectedCamera = backCameras[0];
-            }
-        }
-        else if (this.availableCameras.length > 1) {
-            const lastCamera = this.availableCameras[this.availableCameras.length - 1];
-            const hasAutofocus = await this.checkCameraAutofocus(lastCamera.deviceId);
-            selectedCamera = hasAutofocus ? lastCamera : this.availableCameras[this.availableCameras.length - 1];
+        // If not found by label, try to use the last camera (usually rear on mobile)
+        if (!backCamera && this.availableCameras.length > 1) {
+            backCamera = this.availableCameras[this.availableCameras.length - 1];
+            this.logger.state('USANDO_ULTIMA_CAMARA_COMO_TRASERA', {
+                label: backCamera.label,
+                deviceId: backCamera.deviceId
+            });
         }
-        this.selectedCameraId = selectedCamera ? selectedCamera.deviceId : this.availableCameras[0].deviceId;
+        this.selectedCameraId = backCamera ? backCamera.deviceId : this.availableCameras[0].deviceId;
+        this.logger.state('CAMARA_TRASERA_SELECCIONADA', {
+            found: !!backCamera,
+            label: backCamera?.label || this.availableCameras[0].label,
+            deviceId: this.selectedCameraId
+        });
     }
-    async selectAutoCamera() {
+    selectAutoCamera() {
         if (this.deviceType === 'mobile' || this.deviceType === 'tablet') {
-            await this.selectBackCamera();
+            this.selectBackCamera();
+            this.logger.state('CAMARA_AUTO_SELECCIONADA_MOBILE', { type: 'rear' });
         }
         else {
             // For desktop, prefer front camera (usually built-in webcam)
-            await this.selectFrontCamera();
+            this.selectFrontCamera();
+            this.logger.state('CAMARA_AUTO_SELECCIONADA_DESKTOP', {
+                type: 'front',
+                label: this.availableCameras[0].label,
+                deviceId: this.selectedCameraId
+            });
         }
     }
     updatePreferredFacing(camera) {
@@ -286,19 +311,40 @@ export class CameraService {
                 await this.detectDeviceType();
             }
             const videoConstraints = {};
-            // Priority 1: Always use deviceId if available (ensures specific camera with autofocus)
-            if (this.selectedCameraId) {
+            this.logger.state('CONFIGURANDO_CONSTRAINS_CAMARA', {
+                selectedCameraId: this.selectedCameraId,
+                preferredCameraFacing: this.preferredCameraFacing,
+                preferredCamera: this.preferredCamera,
+                deviceType: this.deviceType,
+                isManuallySelected: this.isManuallySelected
+            });
+            if (this.isManuallySelected && this.selectedCameraId) {
+                // When manually selected, use deviceId for exact camera selection
                 videoConstraints.deviceId = { exact: this.selectedCameraId };
+                this.logger.state('USANDO_CAMARA_MANUAL', {
+                    deviceId: this.selectedCameraId
+                });
             }
-            // Priority 2: Use facingMode as fallback when no specific camera is selected
             else if (this.preferredCameraFacing) {
+                // Use facingMode for initial preference-based selection
+                // Use 'ideal' instead of 'exact' to avoid OverconstrainedError on desktop
                 const facingConstraint = this.deviceType === 'desktop'
                     ? { ideal: this.preferredCameraFacing }
                     : { exact: this.preferredCameraFacing };
                 videoConstraints.facingMode = facingConstraint;
+                this.logger.state('USANDO_FACING_CONSTRAINT', {
+                    facingMode: this.preferredCameraFacing,
+                    constraintType: this.deviceType === 'desktop' ? 'ideal' : 'exact'
+                });
+            }
+            else if (this.selectedCameraId) {
+                videoConstraints.deviceId = { exact: this.selectedCameraId };
+                this.logger.state('USANDO_CAMARA_SELECCIONADA', {
+                    deviceId: this.selectedCameraId
+                });
             }
-            // Priority 3: Fallback to preferredCamera setting
             else {
+                // Use preferredCamera setting to determine default facing mode
                 if (this.preferredCamera === 'front') {
                     videoConstraints.facingMode = "user";
                 }
@@ -306,25 +352,24 @@ export class CameraService {
                     videoConstraints.facingMode = "environment";
                 }
                 else {
+                    // Auto mode: use environment for mobile/tablet, user for desktop
                     videoConstraints.facingMode = (this.deviceType === 'mobile' || this.deviceType === 'tablet') ? "environment" : "user";
                 }
+                this.logger.state('USANDO_PREFERENCIA_CONFIGURADA', {
+                    facingMode: videoConstraints.facingMode,
+                    preferredCamera: this.preferredCamera,
+                    deviceType: this.deviceType
+                });
             }
-            // Optimization: Use cached capabilities if available
-            let capabilities;
-            if (this.selectedCameraId && CameraService.cameraCapabilitiesCache.has(this.selectedCameraId + '_caps')) {
-                capabilities = JSON.parse(CameraService.cameraCapabilitiesCache.get(this.selectedCameraId + '_caps'));
-            }
-            else {
-                const tempStream = await navigator.mediaDevices.getUserMedia({ video: videoConstraints });
-                const videoTrack = tempStream.getVideoTracks()[0];
-                capabilities = videoTrack.getCapabilities();
-                tempStream.getTracks().forEach(track => track.stop());
-                // Cache capabilities for future use
-                if (this.selectedCameraId) {
-                    CameraService.cameraCapabilitiesCache.set(this.selectedCameraId + '_caps', JSON.stringify(capabilities));
-                }
-            }
+            const tempStream = await navigator.mediaDevices.getUserMedia({
+                video: videoConstraints
+            });
+            const videoTrack = tempStream.getVideoTracks()[0];
+            const capabilities = videoTrack.getCapabilities();
+            tempStream.getTracks().forEach(track => track.stop());
             const constraints = { ...videoConstraints };
+            // Enhanced focus and image quality settings
+            this.applyAdvancedCameraSettings(constraints, capabilities);
             if (capabilities.width && capabilities.height) {
                 const maxWidth = Math.min(capabilities.width.max, 1920);
                 const maxHeight = Math.min(capabilities.height.max, 1080);
@@ -338,20 +383,15 @@ export class CameraService {
                     constraints.height = { ideal: maxHeight };
                 }
             }
-            // Configure autofocus if camera has the capability
-            const capabilitiesAny = capabilities;
-            if (capabilitiesAny.focusMode && Array.isArray(capabilitiesAny.focusMode)) {
-                if (capabilitiesAny.focusMode.includes('continuous')) {
-                    constraints.focusMode = 'continuous';
-                }
-                else if (capabilitiesAny.focusMode.includes('auto')) {
-                    constraints.focusMode = 'auto';
-                }
-            }
+            this.logger.state('CONFIGURACION_CAMARA_OPTIMIZADA', {
+                constraints,
+                capabilities: this.getCapabilitiesSummary(capabilities)
+            });
             return constraints;
         }
         catch (err) {
-            // Fallback logic with minimal temporary streams
+            this.logger.warn('No se pudieron obtener capacidades de cámara, usando configuración de respaldo');
+            // Ensure device type is detected before determining constraints
             if (!this.deviceType || this.deviceType === 'desktop') {
                 await this.detectDeviceType();
             }
@@ -360,16 +400,25 @@ export class CameraService {
                 width: { ideal: isTablet ? 1280 : 1920 },
                 height: { ideal: isTablet ? 720 : 1080 }
             };
-            if (this.selectedCameraId) {
+            // Apply basic focus settings even for fallback
+            this.applyBasicFocusSettings(fallbackConstraints);
+            if (this.isManuallySelected && this.selectedCameraId) {
+                // When manually selected, use deviceId for exact camera selection
                 fallbackConstraints.deviceId = { exact: this.selectedCameraId };
             }
             else if (this.preferredCameraFacing) {
+                // Use facingMode for initial preference-based selection
+                // Use 'ideal' instead of 'exact' to avoid OverconstrainedError on desktop
                 const facingConstraint = this.deviceType === 'desktop'
                     ? { ideal: this.preferredCameraFacing }
                     : { exact: this.preferredCameraFacing };
                 fallbackConstraints.facingMode = facingConstraint;
             }
+            else if (this.selectedCameraId) {
+                fallbackConstraints.deviceId = { exact: this.selectedCameraId };
+            }
             else {
+                // Use preferredCamera setting to determine default facing mode
                 if (this.preferredCamera === 'front') {
                     fallbackConstraints.facingMode = "user";
                 }
@@ -377,26 +426,165 @@ export class CameraService {
                     fallbackConstraints.facingMode = "environment";
                 }
                 else {
+                    // Auto mode: use environment for mobile/tablet, user for desktop
                     fallbackConstraints.facingMode = (this.deviceType === 'mobile' || this.deviceType === 'tablet') ? "environment" : "user";
                 }
             }
             return fallbackConstraints;
         }
     }
-    // Optimization helper methods
-    constraintsEqual(a, b) {
-        if (!a || !b)
-            return false;
-        return JSON.stringify(a) === JSON.stringify(b);
+    applyAdvancedCameraSettings(constraints, capabilities) {
+        // Apply standard camera settings that are widely supported
+        // Frame rate optimization
+        if (capabilities.frameRate) {
+            constraints.frameRate = {
+                ideal: 30,
+                min: 15,
+                max: 60
+            };
+        }
+        // Width and height constraints for optimal resolution
+        if (capabilities.width && capabilities.height) {
+            constraints.width = {
+                ideal: Math.min(1920, capabilities.width.max || 1920),
+                min: 640
+            };
+            constraints.height = {
+                ideal: Math.min(1080, capabilities.height.max || 1080),
+                min: 480
+            };
+        }
+        // Apply enhanced constraints through advanced array for better browser compatibility
+        const advancedConstraints = [];
+        // Try to set optimal settings through advanced constraints
+        const advanced = {};
+        // Focus mode - use 'any' type to bypass TypeScript limitations
+        if (capabilities.focusMode) {
+            if (capabilities.focusMode.includes('continuous')) {
+                advanced.focusMode = 'continuous';
+            }
+            else if (capabilities.focusMode.includes('single-shot')) {
+                advanced.focusMode = 'single-shot';
+            }
+        }
+        // Focus distance for close objects
+        if (capabilities.focusDistance) {
+            advanced.focusDistance = {
+                ideal: 0.4, // 40cm - optimal for document capture
+                min: 0.2,
+                max: 1.0
+            };
+        }
+        // Zoom control
+        if (capabilities.zoom) {
+            advanced.zoom = {
+                ideal: 1.0,
+                min: capabilities.zoom.min,
+                max: Math.min(capabilities.zoom.max, 3.0)
+            };
+        }
+        // Add advanced constraints if any were set
+        if (Object.keys(advanced).length > 0) {
+            advancedConstraints.push(advanced);
+        }
+        if (advancedConstraints.length > 0) {
+            constraints.advanced = advancedConstraints;
+        }
     }
-    // Cleanup method for optimization
-    static clearCaches() {
-        CameraService.cameraCapabilitiesCache.clear();
-        CameraService.deviceEnumerationCache = null;
+    applyBasicFocusSettings(constraints) {
+        // Apply basic focus settings when capabilities are not available
+        // Use advanced constraints for non-standard properties
+        const advanced = {
+            focusMode: 'continuous',
+            exposureMode: 'continuous',
+            whiteBalanceMode: 'continuous'
+        };
+        if (!constraints.advanced) {
+            constraints.advanced = [];
+        }
+        constraints.advanced.push(advanced);
+        constraints.frameRate = { ideal: 30 };
     }
-    // Method to invalidate device cache when needed
-    invalidateDeviceCache() {
-        CameraService.deviceEnumerationCache = null;
+    getCapabilitiesSummary(capabilities) {
+        return {
+            hasAutoFocus: !!capabilities.focusMode,
+            hasFocusDistance: !!capabilities.focusDistance,
+            hasExposureControl: !!capabilities.exposureMode,
+            hasWhiteBalance: !!capabilities.whiteBalanceMode,
+            hasZoom: !!capabilities.zoom,
+            hasTorch: capabilities.torch !== undefined,
+            hasImageControls: !!(capabilities.brightness || capabilities.contrast || capabilities.saturation || capabilities.sharpness),
+            resolutionRange: capabilities.width && capabilities.height ?
+                `${capabilities.width.min}x${capabilities.height.min} - ${capabilities.width.max}x${capabilities.height.max}` : 'unknown'
+        };
+    }
+    // New method to enable torch/flash for better illumination
+    async setTorchEnabled(enabled, stream) {
+        try {
+            if (!stream) {
+                this.logger.warn('No hay stream disponible para controlar el flash');
+                return false;
+            }
+            const videoTrack = stream.getVideoTracks()[0];
+            if (!videoTrack) {
+                this.logger.warn('No hay track de video disponible');
+                return false;
+            }
+            const capabilities = videoTrack.getCapabilities();
+            if (capabilities.torch === undefined) {
+                this.logger.warn('El dispositivo no soporta control de flash');
+                return false;
+            }
+            await videoTrack.applyConstraints({
+                advanced: [{ torch: enabled }]
+            });
+            this.logger.state('FLASH_CONTROLADO', { enabled });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error al controlar el flash:', error);
+            return false;
+        }
+    }
+    // Method to manually trigger focus on a specific point
+    async focusAtPoint(x, y, stream) {
+        try {
+            if (!stream) {
+                this.logger.warn('No hay stream disponible para enfocar');
+                return false;
+            }
+            const videoTrack = stream.getVideoTracks()[0];
+            if (!videoTrack) {
+                this.logger.warn('No hay track de video disponible');
+                return false;
+            }
+            const capabilities = videoTrack.getCapabilities();
+            if (!capabilities.focusMode || !capabilities.focusMode.includes('single-shot')) {
+                this.logger.warn('El dispositivo no soporta enfoque manual');
+                return false;
+            }
+            // Trigger single-shot focus
+            await videoTrack.applyConstraints({
+                advanced: [{ focusMode: 'single-shot' }]
+            });
+            // Return to continuous focus after a short delay
+            setTimeout(async () => {
+                try {
+                    await videoTrack.applyConstraints({
+                        advanced: [{ focusMode: 'continuous' }]
+                    });
+                }
+                catch (error) {
+                    this.logger.warn('Error al volver a enfoque continuo:', error);
+                }
+            }, 1000);
+            this.logger.state('ENFOQUE_MANUAL_ACTIVADO', { x, y });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error al enfocar manualmente:', error);
+            return false;
+        }
     }
 }
 //# sourceMappingURL=CameraService.js.map