@simprints/simface-sdk 0.6.1 → 0.8.1

package/dist/services/camera.js

@@ -1,95 +1,130 @@
 /**
  * Camera capture service.
  *
- * Uses realtime face guidance with automatic capture when supported and falls
- * back to a simpler manual capture flow when the browser cannot support it.
+ * Plans capture explicitly as an ordered fallback chain:
+ * auto camera -> manual camera -> media picker.
  */
-import { assessFaceQuality, assessFaceQualityForVideo, getVideoDetector } from './face-detection.js';
-import { AUTO_CAPTURE_ANALYSIS_INTERVAL_MS, AUTO_CAPTURE_COUNTDOWN_MS, CAPTURE_GUIDE_MASK_PATH, CAPTURE_GUIDE_PATH, autoCaptureCompleteMessage, autoCaptureCountdownMessage, } from '../shared/auto-capture.js';
+import { normalizeCaptureOptions, } from '../shared/capture-flow.js';
+import { blobToDataURL, blobToImage, captureFromFileInput, } from '../shared/capture-runtime.js';
 const CAPTURE_DIALOG_Z_INDEX = '2147483647';
 /**
- * Opens the device camera and returns a confirmed image Blob, or null if cancelled.
+ * Opens the configured capture presentation and returns a confirmed image Blob,
+ * or null if the user cancels.
  */
-export async function captureFromCamera() {
-    if (prefersNativeCameraCapture()) {
-        return captureFromFileInput();
-    }
-    if (!navigator.mediaDevices?.getUserMedia) {
-        throw new Error('In-browser camera capture is not supported in this browser.');
-    }
-    const mode = (await supportsRealtimeAutoCapture()) ? 'auto' : 'manual';
-    return captureFromMediaDevices(mode);
+export async function captureFromCamera(options) {
+    const captureOptions = normalizeCaptureOptions(options);
+    if (captureOptions.presentation === 'embedded') {
+        return captureFromEmbeddedComponent(captureOptions);
+    }
+    // For popup, skip the expensive auto-capture probe (MediaPipe load) here.
+    // We only need to know if a camera API is available; the full capabilities
+    // resolution (including auto-capture) happens inside the component once the
+    // UI is shown.  If there is no camera API, bypass the popup and go directly
+    // to the media-picker fallback.
+    const supportsMediaDevices = typeof navigator.mediaDevices?.getUserMedia === 'function';
+    if (!supportsMediaDevices) {
+        if (captureOptions.allowMediaPickerFallback) {
+            return captureFromFileInput();
+        }
+        throw new Error('No supported capture strategy is available in this environment.');
+    }
+    return captureFromPopupCamera(captureOptions);
+}
+async function captureFromEmbeddedComponent(options) {
+    await import('../components/simface-capture.js');
+    const host = resolveEmbeddedCaptureHost(options.container);
+    const usingExistingElement = host.tagName.toLowerCase() === 'simface-capture';
+    const element = (usingExistingElement
+        ? host
+        : document.createElement('simface-capture'));
+    if (!usingExistingElement) {
+        host.appendChild(element);
+    }
+    element.embedded = true;
+    element.label = options.label;
+    element.confirmLabel = options.confirmLabel;
+    element.capturePreference = options.capturePreference;
+    element.allowMediaPickerFallback = options.allowMediaPickerFallback;
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            element.removeEventListener('simface-captured', handleCaptured);
+            element.removeEventListener('simface-cancelled', handleCancelled);
+            element.removeEventListener('simface-error', handleError);
+            element.active = false;
+            if (!usingExistingElement) {
+                element.remove();
+            }
+        };
+        const handleCaptured = (event) => {
+            cleanup();
+            resolve(event.detail.imageBlob);
+        };
+        const handleCancelled = () => {
+            cleanup();
+            resolve(null);
+        };
+        const handleError = (event) => {
+            cleanup();
+            reject(new Error(event.detail.error));
+        };
+        element.addEventListener('simface-captured', handleCaptured);
+        element.addEventListener('simface-cancelled', handleCancelled);
+        element.addEventListener('simface-error', handleError);
+        void element.startCapture().catch((error) => {
+            cleanup();
+            reject(error instanceof Error ? error : new Error('Embedded capture failed.'));
+        });
+    });
 }
-async function supportsRealtimeAutoCapture() {
-    if (typeof window.requestAnimationFrame !== 'function' ||
-        typeof window.cancelAnimationFrame !== 'function') {
-        return false;
+function resolveEmbeddedCaptureHost(container) {
+    if (!container) {
+        throw new Error('Embedded capture requires a container element or selector.');
     }
-    if (!document.createElement('canvas').getContext('2d')) {
-        return false;
+    if (container instanceof HTMLElement) {
+        return container;
     }
-    try {
-        await getVideoDetector();
-        return true;
-    }
-    catch {
-        return false;
+    const element = document.querySelector(container);
+    if (!element) {
+        throw new Error(`No element matched the embedded capture container selector "${container}".`);
     }
+    return element;
 }
-async function captureFromMediaDevices(initialMode) {
-    let stream;
-    try {
-        stream = await navigator.mediaDevices.getUserMedia({
-            video: { facingMode: { ideal: 'user' } },
-            audio: false,
-        });
-    }
-    catch (error) {
-        throw new Error(describeCameraError(error));
-    }
-    let streamStopped = false;
-    const stopStream = () => {
-        if (streamStopped) {
-            return;
-        }
-        streamStopped = true;
-        stream.getTracks().forEach((track) => track.stop());
-    };
+async function captureFromPopupCamera(options) {
+    await import('../components/simface-capture.js');
     return new Promise((resolve, reject) => {
         let settled = false;
-        let mode = initialMode;
-        let overlay = null;
-        let previewUrl = '';
-        let previewBlob = null;
-        let animationFrameId = null;
         let escapeHandler = null;
-        let lastAnalysisTimestamp = 0;
-        let analysisInFlight = false;
-        let previewActive = false;
-        let videoReady = false;
-        let countdownStartedAt = null;
-        let bestCaptureBlob = null;
-        let bestCaptureScore = -1;
-        let bestQualityResult = null;
-        const resetAutoCaptureState = (guideOverlay) => {
-            countdownStartedAt = null;
-            bestCaptureBlob = null;
-            bestCaptureScore = -1;
-            bestQualityResult = null;
-            guideOverlay.setProgress(0);
-        };
+        const overlay = document.createElement('div');
+        overlay.setAttribute('data-simface-camera-overlay', 'true');
+        overlay.setAttribute('role', 'dialog');
+        overlay.setAttribute('aria-modal', 'true');
+        applyStyles(overlay, {
+            position: 'fixed',
+            inset: '0',
+            zIndex: CAPTURE_DIALOG_Z_INDEX,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            padding: '24px',
+            background: 'rgba(15, 23, 42, 0.82)',
+            colorScheme: 'light',
+        });
+        const element = document.createElement('simface-capture');
+        element.label = options.label;
+        element.confirmLabel = options.confirmLabel;
+        element.capturePreference = options.capturePreference;
+        element.allowMediaPickerFallback = options.allowMediaPickerFallback;
+        overlay.appendChild(element);
+        document.body.appendChild(overlay);
         const cleanup = () => {
-            if (animationFrameId !== null) {
-                window.cancelAnimationFrame(animationFrameId);
-            }
             if (escapeHandler) {
                 window.removeEventListener('keydown', escapeHandler);
             }
-            if (previewUrl) {
-                URL.revokeObjectURL(previewUrl);
-            }
-            stopStream();
-            overlay?.remove();
+            element.removeEventListener('simface-captured', handleCaptured);
+            element.removeEventListener('simface-cancelled', handleCancelled);
+            element.removeEventListener('simface-error', handleError);
+            element.active = false;
+            overlay.remove();
         };
         const finalize = (value, error) => {
             if (settled) {
@@ -103,514 +138,31 @@ async function captureFromMediaDevices(initialMode) {
             }
             resolve(value);
         };
-        const renderCaptureMode = (video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay) => {
-            previewActive = false;
-            resetAutoCaptureState(guideOverlay);
-            if (previewUrl) {
-                URL.revokeObjectURL(previewUrl);
-                previewUrl = '';
-            }
-            previewBlob = null;
-            mediaContainer.replaceChildren(video, guideOverlay.wrapper);
-            if (videoReady) {
-                resumeVideoPreview(video);
-            }
-            title.textContent = mode === 'auto' ? 'Center your face' : 'Take a face photo';
-            copy.textContent =
-                mode === 'auto'
-                    ? 'Keep your face inside the oval. We will start a short countdown when the framing looks good and keep the best frame.'
-                    : 'Line up your face in the oval, then take a photo manually.';
-            feedback.textContent =
-                mode === 'auto'
-                    ? 'Looking for a single face in frame...'
-                    : 'When you are ready, press Take photo.';
-            setFeedbackState(feedback, mode === 'auto' ? 'neutral' : 'manual');
-            captureButton.style.display = mode === 'manual' ? 'inline-flex' : 'none';
-            captureButton.disabled = true;
-            actions.replaceChildren(cancelButton, captureButton);
-        };
-        const renderPreviewMode = (video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, qualityResult, options) => {
-            previewActive = true;
-            countdownStartedAt = null;
-            if (previewUrl) {
-                URL.revokeObjectURL(previewUrl);
-            }
-            previewUrl = URL.createObjectURL(blob);
-            previewBlob = blob;
-            const image = document.createElement('img');
-            image.alt = 'Captured face preview';
-            image.src = previewUrl;
-            applyStyles(image, {
-                position: 'absolute',
-                inset: '0',
-                zIndex: '1',
-                width: '100%',
-                height: '100%',
-                objectFit: 'cover',
-            });
-            mediaContainer.replaceChildren(video, image);
-            title.textContent = 'Review your photo';
-            copy.textContent =
-                options?.copyText
-                    ?? (qualityResult?.passesQualityChecks === false
-                        ? 'The capture did not pass the checks. Retake the photo.'
-                        : 'Confirm this photo or retake it.');
-            feedback.textContent =
-                options?.feedbackText
-                    ?? qualityResult?.message
-                    ?? 'Review the captured image before continuing.';
-            setFeedbackState(feedback, options?.feedbackState
-                ?? (qualityResult
-                    ? qualityResult.passesQualityChecks
-                        ? 'success'
-                        : 'error'
-                    : 'manual'));
-            actions.replaceChildren(cancelButton, retakeButton);
-            if (qualityResult?.passesQualityChecks !== false) {
-                actions.append(confirmButton);
-            }
-        };
-        try {
-            overlay = document.createElement('div');
-            overlay.setAttribute('data-simface-camera-overlay', 'true');
-            overlay.setAttribute('role', 'dialog');
-            overlay.setAttribute('aria-modal', 'true');
-            applyStyles(overlay, {
-                position: 'fixed',
-                inset: '0',
-                zIndex: CAPTURE_DIALOG_Z_INDEX,
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-                padding: '24px',
-                background: 'rgba(15, 23, 42, 0.82)',
-            });
-            const panel = document.createElement('div');
-            applyStyles(panel, {
-                width: 'min(100%, 560px)',
-                display: 'flex',
-                flexDirection: 'column',
-                gap: '16px',
-                padding: '20px',
-                borderRadius: '20px',
-                background: '#020617',
-                color: '#e2e8f0',
-                boxShadow: '0 24px 60px rgba(15, 23, 42, 0.35)',
-            });
-            const title = document.createElement('h2');
-            applyStyles(title, {
-                margin: '0',
-                fontSize: '1.25rem',
-                fontWeight: '700',
-            });
-            const copy = document.createElement('p');
-            applyStyles(copy, {
-                margin: '0',
-                color: '#cbd5e1',
-                fontSize: '0.95rem',
-                lineHeight: '1.5',
-            });
-            const mediaContainer = document.createElement('div');
-            applyStyles(mediaContainer, {
-                position: 'relative',
-                overflow: 'hidden',
-                width: '100%',
-                aspectRatio: '3 / 4',
-                minHeight: '320px',
-                borderRadius: '18px',
-                background: '#000',
-            });
-            const video = document.createElement('video');
-            video.autoplay = true;
-            video.muted = true;
-            video.playsInline = true;
-            video.srcObject = stream;
-            applyStyles(video, {
-                width: '100%',
-                height: '100%',
-                objectFit: 'cover',
-            });
-            const feedback = document.createElement('div');
-            applyStyles(feedback, {
-                borderRadius: '14px',
-                padding: '12px 14px',
-                font: '600 14px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
-            });
-            const actions = document.createElement('div');
-            applyStyles(actions, {
-                display: 'flex',
-                flexWrap: 'wrap',
-                gap: '12px',
-                justifyContent: 'flex-end',
-            });
-            const cancelButton = createActionButton('Cancel', 'secondary');
-            cancelButton.dataset.simfaceAction = 'cancel';
-            const captureButton = createActionButton('Take photo', 'primary');
-            captureButton.dataset.simfaceAction = 'capture';
-            captureButton.style.display = mode === 'manual' ? 'inline-flex' : 'none';
-            captureButton.disabled = true;
-            const guideOverlay = createGuideOverlay();
-            const confirmButton = createActionButton('Use photo', 'primary');
-            confirmButton.dataset.simfaceAction = 'confirm';
-            const retakeButton = createActionButton('Retake', 'secondary');
-            retakeButton.dataset.simfaceAction = 'retake';
-            panel.append(title, copy, mediaContainer, feedback, actions);
-            overlay.append(panel);
-            document.body.appendChild(overlay);
-            renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
-            escapeHandler = (event) => {
-                if (event.key === 'Escape') {
-                    finalize(null);
-                }
-            };
-            cancelButton.addEventListener('click', () => finalize(null));
-            confirmButton.addEventListener('click', async () => {
-                if (!previewBlob) {
-                    finalize(null, new Error('Failed to confirm the photo.'));
-                    return;
-                }
-                finalize(previewBlob);
-            });
-            retakeButton.addEventListener('click', () => {
-                renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
-                if (mode === 'manual' && videoReady) {
-                    captureButton.disabled = false;
-                }
-                if (mode === 'auto') {
-                    scheduleAutoCapture();
-                }
-            });
-            captureButton.addEventListener('click', async () => {
-                if (previewActive) {
-                    return;
-                }
-                try {
-                    const blob = await captureVideoFrame(video);
-                    const qualityResult = await assessCapturedBlobSafely(blob);
-                    renderPreviewMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, qualityResult);
-                }
-                catch (error) {
-                    finalize(null, error instanceof Error ? error : new Error('Failed to capture an image.'));
-                }
-            });
-            window.addEventListener('keydown', escapeHandler);
-            waitForVideoReady(video)
-                .then(() => {
-                videoReady = true;
-                if (mode === 'manual') {
-                    captureButton.disabled = false;
-                    return;
-                }
-                scheduleAutoCapture();
-            })
-                .catch((error) => {
-                finalize(null, error instanceof Error ? error : new Error('Failed to start the camera preview.'));
-            });
-            function scheduleAutoCapture() {
-                if (settled || previewActive || mode !== 'auto') {
-                    return;
-                }
-                animationFrameId = window.requestAnimationFrame(async (timestamp) => {
-                    if (previewActive ||
-                        analysisInFlight ||
-                        timestamp - lastAnalysisTimestamp < AUTO_CAPTURE_ANALYSIS_INTERVAL_MS) {
-                        scheduleAutoCapture();
-                        return;
-                    }
-                    lastAnalysisTimestamp = timestamp;
-                    analysisInFlight = true;
-                    try {
-                        const qualityResult = await assessFaceQualityForVideo(video, timestamp);
-                        if (qualityResult.passesQualityChecks) {
-                            if (countdownStartedAt === null) {
-                                countdownStartedAt = timestamp;
-                            }
-                            if (qualityResult.captureScore > bestCaptureScore) {
-                                bestCaptureBlob = await captureVideoFrame(video);
-                                bestCaptureScore = qualityResult.captureScore;
-                                bestQualityResult = qualityResult;
-                            }
-                        }
-                        if (countdownStartedAt !== null) {
-                            const countdownProgress = Math.min((timestamp - countdownStartedAt) / AUTO_CAPTURE_COUNTDOWN_MS, 1);
-                            guideOverlay.setProgress(countdownProgress);
-                            feedback.textContent = autoCaptureCountdownMessage(timestamp, countdownStartedAt, qualityResult);
-                            setFeedbackState(feedback, qualityResult.passesQualityChecks ? 'success' : 'neutral');
-                            if (countdownProgress >= 1) {
-                                const blob = bestCaptureBlob ?? await captureVideoFrame(video);
-                                const previewQualityResult = bestCaptureBlob && bestQualityResult
-                                    ? bestQualityResult
-                                    : await assessCapturedBlobSafely(blob);
-                                renderPreviewMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, confirmButton, retakeButton, blob, previewQualityResult, {
-                                    copyText: 'Best frame captured. Review and confirm this photo.',
-                                    feedbackText: autoCaptureCompleteMessage(previewQualityResult),
-                                    feedbackState: previewQualityResult?.passesQualityChecks === false ? 'error' : 'success',
-                                });
-                                return;
-                            }
-                        }
-                        else {
-                            guideOverlay.setProgress(0);
-                            feedback.textContent = qualityResult.message;
-                            setFeedbackState(feedback, qualityResult.passesQualityChecks ? 'success' : 'neutral');
-                        }
-                    }
-                    catch (error) {
-                        mode = 'manual';
-                        renderCaptureMode(video, mediaContainer, title, copy, feedback, actions, cancelButton, captureButton, guideOverlay);
-                        captureButton.disabled = false;
-                        feedback.textContent = 'Automatic capture is unavailable in this browser. Use Take photo instead.';
-                        setFeedbackState(feedback, 'manual');
-                    }
-                    finally {
-                        analysisInFlight = false;
-                    }
-                    scheduleAutoCapture();
-                });
-            }
-        }
-        catch (error) {
-            finalize(null, error instanceof Error ? error : new Error('Failed to open the camera capture UI.'));
-        }
-    });
-}
-function captureFromFileInput() {
-    return new Promise((resolve) => {
-        const input = document.createElement('input');
-        input.type = 'file';
-        input.accept = 'image/*';
-        input.capture = 'user';
-        input.style.display = 'none';
-        input.addEventListener('change', () => {
-            const file = input.files?.[0] ?? null;
-            cleanup();
-            resolve(file);
-        });
-        const handleFocus = () => {
-            setTimeout(() => {
-                if (!input.files?.length) {
-                    cleanup();
-                    resolve(null);
-                }
-            }, 500);
-        };
-        window.addEventListener('focus', handleFocus, { once: true });
-        function cleanup() {
-            window.removeEventListener('focus', handleFocus);
-            input.remove();
-        }
-        document.body.appendChild(input);
-        input.click();
-    });
-}
-function prefersNativeCameraCapture() {
-    return /WhatsApp/i.test(navigator.userAgent);
-}
-async function waitForVideoReady(video) {
-    if (video.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
-        await video.play();
-        return;
-    }
-    await new Promise((resolve, reject) => {
-        const handleReady = () => {
-            cleanup();
-            resolve();
+        const handleCaptured = (event) => {
+            finalize(event.detail.imageBlob);
         };
-        const handleError = () => {
-            cleanup();
-            reject(new Error('Failed to start the camera preview.'));
+        const handleCancelled = () => {
+            finalize(null);
         };
-        const cleanup = () => {
-            video.removeEventListener('loadedmetadata', handleReady);
-            video.removeEventListener('error', handleError);
+        const handleError = (event) => {
+            finalize(null, new Error(event.detail.error));
         };
-        video.addEventListener('loadedmetadata', handleReady, { once: true });
-        video.addEventListener('error', handleError, { once: true });
-    });
-    await video.play();
-}
-function captureVideoFrame(video) {
-    if (!video.videoWidth || !video.videoHeight) {
-        return Promise.reject(new Error('Camera preview is not ready yet.'));
-    }
-    const canvas = document.createElement('canvas');
-    canvas.width = video.videoWidth;
-    canvas.height = video.videoHeight;
-    const context = canvas.getContext('2d');
-    if (!context) {
-        return Promise.reject(new Error('Failed to initialize camera capture.'));
-    }
-    context.drawImage(video, 0, 0, canvas.width, canvas.height);
-    return new Promise((resolve, reject) => {
-        canvas.toBlob((blob) => {
-            if (!blob) {
-                reject(new Error('Failed to capture an image.'));
-                return;
+        escapeHandler = (event) => {
+            if (event.key === 'Escape') {
+                finalize(null);
             }
-            resolve(blob);
-        }, 'image/jpeg', 0.92);
-    });
-}
-function resumeVideoPreview(video) {
-    void video.play().catch(() => {
-        // Ignore resume failures here; capture flow already handles preview startup errors.
-    });
-}
-async function assessCapturedBlobSafely(blob) {
-    try {
-        const image = await blobToImage(blob);
-        return await assessFaceQuality(image);
-    }
-    catch {
-        return null;
-    }
-}
-function createActionButton(label, variant) {
-    const button = document.createElement('button');
-    button.type = 'button';
-    button.textContent = label;
-    applyStyles(button, {
-        display: 'inline-flex',
-        alignItems: 'center',
-        justifyContent: 'center',
-        border: 'none',
-        borderRadius: '999px',
-        padding: '12px 18px',
-        font: '600 15px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
-        cursor: 'pointer',
-        color: variant === 'primary' ? '#fff' : '#0f172a',
-        background: variant === 'primary' ? '#2563eb' : '#e2e8f0',
-    });
-    return button;
-}
-function createGuideOverlay() {
-    const wrapper = document.createElement('div');
-    applyStyles(wrapper, {
-        position: 'absolute',
-        inset: '0',
-        pointerEvents: 'none',
-    });
-    const svg = createSvgElement('svg');
-    svg.setAttribute('viewBox', '0 0 100 100');
-    svg.setAttribute('preserveAspectRatio', 'none');
-    applyStyles(svg, {
-        width: '100%',
-        height: '100%',
-        display: 'block',
+        };
+        element.addEventListener('simface-captured', handleCaptured);
+        element.addEventListener('simface-cancelled', handleCancelled);
+        element.addEventListener('simface-error', handleError);
+        window.addEventListener('keydown', escapeHandler);
+        void element.startCapture().catch((error) => {
+            finalize(null, error instanceof Error ? error : new Error('Popup capture failed.'));
+        });
     });
-    const mask = createSvgElement('path');
-    mask.setAttribute('d', CAPTURE_GUIDE_MASK_PATH);
-    mask.setAttribute('fill', 'rgba(51, 65, 85, 0.75)');
-    mask.setAttribute('fill-rule', 'evenodd');
-    const outline = createSvgElement('path');
-    outline.setAttribute('d', CAPTURE_GUIDE_PATH);
-    outline.setAttribute('fill', 'none');
-    outline.setAttribute('stroke', 'rgba(255, 255, 255, 0.92)');
-    outline.setAttribute('stroke-width', '2.8');
-    outline.setAttribute('stroke-linecap', 'round');
-    outline.setAttribute('stroke-linejoin', 'round');
-    const progress = createSvgElement('path');
-    progress.setAttribute('d', CAPTURE_GUIDE_PATH);
-    progress.setAttribute('fill', 'none');
-    progress.setAttribute('stroke', '#22c55e');
-    progress.setAttribute('stroke-width', '2.8');
-    progress.setAttribute('stroke-linecap', 'round');
-    progress.setAttribute('stroke-linejoin', 'round');
-    progress.setAttribute('pathLength', '100');
-    progress.setAttribute('stroke-dasharray', '100');
-    progress.setAttribute('stroke-dashoffset', '100');
-    progress.style.transition = 'stroke-dashoffset 0.14s linear, opacity 0.14s linear';
-    progress.style.opacity = '0';
-    svg.append(mask, outline, progress);
-    wrapper.append(svg);
-    return {
-        wrapper,
-        setProgress(value) {
-            const progressValue = Math.min(Math.max(value, 0), 1);
-            progress.setAttribute('stroke-dashoffset', `${100 - progressValue * 100}`);
-            progress.style.opacity = progressValue > 0 ? '1' : '0';
-        },
-    };
-}
-function createSvgElement(tagName) {
-    return document.createElementNS('http://www.w3.org/2000/svg', tagName);
-}
-function setFeedbackState(element, state) {
-    switch (state) {
-        case 'success':
-            applyStyles(element, {
-                background: '#dcfce7',
-                color: '#166534',
-            });
-            return;
-        case 'error':
-            applyStyles(element, {
-                background: '#fee2e2',
-                color: '#991b1b',
-            });
-            return;
-        case 'manual':
-            applyStyles(element, {
-                background: '#e0f2fe',
-                color: '#0f172a',
-            });
-            return;
-        default:
-            applyStyles(element, {
-                background: '#e2e8f0',
-                color: '#0f172a',
-            });
-    }
 }
 function applyStyles(element, styles) {
     Object.assign(element.style, styles);
 }
-function describeCameraError(error) {
-    if (error instanceof DOMException) {
-        switch (error.name) {
-            case 'NotAllowedError':
-            case 'SecurityError':
-                return 'Camera access was denied. Allow camera access and try again.';
-            case 'NotFoundError':
-                return 'No camera was found on this device.';
-            case 'NotReadableError':
-                return 'The camera is already in use by another application.';
-            default:
-                return error.message || 'Failed to access the camera.';
-        }
-    }
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return 'Failed to access the camera.';
-}
-/**
- * Loads a Blob as an HTMLImageElement for face detection analysis.
- */
-export function blobToImage(blob) {
-    return new Promise((resolve, reject) => {
-        const url = URL.createObjectURL(blob);
-        const img = new Image();
-        img.onload = () => {
-            URL.revokeObjectURL(url);
-            resolve(img);
-        };
-        img.onerror = () => {
-            URL.revokeObjectURL(url);
-            reject(new Error('Failed to load captured image'));
-        };
-        img.src = url;
-    });
-}
-/**
- * Creates a data URL from a Blob for display in an <img> tag.
- */
-export function blobToDataURL(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new Error('Failed to read image'));
-        reader.readAsDataURL(blob);
-    });
-}
+export { blobToImage, blobToDataURL };
 //# sourceMappingURL=camera.js.map