@pallasoft/ps-file-components 2.0.0 → 2.1.0

package/dist/esm/models/ps-drag-pan-handlers.js

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

package/dist/esm/models/ps-drag-pan-options.js

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

package/dist/esm/models/ps-scan-detect-profile.js

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

package/dist/esm/models/ps-scan-multi-page.js

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

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

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

package/dist/esm/models/ps-scan-pdf-page.js

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

package/dist/esm/services/ps-pan-service.js

@@ -0,0 +1,13 @@
+export class PsPanService {
+    static translate(offset) {
+        return `translate(${offset.x}px, ${offset.y}px)`;
+    }
+    static add(offset, delta) {
+        return { x: offset.x + delta.x, y: offset.y + delta.y };
+    }
+    static isOnScrollbar(element, clientX, clientY) {
+        const box = element.getBoundingClientRect();
+        return ((element.clientWidth > 0 && clientX - box.left > element.clientWidth) ||
+            (element.clientHeight > 0 && clientY - box.top > element.clientHeight));
+    }
+}

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

@@ -1,4 +1,5 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanDetectProfiles } from '../constants/ps-scan-detect-profiles';
 import { PsScanCannyService } from './ps-scan-canny-service';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
 import { PsScanHullService } from './ps-scan-hull-service';
@@ -9,13 +10,14 @@ import { PsScanRasterService } from './ps-scan-raster-service';
 import { PsScanRegionService } from './ps-scan-region-service';
 import { PsScanYieldService } from './ps-scan-yield-service';
 export class PsScanEdgeService {
-    static async detect(source, maxDimension) {
+    static async detect(source, maxDimension, profile = PsScanDetectProfiles.full) {
         const scale = Math.min(1, maxDimension / Math.max(source.width, source.height));
         const width = Math.max(16, Math.round(source.width * scale));
         const height = Math.max(16, Math.round(source.height * scale));
         const raster = PsScanRasterService.resize(source, width, height);
         const gray = PsScanImageFilterService.blur(PsScanImageFilterService.grayscale(raster), width, height);
-        await PsScanYieldService.next();
+        if (profile.isYielding)
+            await PsScanYieldService.next();
         const edges = PsScanCannyService.edges(gray, width, height);
         for (let index = 0; index < width; index += 1) {
             edges[index] = 1;
@@ -27,8 +29,9 @@ export class PsScanEdgeService {
         }
         let best = null;
         let bestArea = 0;
-        for (const radius of PsScanConfig.closeRadii) {
-            await PsScanYieldService.next();
+        for (const radius of profile.closeRadii) {
+            if (profile.isYielding)
+                await PsScanYieldService.next();
             const closed = PsScanMorphologyService.close(edges, width, height, radius);
             const regions = PsScanRegionService.enclosed(closed, width, height, width * height * PsScanConfig.detectMinAreaRatio * 0.5);
             for (const region of regions) {

package/dist/esm/services/ps-scan-file-name-service.js

@@ -3,6 +3,9 @@ export class PsScanFileNameService {
     static build(base) {
         return `${PsScanFileNameService.sanitize(base)}.jpg`;
     }
+    static buildPdf(base) {
+        return `${PsScanFileNameService.sanitize(base)}.pdf`;
+    }
     static sanitize(base) {
         const cleaned = Array.from(base)
             .filter((char) => char.charCodeAt(0) >= 32)

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

@@ -0,0 +1,10 @@
+export class PsScanFrameService {
+    static schedule(video, callback) {
+        if (video !== null && typeof video.requestVideoFrameCallback === 'function') {
+            const videoHandle = video.requestVideoFrameCallback(() => callback());
+            return () => video.cancelVideoFrameCallback(videoHandle);
+        }
+        const frameHandle = requestAnimationFrame(() => callback());
+        return () => cancelAnimationFrame(frameHandle);
+    }
+}

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

@@ -0,0 +1,69 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanPdfService {
+    static async build(pages) {
+        const loaded = [];
+        for (const page of pages)
+            loaded.push({
+                bytes: new Uint8Array(await page.blob.arrayBuffer()),
+                height: page.height,
+                width: page.width,
+            });
+        return PsScanPdfService.fromJpegs(loaded);
+    }
+    static fromJpegs(pages) {
+        const chunks = [];
+        const offsets = [];
+        let length = 0;
+        const push = (chunk) => {
+            chunks.push(chunk);
+            length += chunk.length;
+        };
+        const begin = (objectNumber) => {
+            offsets[objectNumber] = length;
+            push(PsScanPdfService.text(`${objectNumber} 0 obj\n`));
+        };
+        push(PsScanPdfService.text('%PDF-1.4\n'));
+        push(new Uint8Array([0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a]));
+        begin(1);
+        push(PsScanPdfService.text('<< /Type /Catalog /Pages 2 0 R >>\nendobj\n'));
+        const kids = pages.map((_, index) => `${PsScanPdfService.pageObject(index)} 0 R`).join(' ');
+        begin(2);
+        push(PsScanPdfService.text(`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>\nendobj\n`));
+        pages.forEach((page, index) => {
+            const size = PsScanPdfService.pageSize(page);
+            const pageNumber = PsScanPdfService.pageObject(index);
+            const content = `q ${size.width} 0 0 ${size.height} 0 0 cm /Im0 Do Q`;
+            begin(pageNumber);
+            push(PsScanPdfService.text(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${size.width} ${size.height}] /Resources << /XObject << /Im0 ${pageNumber + 1} 0 R >> >> /Contents ${pageNumber + 2} 0 R >>\nendobj\n`));
+            begin(pageNumber + 1);
+            push(PsScanPdfService.text(`<< /Type /XObject /Subtype /Image /Width ${page.width} /Height ${page.height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${page.bytes.length} >>\nstream\n`));
+            push(page.bytes);
+            push(PsScanPdfService.text('\nendstream\nendobj\n'));
+            begin(pageNumber + 2);
+            push(PsScanPdfService.text(`<< /Length ${content.length} >>\nstream\n${content}\nendstream\nendobj\n`));
+        });
+        const count = 3 + pages.length * 3;
+        const entries = Array.from({ length: count - 1 }, (_, index) => `${String(offsets[index + 1]).padStart(10, '0')} 00000 n \n`).join('');
+        push(PsScanPdfService.text(`xref\n0 ${count}\n0000000000 65535 f \n${entries}trailer\n<< /Size ${count} /Root 1 0 R >>\nstartxref\n${length}\n%%EOF\n`));
+        const merged = new Uint8Array(length);
+        let cursor = 0;
+        for (const chunk of chunks) {
+            merged.set(chunk, cursor);
+            cursor += chunk.length;
+        }
+        return new Blob([merged], { type: 'application/pdf' });
+    }
+    static pageSize(page) {
+        const scale = PsScanConfig.pdfLongEdgePoints / Math.max(page.width, page.height);
+        return {
+            height: Math.round(page.height * scale * 100) / 100,
+            width: Math.round(page.width * scale * 100) / 100,
+        };
+    }
+    static pageObject(index) {
+        return 3 + index * 3;
+    }
+    static text(value) {
+        return new TextEncoder().encode(value);
+    }
+}

package/dist/esm/services/ps-scan-quad-tween-service.js

@@ -0,0 +1,10 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanQuadTweenService {
+    static step(current, target, elapsedMs) {
+        const weight = 1 - Math.exp(-Math.max(0, elapsedMs) / PsScanConfig.liveTweenMs);
+        return current.map((point, index) => ({
+            x: point.x + (target[index].x - point.x) * weight,
+            y: point.y + (target[index].y - point.y) * weight,
+        }));
+    }
+}

package/dist/hooks/use-ps-drag-pan.d.ts

@@ -0,0 +1,3 @@
+import type { PsDragPanHandlers } from '../models/ps-drag-pan-handlers';
+import type { PsDragPanOptions } from '../models/ps-drag-pan-options';
+export declare const usePsDragPan: ({ activationDistance, isEnabled, isMouseOnly, onEnd, onMove, onStart, }: PsDragPanOptions) => PsDragPanHandlers;

package/dist/hooks/use-ps-drag-pan.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsDragPan = void 0;
+const react_1 = require("react");
+const ps_pan_service_1 = require("../services/ps-pan-service");
+const usePsDragPan = ({ activationDistance, isEnabled, isMouseOnly, onEnd, onMove, onStart, }) => {
+    const origin = (0, react_1.useRef)(null);
+    const pointerId = (0, react_1.useRef)(-1);
+    const isActive = (0, react_1.useRef)(false);
+    const last = (0, react_1.useRef)({ x: 0, y: 0 });
+    const activate = (element) => {
+        isActive.current = true;
+        last.current = { x: 0, y: 0 };
+        if (typeof element.setPointerCapture === 'function')
+            element.setPointerCapture(pointerId.current);
+        element.style.userSelect = 'none';
+        window.getSelection()?.removeAllRanges();
+        onStart(element);
+    };
+    const finish = (element) => {
+        if (origin.current === null)
+            return;
+        const wasActive = isActive.current;
+        origin.current = null;
+        isActive.current = false;
+        element.style.userSelect = '';
+        if (wasActive)
+            onEnd(last.current);
+    };
+    const onPointerDown = (event) => {
+        if (!isEnabled || origin.current !== null)
+            return;
+        if (isMouseOnly && event.pointerType === 'touch')
+            return;
+        if (event.pointerType === 'mouse' && event.button !== 0)
+            return;
+        if (ps_pan_service_1.PsPanService.isOnScrollbar(event.currentTarget, event.clientX, event.clientY))
+            return;
+        origin.current = { x: event.clientX, y: event.clientY };
+        pointerId.current = event.pointerId;
+        isActive.current = false;
+        if (activationDistance <= 0)
+            activate(event.currentTarget);
+    };
+    const onPointerMove = (event) => {
+        if (origin.current === null || event.pointerId !== pointerId.current)
+            return;
+        const delta = { x: event.clientX - origin.current.x, y: event.clientY - origin.current.y };
+        if (!isActive.current) {
+            if (Math.hypot(delta.x, delta.y) < activationDistance)
+                return;
+            activate(event.currentTarget);
+        }
+        last.current = delta;
+        onMove(delta);
+    };
+    const onPointerEnd = (event) => {
+        if (event.pointerId !== pointerId.current)
+            return;
+        finish(event.currentTarget);
+    };
+    return {
+        onLostPointerCapture: onPointerEnd,
+        onPointerCancel: onPointerEnd,
+        onPointerDown,
+        onPointerMove,
+        onPointerUp: onPointerEnd,
+    };
+};
+exports.usePsDragPan = usePsDragPan;

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

@@ -3,43 +3,68 @@ 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_detect_profiles_1 = require("../constants/ps-scan-detect-profiles");
 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_frame_service_1 = require("../services/ps-scan-frame-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 });
+    const [hasQuad, setHasQuad] = (0, react_1.useState)(false);
+    const quadRef = (0, react_1.useRef)(null);
     (0, react_1.useEffect)(() => {
+        quadRef.current = null;
         if (!isActive) {
-            setDetection({ quad: null });
+            setHasQuad(false);
             return;
         }
         let isCancelled = false;
+        let isRunning = false;
+        let lastStart = 0;
         let state = ps_scan_stability_service_1.PsScanStabilityService.initial();
-        let timer;
-        const tick = async () => {
+        let cancelNext = () => undefined;
+        const schedule = () => {
+            if (!isCancelled)
+                cancelNext = ps_scan_frame_service_1.PsScanFrameService.schedule(videoRef.current, run);
+        };
+        const run = 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 }));
+            const now = performance.now();
+            if (isRunning ||
+                video === null ||
+                video.videoWidth === 0 ||
+                document.visibilityState !== 'visible' ||
+                now - lastStart < ps_scan_config_1.PsScanConfig.liveDetectMinIntervalMs) {
+                schedule();
+                return;
             }
-            if (!isCancelled)
-                timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+            isRunning = true;
+            lastStart = now;
+            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, ps_scan_detect_profiles_1.PsScanDetectProfiles.live);
+                if (isCancelled)
+                    return;
+                state = ps_scan_stability_service_1.PsScanStabilityService.next(state, quad);
+            }
+            catch {
+                state = ps_scan_stability_service_1.PsScanStabilityService.initial();
+            }
+            finally {
+                isRunning = false;
+            }
+            if (isCancelled)
+                return;
+            quadRef.current = state.quad;
+            setHasQuad(state.quad !== null);
+            schedule();
         };
-        timer = setTimeout(tick, ps_scan_config_1.PsScanConfig.liveDetectIntervalMs);
+        schedule();
         return () => {
             isCancelled = true;
-            clearTimeout(timer);
+            cancelNext();
+            quadRef.current = null;
         };
     }, [isActive]);
-    return detection;
+    return { hasQuad, quadRef };
 };
 exports.usePsScanLiveDetection = usePsScanLiveDetection;

package/dist/hooks/use-ps-scan-quad-tween.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from 'react';
+import type { PsScanQuad } from '../models/ps-scan-quad';
+export declare const usePsScanQuadTween: (quadRef: RefObject<PsScanQuad | null>, format: (quad: PsScanQuad) => string) => RefObject<SVGPolygonElement>;

package/dist/hooks/use-ps-scan-quad-tween.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanQuadTween = void 0;
+const react_1 = require("react");
+const ps_scan_quad_tween_service_1 = require("../services/ps-scan-quad-tween-service");
+const usePsScanQuadTween = (quadRef, format) => {
+    const polygon = (0, react_1.useRef)(null);
+    const formatRef = (0, react_1.useRef)(format);
+    formatRef.current = format;
+    (0, react_1.useEffect)(() => {
+        let displayed = null;
+        let lastTime = performance.now();
+        let lastPoints = '';
+        let handle = 0;
+        const frame = (time) => {
+            const target = quadRef.current;
+            const elapsed = time - lastTime;
+            lastTime = time;
+            if (target === null)
+                displayed = null;
+            else
+                displayed =
+                    displayed === null ? target : ps_scan_quad_tween_service_1.PsScanQuadTweenService.step(displayed, target, elapsed);
+            if (displayed !== null && polygon.current !== null) {
+                const points = formatRef.current(displayed);
+                if (points !== lastPoints) {
+                    lastPoints = points;
+                    polygon.current.setAttribute('points', points);
+                }
+            }
+            handle = requestAnimationFrame(frame);
+        };
+        handle = requestAnimationFrame(frame);
+        return () => cancelAnimationFrame(handle);
+    }, [quadRef]);
+    return polygon;
+};
+exports.usePsScanQuadTween = usePsScanQuadTween;

package/dist/index.d.ts

@@ -33,6 +33,8 @@ export * from './constants/ps-upload-messages';
 export * from './constants/ps-upload-queue-config';
 export * from './constants/ps-upload-status-tones';
 export * from './constants/ps-upload-status';
+export * from './models/ps-drag-pan-handlers';
+export * from './models/ps-drag-pan-options';
 export * from './models/ps-file-icon-button-tone';
 export * from './models/ps-file-rejection';
 export * from './models/ps-file-selection-rules';
@@ -66,10 +68,12 @@ export * from './services/ps-text-search-service';
 export * from './services/ps-upload-queue-service';
 export * from './services/ps-xhr-upload-service';
 export * from './hooks/use-ps-active-match-scroll';
+export * from './hooks/use-ps-drag-pan';
 export * from './hooks/use-ps-file-text';
 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 './models/ps-document-scanner-page-labels';
 export * from './models/ps-document-scanner-props';
 export * from './models/ps-file-picker-scan';

package/dist/index.js

@@ -49,6 +49,8 @@ __exportStar(require("./constants/ps-upload-messages"), exports);
 __exportStar(require("./constants/ps-upload-queue-config"), exports);
 __exportStar(require("./constants/ps-upload-status-tones"), exports);
 __exportStar(require("./constants/ps-upload-status"), exports);
+__exportStar(require("./models/ps-drag-pan-handlers"), exports);
+__exportStar(require("./models/ps-drag-pan-options"), exports);
 __exportStar(require("./models/ps-file-icon-button-tone"), exports);
 __exportStar(require("./models/ps-file-rejection"), exports);
 __exportStar(require("./models/ps-file-selection-rules"), exports);
@@ -82,10 +84,12 @@ __exportStar(require("./services/ps-text-search-service"), exports);
 __exportStar(require("./services/ps-upload-queue-service"), exports);
 __exportStar(require("./services/ps-xhr-upload-service"), exports);
 __exportStar(require("./hooks/use-ps-active-match-scroll"), exports);
+__exportStar(require("./hooks/use-ps-drag-pan"), exports);
 __exportStar(require("./hooks/use-ps-file-text"), exports);
 __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("./models/ps-document-scanner-page-labels"), exports);
 __exportStar(require("./models/ps-document-scanner-props"), exports);
 __exportStar(require("./models/ps-file-picker-scan"), exports);

package/dist/models/ps-document-scanner-page-labels.d.ts

@@ -0,0 +1,6 @@
+export interface PsDocumentScannerPageLabels {
+    addPage: string;
+    pageCount: string;
+    pageLabel: string;
+    removePage: string;
+}

package/dist/models/ps-document-scanner-page-labels.js

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

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

@@ -1,12 +1,15 @@
 import type { PsDocumentScannerLabels } from '../constants/ps-document-scanner-labels';
+import type { PsDocumentScannerPageLabels } from './ps-document-scanner-page-labels';
 import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerProps {
     className?: string;
     fileName?: string;
+    isMultiPage?: boolean;
     isOpen: boolean;
     jpegQuality?: number;
     labels?: Partial<PsLabelSet<typeof PsDocumentScannerLabels>>;
     maxDimension?: number;
+    pageLabels?: PsDocumentScannerPageLabels;
     onClose: () => void;
     onComplete: (files: File[]) => void;
 }

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

@@ -1,10 +1,12 @@
 import type { PsDocumentScannerLabels } from '../constants/ps-document-scanner-labels';
+import type { PsDocumentScannerPageLabels } from './ps-document-scanner-page-labels';
 import type { PsLabelSet } from './ps-label-set';
 export interface PsDocumentScannerSheetProps {
     fileName: string;
     jpegQuality: number;
     labels: PsLabelSet<typeof PsDocumentScannerLabels>;
     maxDimension: number;
+    pageLabels: PsDocumentScannerPageLabels | null;
     onClose: () => void;
     onComplete: (files: File[]) => void;
 }

package/dist/models/ps-drag-pan-handlers.d.ts

@@ -0,0 +1,8 @@
+import type { PointerEvent } from 'react';
+export interface PsDragPanHandlers {
+    onLostPointerCapture: (event: PointerEvent<HTMLElement>) => void;
+    onPointerCancel: (event: PointerEvent<HTMLElement>) => void;
+    onPointerDown: (event: PointerEvent<HTMLElement>) => void;
+    onPointerMove: (event: PointerEvent<HTMLElement>) => void;
+    onPointerUp: (event: PointerEvent<HTMLElement>) => void;
+}

package/dist/models/ps-drag-pan-handlers.js

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

package/dist/models/ps-drag-pan-options.d.ts

@@ -0,0 +1,9 @@
+import type { PsPoint } from './ps-point';
+export interface PsDragPanOptions {
+    activationDistance: number;
+    isEnabled: boolean;
+    isMouseOnly: boolean;
+    onEnd: (delta: PsPoint) => void;
+    onMove: (delta: PsPoint) => void;
+    onStart: (element: HTMLElement) => void;
+}

package/dist/models/ps-drag-pan-options.js

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

package/dist/models/ps-scan-detect-profile.d.ts

@@ -0,0 +1,4 @@
+export interface PsScanDetectProfile {
+    closeRadii: readonly number[];
+    isYielding: boolean;
+}

package/dist/models/ps-scan-detect-profile.js

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

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

@@ -1,4 +1,6 @@
+import type { RefObject } from 'react';
 import type { PsScanQuad } from './ps-scan-quad';
 export interface PsScanLiveDetection {
-    quad: PsScanQuad | null;
+    hasQuad: boolean;
+    quadRef: RefObject<PsScanQuad | null>;
 }

package/dist/models/ps-scan-multi-page.d.ts

@@ -0,0 +1,9 @@
+import type { PsDocumentScannerPageLabels } from './ps-document-scanner-page-labels';
+import type { PsScanPage } from './ps-scan-page';
+export interface PsScanMultiPage {
+    isBusy: boolean;
+    labels: PsDocumentScannerPageLabels;
+    onAddPage: () => void;
+    onRemovePage: (id: number) => void;
+    pages: PsScanPage[];
+}

package/dist/models/ps-scan-multi-page.js

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

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

@@ -0,0 +1,4 @@
+import type { PsScanResult } from './ps-scan-result';
+export interface PsScanPage extends PsScanResult {
+    id: number;
+}

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

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

package/dist/models/ps-scan-pdf-page.d.ts

@@ -0,0 +1,5 @@
+export interface PsScanPdfPage {
+    bytes: Uint8Array;
+    height: number;
+    width: number;
+}

package/dist/models/ps-scan-pdf-page.js

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

package/dist/services/ps-pan-service.d.ts

@@ -0,0 +1,6 @@
+import type { PsPoint } from '../models/ps-point';
+export declare class PsPanService {
+    static translate(offset: PsPoint): string;
+    static add(offset: PsPoint, delta: PsPoint): PsPoint;
+    static isOnScrollbar(element: HTMLElement, clientX: number, clientY: number): boolean;
+}

package/dist/services/ps-pan-service.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsPanService = void 0;
+class PsPanService {
+    static translate(offset) {
+        return `translate(${offset.x}px, ${offset.y}px)`;
+    }
+    static add(offset, delta) {
+        return { x: offset.x + delta.x, y: offset.y + delta.y };
+    }
+    static isOnScrollbar(element, clientX, clientY) {
+        const box = element.getBoundingClientRect();
+        return ((element.clientWidth > 0 && clientX - box.left > element.clientWidth) ||
+            (element.clientHeight > 0 && clientY - box.top > element.clientHeight));
+    }
+}
+exports.PsPanService = PsPanService;

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

@@ -1,8 +1,9 @@
+import type { PsScanDetectProfile } from '../models/ps-scan-detect-profile';
 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, maxDimension: number): Promise<PsScanQuad | null>;
+    static detect(source: PsScanRaster, maxDimension: number, profile?: PsScanDetectProfile): Promise<PsScanQuad | null>;
     static locate(source: PsScanRaster, maxDimension: number): Promise<PsScanLocated>;
     private static candidate;
     private static normalise;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanEdgeService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_detect_profiles_1 = require("../constants/ps-scan-detect-profiles");
 const ps_scan_canny_service_1 = require("./ps-scan-canny-service");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 const ps_scan_hull_service_1 = require("./ps-scan-hull-service");
@@ -12,13 +13,14 @@ const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
 const ps_scan_region_service_1 = require("./ps-scan-region-service");
 const ps_scan_yield_service_1 = require("./ps-scan-yield-service");
 class PsScanEdgeService {
-    static async detect(source, maxDimension) {
+    static async detect(source, maxDimension, profile = ps_scan_detect_profiles_1.PsScanDetectProfiles.full) {
         const scale = Math.min(1, maxDimension / Math.max(source.width, source.height));
         const width = Math.max(16, Math.round(source.width * scale));
         const height = Math.max(16, Math.round(source.height * scale));
         const raster = ps_scan_raster_service_1.PsScanRasterService.resize(source, width, height);
         const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.blur(ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(raster), width, height);
-        await ps_scan_yield_service_1.PsScanYieldService.next();
+        if (profile.isYielding)
+            await ps_scan_yield_service_1.PsScanYieldService.next();
         const edges = ps_scan_canny_service_1.PsScanCannyService.edges(gray, width, height);
         for (let index = 0; index < width; index += 1) {
             edges[index] = 1;
@@ -30,8 +32,9 @@ class PsScanEdgeService {
         }
         let best = null;
         let bestArea = 0;
-        for (const radius of ps_scan_config_1.PsScanConfig.closeRadii) {
-            await ps_scan_yield_service_1.PsScanYieldService.next();
+        for (const radius of profile.closeRadii) {
+            if (profile.isYielding)
+                await ps_scan_yield_service_1.PsScanYieldService.next();
             const closed = ps_scan_morphology_service_1.PsScanMorphologyService.close(edges, width, height, radius);
             const regions = ps_scan_region_service_1.PsScanRegionService.enclosed(closed, width, height, width * height * ps_scan_config_1.PsScanConfig.detectMinAreaRatio * 0.5);
             for (const region of regions) {