@pallasoft/ps-file-components 1.5.0 → 2.0.0

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-live-detection.d.ts

@@ -1,3 +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;
+export declare const usePsScanLiveDetection: (videoRef: RefObject<HTMLVideoElement | null>, isActive: boolean) => PsScanLiveDetection;

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

@@ -6,43 +6,39 @@ 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;
+const usePsScanLiveDetection = (videoRef, isActive) => {
+    const [detection, setDetection] = (0, react_1.useState)({ quad: null });
     (0, react_1.useEffect)(() => {
         if (!isActive) {
-            setDetection({ progress: 0, quad: null });
+            setDetection({ quad: null });
             return;
         }
+        let isCancelled = false;
         let state = ps_scan_stability_service_1.PsScanStabilityService.initial();
-        let last = performance.now();
         let timer;
-        const tick = () => {
+        const tick = async () => {
             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);
+                    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();
                 }
-                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();
-                }
+                setDetection((current) => (current.quad === state.quad ? current : { quad: state.quad }));
             }
-            last = now;
-            timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+            if (!isCancelled)
+                timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
         };
         timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
-        return () => clearTimeout(timer);
+        return () => {
+            isCancelled = true;
+            clearTimeout(timer);
+        };
     }, [isActive]);
     return detection;
 };

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,7 +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,7 +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,16 +1,12 @@
 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;
     fileName?: string;
-    isAutoCapture?: boolean;
     isOpen: boolean;
     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,14 +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;
-    isAutoCapture: boolean;
     jpegQuality: number;
     labels: PsLabelSet<typeof PsDocumentScannerLabels>;
     maxDimension: number;
-    maxPages: number;
     onClose: () => void;
     onComplete: (files: File[]) => void;
-    outputFormat: PsScanOutputFormat;
 }

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanLocated {
+    isDetected: boolean;
+    quad: PsScanQuad;
+}

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

@@ -0,0 +1,9 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanPhoto {
+    corners: PsScanQuad;
+    height: number;
+    isDetected: boolean;
+    source: Blob;
+    sourceUrl: string;
+    width: number;
+}

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

@@ -0,0 +1,5 @@
+import type { PsPoint } from './ps-point';
+export interface PsScanRegion {
+    area: number;
+    boundary: PsPoint[];
+}

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

@@ -0,0 +1,6 @@
+export interface PsScanResult {
+    blob: Blob;
+    height: number;
+    url: string;
+    width: number;
+}

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

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

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

@@ -54,8 +54,8 @@ class PsScanCameraService {
             audio: false,
             video: {
                 facingMode: { ideal: 'environment' },
-                height: { ideal: 1440 },
-                width: { ideal: 1920 },
+                height: { ideal: 2160 },
+                width: { ideal: 3840 },
             },
         });
         const track = stream.getVideoTracks()[0];

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

@@ -0,0 +1,7 @@
+export declare class PsScanCannyService {
+    static edges(gray: Uint8ClampedArray, width: number, height: number): Uint8Array;
+    private static gradient;
+    private static highThreshold;
+    private static hysteresis;
+    private static suppress;
+}

package/dist/services/ps-scan-canny-service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanCannyService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+class PsScanCannyService {
+    static edges(gray, width, height) {
+        const gradient = PsScanCannyService.gradient(gray, width, height);
+        const ridges = PsScanCannyService.suppress(gradient, width, height);
+        const high = PsScanCannyService.highThreshold(ridges);
+        return PsScanCannyService.hysteresis(ridges, width, height, high * ps_scan_config_1.PsScanConfig.cannyLowRatio, high);
+    }
+    static gradient(gray, width, height) {
+        const magnitude = new Float32Array(width * height);
+        const direction = new Uint8Array(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];
+                const ax = Math.abs(gx);
+                const ay = Math.abs(gy);
+                magnitude[i] = Math.hypot(gx, gy) / 4;
+                if (ay <= ax * 0.41421356)
+                    direction[i] = 0;
+                else if (ay >= ax * 2.41421356)
+                    direction[i] = 2;
+                else
+                    direction[i] = gx * gy > 0 ? 1 : 3;
+            }
+        return { direction, magnitude };
+    }
+    static highThreshold(ridges) {
+        const values = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] > 0)
+                values.push(ridges[index]);
+        if (values.length === 0)
+            return ps_scan_config_1.PsScanConfig.cannyMinHigh;
+        values.sort((a, b) => a - b);
+        const at = Math.min(values.length - 1, Math.floor(values.length * ps_scan_config_1.PsScanConfig.cannyHighPercentile));
+        return Math.max(ps_scan_config_1.PsScanConfig.cannyMinHigh, values[at]);
+    }
+    static hysteresis(ridges, width, height, low, high) {
+        const out = new Uint8Array(width * height);
+        const stack = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] >= high) {
+                out[index] = 1;
+                stack.push(index);
+            }
+        while (stack.length > 0) {
+            const index = stack.pop();
+            if (index === undefined)
+                break;
+            const x = index % width;
+            const y = (index - x) / width;
+            for (let dy = -1; dy <= 1; dy += 1)
+                for (let dx = -1; dx <= 1; dx += 1) {
+                    const nx = x + dx;
+                    const ny = y + dy;
+                    if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                        continue;
+                    const next = ny * width + nx;
+                    if (out[next] === 0 && ridges[next] >= low) {
+                        out[next] = 1;
+                        stack.push(next);
+                    }
+                }
+        }
+        return out;
+    }
+    static suppress(gradient, width, height) {
+        const { direction, magnitude } = gradient;
+        const out = new Float32Array(width * height);
+        const offsets = [1, width + 1, width, width - 1];
+        for (let y = 1; y < height - 1; y += 1)
+            for (let x = 1; x < width - 1; x += 1) {
+                const i = y * width + x;
+                const offset = offsets[direction[i]];
+                const value = magnitude[i];
+                if (value >= magnitude[i - offset] && value > magnitude[i + offset])
+                    out[i] = value;
+            }
+        return out;
+    }
+}
+exports.PsScanCannyService = PsScanCannyService;

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

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanCanvasService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 class PsScanCanvasService {
     static async decode(blob, maxDimension) {
         const bitmap = await createImageBitmap(blob, { imageOrientation: 'from-image' });
-        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const capped = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const shrink = Math.min(1, Math.sqrt(ps_scan_config_1.PsScanConfig.decodeMaxPixels / (capped.width * capped.height)));
+        const size = {
+            height: Math.max(1, Math.round(capped.height * shrink)),
+            width: Math.max(1, Math.round(capped.width * shrink)),
+        };
         const context = PsScanCanvasService.context(size.width, size.height);
         context.drawImage(bitmap, 0, 0, size.width, size.height);
         const naturalHeight = bitmap.height;

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

@@ -1,9 +1,9 @@
+import type { PsScanLocated } from '../models/ps-scan-located';
 import type { PsScanQuad } from '../models/ps-scan-quad';
 import type { PsScanRaster } from '../models/ps-scan-raster';
 export declare class PsScanEdgeService {
-    static detect(source: PsScanRaster): PsScanQuad | null;
-    private static dilate;
-    private static foreground;
-    private static largestComponent;
-    private static threshold;
+    static detect(source: PsScanRaster, maxDimension: number): Promise<PsScanQuad | null>;
+    static locate(source: PsScanRaster, maxDimension: number): Promise<PsScanLocated>;
+    private static candidate;
+    private static normalise;
 }