@pallasoft/ps-file-components 1.4.0 → 1.5.0

package/dist/esm/hooks/use-ps-scan-camera.js

@@ -6,18 +6,40 @@ import { PsScanCanvasService } from '../services/ps-scan-canvas-service';
 export const usePsScanCamera = (isActive) => {
     const videoRef = useRef(null);
     const sessionRef = useRef(null);
-    const [status, setStatus] = useState(PsScanCameraStatus.Starting);
+    const [status, setStatus] = useState(PsScanCameraStatus.Checking);
+    const [request, setRequest] = useState(0);
     const [canTorch, setCanTorch] = useState(false);
     const [isTorchOn, setIsTorchOn] = useState(false);
     useEffect(() => {
-        if (!isActive)
+        let isCancelled = false;
+        let permission = null;
+        const onChange = () => {
+            if (permission !== null && permission.state === 'granted')
+                setRequest((current) => current + 1);
+        };
+        PsScanCameraService.check().then(async (next) => {
+            if (isCancelled)
+                return;
+            if (next === PsScanCameraStatus.Starting)
+                setRequest(1);
+            else
+                setStatus(next);
+            permission = await PsScanCameraService.permission();
+            if (isCancelled || permission === null)
+                return;
+            permission.addEventListener('change', onChange);
+        });
+        return () => {
+            isCancelled = true;
+            if (permission !== null)
+                permission.removeEventListener('change', onChange);
+        };
+    }, []);
+    useEffect(() => {
+        if (!isActive || request === 0)
             return;
         let isCancelled = false;
         setIsTorchOn(false);
-        if (!PsScanCameraService.isSupported()) {
-            setStatus(PsScanCameraStatus.Unavailable);
-            return;
-        }
         setStatus(PsScanCameraStatus.Starting);
         PsScanCameraService.open()
             .then(async (session) => {
@@ -27,12 +49,10 @@ export const usePsScanCamera = (isActive) => {
             }
             sessionRef.current = session;
             setCanTorch(session.canTorch);
-            const video = videoRef.current;
-            if (video !== null) {
-                video.srcObject = session.stream;
-                await video.play().catch(() => undefined);
-            }
-            setStatus(PsScanCameraStatus.Ready);
+            if (videoRef.current !== null)
+                await PsScanCameraService.attach(videoRef.current, session);
+            if (!isCancelled)
+                setStatus(PsScanCameraStatus.Ready);
         })
             .catch((error) => {
             if (!isCancelled)
@@ -45,7 +65,13 @@ export const usePsScanCamera = (isActive) => {
             if (videoRef.current !== null)
                 videoRef.current.srcObject = null;
         };
-    }, [isActive]);
+    }, [isActive, request]);
+    const attachVideo = useCallback((element) => {
+        videoRef.current = element;
+        if (element !== null && sessionRef.current !== null)
+            void PsScanCameraService.attach(element, sessionRef.current);
+    }, []);
+    const allow = useCallback(() => setRequest((current) => current + 1), []);
     const toggleTorch = useCallback(async () => {
         const session = sessionRef.current;
         if (session === null)
@@ -54,9 +80,20 @@ export const usePsScanCamera = (isActive) => {
     }, [isTorchOn]);
     const capture = useCallback(async () => {
         const video = videoRef.current;
-        if (video === null || video.videoWidth === 0)
+        if (video === null ||
+            video.videoWidth === 0 ||
+            video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA)
             return null;
         return await PsScanCanvasService.fromVideo(video, PsScanConfig.capturedJpegQuality);
     }, []);
-    return { canTorch, capture, isTorchOn, status, toggleTorch, videoRef };
+    return {
+        allow,
+        attachVideo,
+        canTorch,
+        capture,
+        isTorchOn,
+        status,
+        toggleTorch,
+        videoRef,
+    };
 };

package/dist/esm/hooks/use-ps-scan-live-detection.js

@@ -0,0 +1,45 @@
+import { useEffect, useRef, useState } from 'react';
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanCanvasService } from '../services/ps-scan-canvas-service';
+import { PsScanEdgeService } from '../services/ps-scan-edge-service';
+import { PsScanStabilityService } from '../services/ps-scan-stability-service';
+export const usePsScanLiveDetection = (videoRef, isActive, isAuto, onSteady) => {
+    const [detection, setDetection] = useState({ progress: 0, quad: null });
+    const isAutoRef = useRef(isAuto);
+    const onSteadyRef = useRef(onSteady);
+    isAutoRef.current = isAuto;
+    onSteadyRef.current = onSteady;
+    useEffect(() => {
+        if (!isActive) {
+            setDetection({ progress: 0, quad: null });
+            return;
+        }
+        let state = PsScanStabilityService.initial();
+        let last = performance.now();
+        let timer;
+        const tick = () => {
+            const video = videoRef.current;
+            const now = performance.now();
+            if (video !== null && video.videoWidth > 0 && document.visibilityState === 'visible') {
+                try {
+                    const raster = PsScanCanvasService.sample(video, PsScanConfig.liveDetectMaxDimension);
+                    state = PsScanStabilityService.next(state, PsScanEdgeService.detect(raster), now - last);
+                }
+                catch {
+                    state = PsScanStabilityService.initial();
+                }
+                const progress = isAutoRef.current ? PsScanStabilityService.progress(state) : 0;
+                setDetection({ progress, quad: state.quad });
+                if (progress >= 1) {
+                    state = PsScanStabilityService.disarm(state);
+                    onSteadyRef.current();
+                }
+            }
+            last = now;
+            timer = setTimeout(tick, PsScanConfig.liveDetectIntervalMs);
+        };
+        timer = setTimeout(tick, PsScanConfig.liveDetectIntervalMs);
+        return () => clearTimeout(timer);
+    }, [isActive]);
+    return detection;
+};

package/dist/esm/index.js

@@ -74,3 +74,4 @@ export * from './constants/ps-document-scanner-labels';
 export * from './constants/ps-scan-filter';
 export * from './constants/ps-scan-output-format';
 export * from './models/ps-document-scanner-props';
+export * from './models/ps-file-picker-scan';

package/dist/esm/models/ps-file-picker-scan.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/ps-scan-live-detection.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/ps-scan-stability.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/ps-scan-camera-service.js

@@ -1,13 +1,45 @@
 import { PsScanCameraStatus } from '../constants/ps-scan-camera-status';
 import { PsScanConfig } from '../constants/ps-scan-config';
 export class PsScanCameraService {
+    static async attach(video, session) {
+        if (video.srcObject !== session.stream)
+            video.srcObject = session.stream;
+        await video.play().catch(() => undefined);
+    }
+    static async check() {
+        if (globalThis.isSecureContext === false)
+            return PsScanCameraStatus.Insecure;
+        if (!PsScanCameraService.isSupported())
+            return PsScanCameraStatus.Unavailable;
+        if (!(await PsScanCameraService.hasCamera()))
+            return PsScanCameraStatus.Unavailable;
+        const permission = await PsScanCameraService.permission();
+        if (permission === null)
+            return PsScanCameraStatus.Prompt;
+        if (permission.state === 'granted')
+            return PsScanCameraStatus.Starting;
+        return permission.state === 'denied' ? PsScanCameraStatus.Denied : PsScanCameraStatus.Prompt;
+    }
     static classify(error) {
         const name = typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
-        return name === 'NotAllowedError' ||
-            name === 'SecurityError' ||
-            name === 'PermissionDeniedError'
-            ? PsScanCameraStatus.Denied
-            : PsScanCameraStatus.Unavailable;
+        if (name === 'NotAllowedError' || name === 'PermissionDeniedError')
+            return PsScanCameraStatus.Denied;
+        if (name === 'SecurityError')
+            return PsScanCameraStatus.Insecure;
+        if (name === 'NotReadableError' || name === 'TrackStartError' || name === 'AbortError')
+            return PsScanCameraStatus.Busy;
+        return PsScanCameraStatus.Unavailable;
+    }
+    static async hasCamera() {
+        if (typeof navigator.mediaDevices.enumerateDevices !== 'function')
+            return true;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.length === 0 || devices.some((device) => device.kind === 'videoinput');
+        }
+        catch {
+            return true;
+        }
     }
     static isSupported() {
         return (typeof navigator !== 'undefined' &&
@@ -26,6 +58,19 @@ export class PsScanCameraService {
         const track = stream.getVideoTracks()[0];
         return { canTorch: PsScanCameraService.supportsTorch(track), stream, track };
     }
+    static async permission() {
+        if (typeof navigator.permissions === 'undefined' ||
+            typeof navigator.permissions.query !== 'function')
+            return null;
+        try {
+            return await navigator.permissions.query({
+                name: PsScanConfig.cameraPermission,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     static async setTorch(track, isOn) {
         try {
             await track.applyConstraints({

package/dist/esm/services/ps-scan-canvas-service.js

@@ -27,6 +27,12 @@ export class PsScanCanvasService {
         context.drawImage(video, 0, 0);
         return await PsScanCanvasService.encode(context.getImageData(0, 0, video.videoWidth, video.videoHeight), quality);
     }
+    static sample(video, maxDimension) {
+        const size = PsScanGeometryService.fitWithin({ height: video.videoHeight, width: video.videoWidth }, maxDimension);
+        const context = PsScanCanvasService.context(size.width, size.height);
+        context.drawImage(video, 0, 0, size.width, size.height);
+        return context.getImageData(0, 0, size.width, size.height);
+    }
     static context(width, height) {
         if (typeof OffscreenCanvas !== 'undefined') {
             const context = new OffscreenCanvas(width, height).getContext('2d', {

package/dist/esm/services/ps-scan-edge-service.js

@@ -33,7 +33,7 @@ export class PsScanEdgeService {
             return null;
         if (!PsScanGeometryService.isConvex(quad))
             return null;
-        return quad.map((point) => ({
+        return PsScanGeometryService.inset(quad, PsScanConfig.detectInset).map((point) => ({
             x: Math.min(1, Math.max(0, point.x / (width - 1))),
             y: Math.min(1, Math.max(0, point.y / (height - 1))),
         }));

package/dist/esm/services/ps-scan-geometry-service.js

@@ -11,6 +11,12 @@ export class PsScanGeometryService {
     static clamp(point) {
         return { x: Math.min(1, Math.max(0, point.x)), y: Math.min(1, Math.max(0, point.y)) };
     }
+    static cover(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.max(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
     static defaultQuad() {
         const inset = 0.08;
         return [
@@ -39,6 +45,20 @@ export class PsScanGeometryService {
             width: Math.max(1, Math.round(size.width * scale)),
         };
     }
+    static inset(quad, distance) {
+        const centre = {
+            x: quad.reduce((sum, point) => sum + point.x, 0) / quad.length,
+            y: quad.reduce((sum, point) => sum + point.y, 0) / quad.length,
+        };
+        return quad.map((point) => {
+            const length = PsScanGeometryService.distance(point, centre);
+            const ratio = length <= distance ? 0 : (length - distance) / length;
+            return {
+                x: centre.x + (point.x - centre.x) * ratio,
+                y: centre.y + (point.y - centre.y) * ratio,
+            };
+        });
+    }
     static isConvex(points) {
         let sign = 0;
         for (let index = 0; index < points.length; index += 1) {

package/dist/esm/services/ps-scan-platform-service.js

@@ -0,0 +1,15 @@
+import { PsScanPlatform } from '../constants/ps-scan-platform';
+export class PsScanPlatformService {
+    static detect() {
+        if (typeof navigator === 'undefined')
+            return PsScanPlatform.Desktop;
+        const agent = navigator.userAgent;
+        if (/iPhone|iPad|iPod/i.test(agent))
+            return PsScanPlatform.Ios;
+        if (/Macintosh/i.test(agent) && navigator.maxTouchPoints > 1)
+            return PsScanPlatform.Ios;
+        if (/Android/i.test(agent))
+            return PsScanPlatform.Android;
+        return PsScanPlatform.Desktop;
+    }
+}

package/dist/esm/services/ps-scan-stability-service.js

@@ -0,0 +1,41 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanStabilityService {
+    static disarm(state) {
+        return { ...state, isArmed: false, stableMs: 0 };
+    }
+    static initial() {
+        return { isArmed: true, misses: 0, quad: null, raw: null, stableMs: 0 };
+    }
+    static movement(from, to) {
+        return Math.max(...from.map((point, index) => PsScanGeometryService.distance(point, to[index])));
+    }
+    static next(state, detected, elapsedMs) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > PsScanConfig.liveMissLimit
+                ? { isArmed: true, misses, quad: null, raw: null, stableMs: 0 }
+                : { ...state, misses, stableMs: 0 };
+        }
+        if (state.quad === null || state.raw === null)
+            return { ...state, misses: 0, quad: detected, raw: detected, stableMs: 0 };
+        const movement = PsScanStabilityService.movement(state.raw, detected);
+        const weight = PsScanConfig.liveSmoothing;
+        const quad = state.quad.map((point, index) => ({
+            x: point.x + (detected[index].x - point.x) * weight,
+            y: point.y + (detected[index].y - point.y) * weight,
+        }));
+        return {
+            isArmed: state.isArmed || movement > PsScanConfig.liveRearmMovement,
+            misses: 0,
+            quad,
+            raw: detected,
+            stableMs: movement <= PsScanConfig.liveStillMovement ? state.stableMs + elapsedMs : 0,
+        };
+    }
+    static progress(state) {
+        if (!state.isArmed || state.quad === null)
+            return 0;
+        return Math.min(1, state.stableMs / PsScanConfig.autoCaptureMs);
+    }
+}

package/dist/hooks/use-ps-scan-camera.d.ts

@@ -1,9 +1,11 @@
 import { PsScanCameraStatus } from '../constants/ps-scan-camera-status';
 export declare const usePsScanCamera: (isActive: boolean) => {
+    allow: () => void;
+    attachVideo: (element: HTMLVideoElement | null) => void;
     canTorch: boolean;
     capture: () => Promise<Blob | null>;
     isTorchOn: boolean;
     status: PsScanCameraStatus;
     toggleTorch: () => Promise<void>;
-    videoRef: import("react").RefObject<HTMLVideoElement>;
+    videoRef: import("react").MutableRefObject<HTMLVideoElement | null>;
 };

package/dist/hooks/use-ps-scan-camera.js

@@ -9,18 +9,40 @@ const ps_scan_canvas_service_1 = require("../services/ps-scan-canvas-service");
 const usePsScanCamera = (isActive) => {
     const videoRef = (0, react_1.useRef)(null);
     const sessionRef = (0, react_1.useRef)(null);
-    const [status, setStatus] = (0, react_1.useState)(ps_scan_camera_status_1.PsScanCameraStatus.Starting);
+    const [status, setStatus] = (0, react_1.useState)(ps_scan_camera_status_1.PsScanCameraStatus.Checking);
+    const [request, setRequest] = (0, react_1.useState)(0);
     const [canTorch, setCanTorch] = (0, react_1.useState)(false);
     const [isTorchOn, setIsTorchOn] = (0, react_1.useState)(false);
     (0, react_1.useEffect)(() => {
-        if (!isActive)
+        let isCancelled = false;
+        let permission = null;
+        const onChange = () => {
+            if (permission !== null && permission.state === 'granted')
+                setRequest((current) => current + 1);
+        };
+        ps_scan_camera_service_1.PsScanCameraService.check().then(async (next) => {
+            if (isCancelled)
+                return;
+            if (next === ps_scan_camera_status_1.PsScanCameraStatus.Starting)
+                setRequest(1);
+            else
+                setStatus(next);
+            permission = await ps_scan_camera_service_1.PsScanCameraService.permission();
+            if (isCancelled || permission === null)
+                return;
+            permission.addEventListener('change', onChange);
+        });
+        return () => {
+            isCancelled = true;
+            if (permission !== null)
+                permission.removeEventListener('change', onChange);
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!isActive || request === 0)
             return;
         let isCancelled = false;
         setIsTorchOn(false);
-        if (!ps_scan_camera_service_1.PsScanCameraService.isSupported()) {
-            setStatus(ps_scan_camera_status_1.PsScanCameraStatus.Unavailable);
-            return;
-        }
         setStatus(ps_scan_camera_status_1.PsScanCameraStatus.Starting);
         ps_scan_camera_service_1.PsScanCameraService.open()
             .then(async (session) => {
@@ -30,12 +52,10 @@ const usePsScanCamera = (isActive) => {
             }
             sessionRef.current = session;
             setCanTorch(session.canTorch);
-            const video = videoRef.current;
-            if (video !== null) {
-                video.srcObject = session.stream;
-                await video.play().catch(() => undefined);
-            }
-            setStatus(ps_scan_camera_status_1.PsScanCameraStatus.Ready);
+            if (videoRef.current !== null)
+                await ps_scan_camera_service_1.PsScanCameraService.attach(videoRef.current, session);
+            if (!isCancelled)
+                setStatus(ps_scan_camera_status_1.PsScanCameraStatus.Ready);
         })
             .catch((error) => {
             if (!isCancelled)
@@ -48,7 +68,13 @@ const usePsScanCamera = (isActive) => {
             if (videoRef.current !== null)
                 videoRef.current.srcObject = null;
         };
-    }, [isActive]);
+    }, [isActive, request]);
+    const attachVideo = (0, react_1.useCallback)((element) => {
+        videoRef.current = element;
+        if (element !== null && sessionRef.current !== null)
+            void ps_scan_camera_service_1.PsScanCameraService.attach(element, sessionRef.current);
+    }, []);
+    const allow = (0, react_1.useCallback)(() => setRequest((current) => current + 1), []);
     const toggleTorch = (0, react_1.useCallback)(async () => {
         const session = sessionRef.current;
         if (session === null)
@@ -57,10 +83,21 @@ const usePsScanCamera = (isActive) => {
     }, [isTorchOn]);
     const capture = (0, react_1.useCallback)(async () => {
         const video = videoRef.current;
-        if (video === null || video.videoWidth === 0)
+        if (video === null ||
+            video.videoWidth === 0 ||
+            video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA)
             return null;
         return await ps_scan_canvas_service_1.PsScanCanvasService.fromVideo(video, ps_scan_config_1.PsScanConfig.capturedJpegQuality);
     }, []);
-    return { canTorch, capture, isTorchOn, status, toggleTorch, videoRef };
+    return {
+        allow,
+        attachVideo,
+        canTorch,
+        capture,
+        isTorchOn,
+        status,
+        toggleTorch,
+        videoRef,
+    };
 };
 exports.usePsScanCamera = usePsScanCamera;

package/dist/hooks/use-ps-scan-live-detection.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from 'react';
+import type { PsScanLiveDetection } from '../models/ps-scan-live-detection';
+export declare const usePsScanLiveDetection: (videoRef: RefObject<HTMLVideoElement | null>, isActive: boolean, isAuto: boolean, onSteady: () => void) => PsScanLiveDetection;

package/dist/hooks/use-ps-scan-live-detection.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanLiveDetection = void 0;
+const react_1 = require("react");
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_canvas_service_1 = require("../services/ps-scan-canvas-service");
+const ps_scan_edge_service_1 = require("../services/ps-scan-edge-service");
+const ps_scan_stability_service_1 = require("../services/ps-scan-stability-service");
+const usePsScanLiveDetection = (videoRef, isActive, isAuto, onSteady) => {
+    const [detection, setDetection] = (0, react_1.useState)({ progress: 0, quad: null });
+    const isAutoRef = (0, react_1.useRef)(isAuto);
+    const onSteadyRef = (0, react_1.useRef)(onSteady);
+    isAutoRef.current = isAuto;
+    onSteadyRef.current = onSteady;
+    (0, react_1.useEffect)(() => {
+        if (!isActive) {
+            setDetection({ progress: 0, quad: null });
+            return;
+        }
+        let state = ps_scan_stability_service_1.PsScanStabilityService.initial();
+        let last = performance.now();
+        let timer;
+        const tick = () => {
+            const video = videoRef.current;
+            const now = performance.now();
+            if (video !== null && video.videoWidth > 0 && document.visibilityState === 'visible') {
+                try {
+                    const raster = ps_scan_canvas_service_1.PsScanCanvasService.sample(video, ps_scan_config_1.PsScanConfig.liveDetectMaxDimension);
+                    state = ps_scan_stability_service_1.PsScanStabilityService.next(state, ps_scan_edge_service_1.PsScanEdgeService.detect(raster), now - last);
+                }
+                catch {
+                    state = ps_scan_stability_service_1.PsScanStabilityService.initial();
+                }
+                const progress = isAutoRef.current ? ps_scan_stability_service_1.PsScanStabilityService.progress(state) : 0;
+                setDetection({ progress, quad: state.quad });
+                if (progress >= 1) {
+                    state = ps_scan_stability_service_1.PsScanStabilityService.disarm(state);
+                    onSteadyRef.current();
+                }
+            }
+            last = now;
+            timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+        };
+        timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+        return () => clearTimeout(timer);
+    }, [isActive]);
+    return detection;
+};
+exports.usePsScanLiveDetection = usePsScanLiveDetection;

package/dist/index.d.ts

@@ -74,3 +74,4 @@ export * from './constants/ps-document-scanner-labels';
 export * from './constants/ps-scan-filter';
 export * from './constants/ps-scan-output-format';
 export * from './models/ps-document-scanner-props';
+export * from './models/ps-file-picker-scan';

package/dist/index.js

@@ -90,3 +90,4 @@ __exportStar(require("./constants/ps-document-scanner-labels"), exports);
 __exportStar(require("./constants/ps-scan-filter"), exports);
 __exportStar(require("./constants/ps-scan-output-format"), exports);
 __exportStar(require("./models/ps-document-scanner-props"), exports);
+__exportStar(require("./models/ps-file-picker-scan"), exports);

package/dist/models/ps-document-scanner-props.d.ts

@@ -4,6 +4,7 @@ import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerProps {
     className?: string;
     fileName?: string;
+    isAutoCapture?: boolean;
     isOpen: boolean;
     jpegQuality?: number;
     labels?: Partial<PsLabelSet<typeof PsDocumentScannerLabels>>;

package/dist/models/ps-document-scanner-sheet-props.d.ts

@@ -3,6 +3,7 @@ import type { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerSheetProps {
     fileName: string;
+    isAutoCapture: boolean;
     jpegQuality: number;
     labels: PsLabelSet<typeof PsDocumentScannerLabels>;
     maxDimension: number;

package/dist/models/ps-file-picker-scan.d.ts

@@ -0,0 +1,4 @@
+import type { PsDocumentScannerProps } from './ps-document-scanner-props';
+export interface PsFilePickerScan extends Omit<PsDocumentScannerProps, 'fileName' | 'isOpen' | 'onClose' | 'onComplete'> {
+    getFileName?: () => string;
+}

package/dist/models/ps-file-picker-scan.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scan-live-detection.d.ts

@@ -0,0 +1,5 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanLiveDetection {
+    progress: number;
+    quad: PsScanQuad | null;
+}

package/dist/models/ps-scan-live-detection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ps-scan-stability.d.ts

@@ -0,0 +1,8 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanStability {
+    isArmed: boolean;
+    misses: number;
+    quad: PsScanQuad | null;
+    raw: PsScanQuad | null;
+    stableMs: number;
+}

package/dist/models/ps-scan-stability.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/ps-scan-camera-service.d.ts

@@ -1,9 +1,13 @@
 import { PsScanCameraStatus } from '../constants/ps-scan-camera-status';
 import type { PsScanCameraSession } from '../models/ps-scan-camera-session';
 export declare class PsScanCameraService {
+    static attach(video: HTMLVideoElement, session: PsScanCameraSession): Promise<void>;
+    static check(): Promise<PsScanCameraStatus>;
     static classify(error: unknown): PsScanCameraStatus;
+    static hasCamera(): Promise<boolean>;
     static isSupported(): boolean;
     static open(): Promise<PsScanCameraSession>;
+    static permission(): Promise<PermissionStatus | null>;
     static setTorch(track: MediaStreamTrack, isOn: boolean): Promise<boolean>;
     static stop(stream: MediaStream | null): void;
     static supportsTorch(track: MediaStreamTrack | undefined): boolean;