@pallasoft/ps-file-components 1.4.0 → 2.0.0

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

@@ -1,25 +1,4 @@
-import { PsScanConfig } from '../constants/ps-scan-config';
-import { PsScanGeometryService } from './ps-scan-geometry-service';
 export class PsScanHullService {
-    static bestQuad(hull) {
-        const points = PsScanHullService.reduce(hull, PsScanConfig.hullCandidateLimit);
-        if (points.length <= 4)
-            return points;
-        let best = points.slice(0, 4);
-        let bestArea = 0;
-        for (let a = 0; a < points.length - 3; a += 1)
-            for (let b = a + 1; b < points.length - 2; b += 1)
-                for (let c = b + 1; c < points.length - 1; c += 1)
-                    for (let d = c + 1; d < points.length; d += 1) {
-                        const candidate = [points[a], points[b], points[c], points[d]];
-                        const area = PsScanGeometryService.area(candidate);
-                        if (area > bestArea) {
-                            bestArea = area;
-                            best = candidate;
-                        }
-                    }
-        return best;
-    }
     static convexHull(input) {
         const points = [...input].sort((a, b) => (a.x === b.x ? a.y - b.y : a.x - b.x));
         if (points.length < 3)
@@ -38,22 +17,4 @@ export class PsScanHullService {
         };
         return [...build(points), ...build([...points].reverse())];
     }
-    static reduce(hull, limit) {
-        const points = [...hull];
-        while (points.length > limit) {
-            let weakest = 0;
-            let weakestArea = Infinity;
-            points.forEach((point, index) => {
-                const previous = points[(index - 1 + points.length) % points.length];
-                const next = points[(index + 1) % points.length];
-                const area = PsScanGeometryService.area([previous, point, next]);
-                if (area < weakestArea) {
-                    weakestArea = area;
-                    weakest = index;
-                }
-            });
-            points.splice(weakest, 1);
-        }
-        return points;
-    }
 }

package/dist/esm/services/ps-scan-image-filter-service.js

@@ -28,25 +28,4 @@ export class PsScanImageFilterService {
         }
         return out;
     }
-    static sobel(gray, width, height) {
-        const out = new Uint16Array(width * height);
-        for (let y = 1; y < height - 1; y += 1)
-            for (let x = 1; x < width - 1; x += 1) {
-                const i = y * width + x;
-                const gx = -gray[i - width - 1] +
-                    gray[i - width + 1] -
-                    2 * gray[i - 1] +
-                    2 * gray[i + 1] -
-                    gray[i + width - 1] +
-                    gray[i + width + 1];
-                const gy = -gray[i - width - 1] -
-                    2 * gray[i - width] -
-                    gray[i - width + 1] +
-                    gray[i + width - 1] +
-                    2 * gray[i + width] +
-                    gray[i + width + 1];
-                out[i] = Math.hypot(gx, gy) / 4;
-            }
-        return out;
-    }
 }

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

@@ -0,0 +1,44 @@
+export class PsScanMorphologyService {
+    static close(mask, width, height, radius) {
+        return PsScanMorphologyService.erode(PsScanMorphologyService.dilate(mask, width, height, radius), width, height, radius);
+    }
+    static dilate(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 1), width, height, radius, 1);
+    }
+    static erode(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 0), width, height, radius, 0);
+    }
+    static horizontal(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const from = Math.max(0, x - radius);
+                const to = Math.min(width - 1, x + radius);
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[y * width + at] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        return out;
+    }
+    static vertical(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1) {
+            const from = Math.max(0, y - radius);
+            const to = Math.min(height - 1, y + radius);
+            for (let x = 0; x < width; x += 1) {
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[at * width + x] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        }
+        return out;
+    }
+}

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

@@ -1,36 +1,26 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
 import { PsScanCanvasService } from './ps-scan-canvas-service';
 import { PsScanEdgeService } from './ps-scan-edge-service';
-import { PsScanEnhanceService } from './ps-scan-enhance-service';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
-import { PsScanRasterService } from './ps-scan-raster-service';
 import { PsScanWarpService } from './ps-scan-warp-service';
 export class PsScanPipelineService {
     static async prepare(source) {
         const decoded = await PsScanCanvasService.decode(source, PsScanConfig.detectMaxDimension * 2);
-        const detected = PsScanEdgeService.detect(decoded.raster);
+        const located = await PsScanEdgeService.locate(decoded.raster, PsScanConfig.detectMaxDimension);
         return {
-            corners: detected === null ? PsScanGeometryService.defaultQuad() : detected,
+            corners: located.quad,
             height: decoded.naturalHeight,
-            isDetected: detected !== null,
+            isDetected: located.isDetected,
             width: decoded.naturalWidth,
         };
     }
-    static async measure(source) {
-        const decoded = await PsScanCanvasService.decode(source, PsScanConfig.previewMaxDimension);
-        return decoded.raster;
-    }
-    static process(page, raster, maxDimension) {
-        const size = PsScanGeometryService.fitWithin(PsScanGeometryService.outputSize(page.corners, raster), maxDimension);
-        const warped = PsScanWarpService.warp(raster, PsScanGeometryService.toPixels(page.corners, {
-            height: raster.height - 1,
-            width: raster.width - 1,
+    static async render(source, corners, maxDimension, quality) {
+        const decoded = await PsScanCanvasService.decode(source, Number.MAX_SAFE_INTEGER);
+        const size = PsScanGeometryService.fitWithin(PsScanGeometryService.outputSize(corners, decoded.raster), maxDimension);
+        const raster = await PsScanWarpService.warp(decoded.raster, PsScanGeometryService.toPixels(corners, {
+            height: decoded.raster.height - 1,
+            width: decoded.raster.width - 1,
         }), size.width, size.height);
-        return PsScanRasterService.rotate(PsScanEnhanceService.apply(warped, page.filter), page.rotation);
-    }
-    static async render(page, maxDimension, quality) {
-        const decoded = await PsScanCanvasService.decode(page.source, PsScanConfig.decodeMaxDimension);
-        const raster = PsScanPipelineService.process(page, decoded.raster, maxDimension);
         return {
             blob: await PsScanCanvasService.encode(raster, quality),
             height: raster.height,

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-polygon-service.js

@@ -0,0 +1,75 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanPolygonService {
+    static perimeter(points) {
+        return points.reduce((sum, point, index) => sum + PsScanGeometryService.distance(point, points[(index + 1) % points.length]), 0);
+    }
+    static simplify(points, epsilon) {
+        if (points.length < 4)
+            return points;
+        let first = 0;
+        let second = 0;
+        let best = -1;
+        points.forEach((point, index) => {
+            const length = PsScanGeometryService.distance(points[0], point);
+            if (length > best) {
+                best = length;
+                second = index;
+            }
+        });
+        best = -1;
+        points.forEach((point, index) => {
+            const length = PsScanGeometryService.distance(points[second], point);
+            if (length > best) {
+                best = length;
+                first = index;
+            }
+        });
+        const low = Math.min(first, second);
+        const high = Math.max(first, second);
+        const forward = points.slice(low, high + 1);
+        const backward = [...points.slice(high), ...points.slice(0, low + 1)];
+        const left = PsScanPolygonService.chain(forward, epsilon);
+        const right = PsScanPolygonService.chain(backward, epsilon);
+        return [...left.slice(0, -1), ...right.slice(0, -1)];
+    }
+    static toQuad(hull) {
+        const perimeter = PsScanPolygonService.perimeter(hull);
+        for (const ratio of PsScanConfig.polygonEpsilons) {
+            const simple = PsScanPolygonService.simplify(hull, ratio * perimeter);
+            if (simple.length === 4)
+                return simple;
+            if (simple.length < 4)
+                return null;
+        }
+        return null;
+    }
+    static chain(points, epsilon) {
+        if (points.length < 3)
+            return points;
+        const start = points[0];
+        const end = points[points.length - 1];
+        let far = 0;
+        let farDistance = -1;
+        for (let index = 1; index < points.length - 1; index += 1) {
+            const length = PsScanPolygonService.lineDistance(points[index], start, end);
+            if (length > farDistance) {
+                farDistance = length;
+                far = index;
+            }
+        }
+        if (farDistance <= epsilon)
+            return [start, end];
+        const left = PsScanPolygonService.chain(points.slice(0, far + 1), epsilon);
+        const right = PsScanPolygonService.chain(points.slice(far), epsilon);
+        return [...left.slice(0, -1), ...right];
+    }
+    static lineDistance(point, from, to) {
+        const dx = to.x - from.x;
+        const dy = to.y - from.y;
+        const length = Math.hypot(dx, dy);
+        if (length === 0)
+            return PsScanGeometryService.distance(point, from);
+        return Math.abs(dy * (point.x - from.x) - dx * (point.y - from.y)) / length;
+    }
+}

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

@@ -0,0 +1,52 @@
+export class PsScanRegionService {
+    static enclosed(mask, width, height, minArea) {
+        const seen = new Uint8Array(mask.length);
+        const regions = [];
+        for (let start = 0; start < mask.length; start += 1) {
+            if (mask[start] === 1 || seen[start] === 1)
+                continue;
+            const boundary = [];
+            const stack = [start];
+            let area = 0;
+            seen[start] = 1;
+            while (stack.length > 0) {
+                const index = stack.pop();
+                if (index === undefined)
+                    break;
+                const x = index % width;
+                const y = (index - x) / width;
+                let isBoundary = false;
+                area += 1;
+                const visit = (next) => {
+                    if (mask[next] === 1)
+                        isBoundary = true;
+                    else if (seen[next] === 0) {
+                        seen[next] = 1;
+                        stack.push(next);
+                    }
+                };
+                if (x > 0)
+                    visit(index - 1);
+                else
+                    isBoundary = true;
+                if (x < width - 1)
+                    visit(index + 1);
+                else
+                    isBoundary = true;
+                if (y > 0)
+                    visit(index - width);
+                else
+                    isBoundary = true;
+                if (y < height - 1)
+                    visit(index + width);
+                else
+                    isBoundary = true;
+                if (isBoundary)
+                    boundary.push({ x, y });
+            }
+            if (area >= minArea)
+                regions.push({ area, boundary });
+        }
+        return regions;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanStabilityService {
+    static initial() {
+        return { misses: 0, quad: null };
+    }
+    static movement(from, to) {
+        return Math.max(...from.map((point, index) => PsScanGeometryService.distance(point, to[index])));
+    }
+    static next(state, detected) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > PsScanConfig.liveMissLimit
+                ? { misses, quad: null }
+                : { misses, quad: state.quad };
+        }
+        if (state.quad === null)
+            return { misses: 0, quad: detected };
+        if (PsScanStabilityService.movement(state.quad, detected) < PsScanConfig.liveDeadzone)
+            return { misses: 0, quad: state.quad };
+        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 { misses: 0, quad };
+    }
+}

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

@@ -1,16 +1,22 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
 import { PsScanHomographyService } from './ps-scan-homography-service';
 import { PsScanRasterService } from './ps-scan-raster-service';
+import { PsScanYieldService } from './ps-scan-yield-service';
 export class PsScanWarpService {
-    static warp(source, pixelQuad, width, height) {
+    static async warp(source, pixelQuad, width, height) {
         const matrix = PsScanHomographyService.fromUnitSquare(pixelQuad);
         const target = PsScanRasterService.create(width, height);
         const spanX = Math.max(1, width - 1);
         const spanY = Math.max(1, height - 1);
-        for (let y = 0; y < height; y += 1)
+        const rowsPerChunk = Math.max(1, Math.floor(PsScanConfig.warpChunkPixels / width));
+        for (let y = 0; y < height; y += 1) {
             for (let x = 0; x < width; x += 1) {
                 const point = PsScanHomographyService.apply(matrix, x / spanX, y / spanY);
                 PsScanWarpService.sample(source, point.x, point.y, target.data, (y * width + x) * 4);
             }
+            if ((y + 1) % rowsPerChunk === 0)
+                await PsScanYieldService.next();
+        }
         return target;
     }
     static sample(source, x, y, out, at) {

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

@@ -0,0 +1,5 @@
+export class PsScanYieldService {
+    static async next() {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+}

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) => PsScanLiveDetection;

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

@@ -0,0 +1,45 @@
+"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) => {
+    const [detection, setDetection] = (0, react_1.useState)({ quad: null });
+    (0, react_1.useEffect)(() => {
+        if (!isActive) {
+            setDetection({ quad: null });
+            return;
+        }
+        let isCancelled = false;
+        let state = ps_scan_stability_service_1.PsScanStabilityService.initial();
+        let timer;
+        const tick = async () => {
+            const video = videoRef.current;
+            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);
+                    const quad = await ps_scan_edge_service_1.PsScanEdgeService.detect(raster, ps_scan_config_1.PsScanConfig.liveDetectMaxDimension);
+                    if (isCancelled)
+                        return;
+                    state = ps_scan_stability_service_1.PsScanStabilityService.next(state, quad);
+                }
+                catch {
+                    state = ps_scan_stability_service_1.PsScanStabilityService.initial();
+                }
+                setDetection((current) => (current.quad === state.quad ? current : { quad: state.quad }));
+            }
+            if (!isCancelled)
+                timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+        };
+        timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+        return () => {
+            isCancelled = true;
+            clearTimeout(timer);
+        };
+    }, [isActive]);
+    return detection;
+};
+exports.usePsScanLiveDetection = usePsScanLiveDetection;

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

@@ -0,0 +1,9 @@
+import type { PsScanPhoto } from '../models/ps-scan-photo';
+import type { PsScanQuad } from '../models/ps-scan-quad';
+export declare const usePsScanPhoto: () => {
+    clear: () => void;
+    detectAgain: () => Promise<boolean>;
+    load: (source: Blob) => Promise<PsScanPhoto>;
+    photo: PsScanPhoto | null;
+    setCorners: (corners: PsScanQuad) => void;
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanPhoto = void 0;
+const react_1 = require("react");
+const ps_scan_pipeline_service_1 = require("../services/ps-scan-pipeline-service");
+const usePsScanPhoto = () => {
+    const [photo, setPhoto] = (0, react_1.useState)(null);
+    const url = (0, react_1.useRef)('');
+    const release = (0, react_1.useCallback)(() => {
+        if (url.current !== '')
+            URL.revokeObjectURL(url.current);
+        url.current = '';
+    }, []);
+    (0, react_1.useEffect)(() => release, [release]);
+    const load = (0, react_1.useCallback)(async (source) => {
+        const prepared = await ps_scan_pipeline_service_1.PsScanPipelineService.prepare(source);
+        const next = {
+            corners: prepared.corners,
+            height: prepared.height,
+            isDetected: prepared.isDetected,
+            source,
+            sourceUrl: URL.createObjectURL(source),
+            width: prepared.width,
+        };
+        release();
+        url.current = next.sourceUrl;
+        setPhoto(next);
+        return next;
+    }, [release]);
+    const setCorners = (0, react_1.useCallback)((corners) => setPhoto((current) => (current === null ? current : { ...current, corners })), []);
+    const detectAgain = (0, react_1.useCallback)(async () => {
+        if (photo === null)
+            return false;
+        const prepared = await ps_scan_pipeline_service_1.PsScanPipelineService.prepare(photo.source);
+        setPhoto((current) => current === null
+            ? current
+            : { ...current, corners: prepared.corners, isDetected: prepared.isDetected });
+        return prepared.isDetected;
+    }, [photo]);
+    const clear = (0, react_1.useCallback)(() => {
+        release();
+        setPhoto(null);
+    }, [release]);
+    return { clear, detectAgain, load, photo, setCorners };
+};
+exports.usePsScanPhoto = usePsScanPhoto;

package/dist/index.d.ts

@@ -71,6 +71,5 @@ export * from './hooks/use-ps-in-view';
 export * from './hooks/use-ps-upload-queue';
 export * from './components/ps-document-scanner';
 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

@@ -87,6 +87,5 @@ __exportStar(require("./hooks/use-ps-in-view"), exports);
 __exportStar(require("./hooks/use-ps-upload-queue"), exports);
 __exportStar(require("./components/ps-document-scanner"), exports);
 __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

@@ -1,5 +1,4 @@
 import type { PsDocumentScannerLabels } from '../constants/ps-document-scanner-labels';
-import type { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerProps {
     className?: string;
@@ -8,8 +7,6 @@ export interface PsDocumentScannerProps {
     jpegQuality?: number;
     labels?: Partial<PsLabelSet<typeof PsDocumentScannerLabels>>;
     maxDimension?: number;
-    maxPages?: number;
     onClose: () => void;
     onComplete: (files: File[]) => void;
-    outputFormat?: PsScanOutputFormat;
 }

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

@@ -1,13 +1,10 @@
 import type { PsDocumentScannerLabels } from '../constants/ps-document-scanner-labels';
-import type { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerSheetProps {
     fileName: string;
     jpegQuality: number;
     labels: PsLabelSet<typeof PsDocumentScannerLabels>;
     maxDimension: number;
-    maxPages: number;
     onClose: () => void;
     onComplete: (files: File[]) => void;
-    outputFormat: PsScanOutputFormat;
 }

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-scan-gradient.d.ts

@@ -0,0 +1,4 @@
+export interface PsScanGradient {
+    direction: Uint8Array;
+    magnitude: Float32Array;
+}