@pallasoft/ps-file-components 1.3.0 → 1.5.0

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

@@ -0,0 +1,35 @@
+import { PsScanHomographyService } from './ps-scan-homography-service';
+import { PsScanRasterService } from './ps-scan-raster-service';
+export class PsScanWarpService {
+    static 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)
+            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);
+            }
+        return target;
+    }
+    static sample(source, x, y, out, at) {
+        const cx = Math.min(source.width - 1, Math.max(0, x));
+        const cy = Math.min(source.height - 1, Math.max(0, y));
+        const x0 = Math.floor(cx);
+        const y0 = Math.floor(cy);
+        const x1 = Math.min(source.width - 1, x0 + 1);
+        const y1 = Math.min(source.height - 1, y0 + 1);
+        const fx = cx - x0;
+        const fy = cy - y0;
+        const a = (y0 * source.width + x0) * 4;
+        const b = (y0 * source.width + x1) * 4;
+        const c = (y1 * source.width + x0) * 4;
+        const d = (y1 * source.width + x1) * 4;
+        for (let channel = 0; channel < 4; channel += 1) {
+            const top = source.data[a + channel] * (1 - fx) + source.data[b + channel] * fx;
+            const bottom = source.data[c + channel] * (1 - fx) + source.data[d + channel] * fx;
+            out[at + channel] = top * (1 - fy) + bottom * fy;
+        }
+    }
+}

package/dist/hooks/use-ps-focus-trap.d.ts

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare const usePsFocusTrap: (ref: RefObject<HTMLElement | null>, isActive: boolean, onEscape: () => void) => void;

package/dist/hooks/use-ps-focus-trap.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsFocusTrap = void 0;
+const react_1 = require("react");
+const usePsFocusTrap = (ref, isActive, onEscape) => {
+    (0, react_1.useEffect)(() => {
+        if (!isActive || ref.current === null)
+            return;
+        const dialog = ref.current.closest('[role="dialog"]');
+        const root = dialog === null ? ref.current : dialog;
+        const focusable = () => Array.from(root.querySelectorAll('button:not([disabled]), [href], input:not([disabled]), [tabindex]:not([tabindex="-1"])')).filter((element) => element.offsetParent !== null || element === document.activeElement);
+        if (!root.contains(document.activeElement)) {
+            root.setAttribute('tabindex', '-1');
+            root.focus({ preventScroll: true });
+        }
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                event.stopPropagation();
+                onEscape();
+                return;
+            }
+            if (event.key !== 'Tab')
+                return;
+            const items = focusable();
+            if (items.length === 0) {
+                event.preventDefault();
+                return;
+            }
+            const first = items[0];
+            const last = items[items.length - 1];
+            const current = document.activeElement;
+            if (!root.contains(current)) {
+                event.preventDefault();
+                first.focus();
+            }
+            else if (event.shiftKey && (current === first || current === root)) {
+                event.preventDefault();
+                last.focus();
+            }
+            else if (!event.shiftKey && current === last) {
+                event.preventDefault();
+                first.focus();
+            }
+        };
+        document.addEventListener('keydown', onKeyDown, true);
+        return () => document.removeEventListener('keydown', onKeyDown, true);
+    }, [isActive, onEscape]);
+};
+exports.usePsFocusTrap = usePsFocusTrap;

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

@@ -0,0 +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").MutableRefObject<HTMLVideoElement | null>;
+};

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanCamera = void 0;
+const react_1 = require("react");
+const ps_scan_camera_status_1 = require("../constants/ps-scan-camera-status");
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_camera_service_1 = require("../services/ps-scan-camera-service");
+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.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)(() => {
+        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);
+        setStatus(ps_scan_camera_status_1.PsScanCameraStatus.Starting);
+        ps_scan_camera_service_1.PsScanCameraService.open()
+            .then(async (session) => {
+            if (isCancelled) {
+                ps_scan_camera_service_1.PsScanCameraService.stop(session.stream);
+                return;
+            }
+            sessionRef.current = session;
+            setCanTorch(session.canTorch);
+            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)
+                setStatus(ps_scan_camera_service_1.PsScanCameraService.classify(error));
+        });
+        return () => {
+            isCancelled = true;
+            ps_scan_camera_service_1.PsScanCameraService.stop(sessionRef.current === null ? null : sessionRef.current.stream);
+            sessionRef.current = null;
+            if (videoRef.current !== null)
+                videoRef.current.srcObject = null;
+        };
+    }, [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)
+            return;
+        setIsTorchOn(await ps_scan_camera_service_1.PsScanCameraService.setTorch(session.track, !isTorchOn));
+    }, [isTorchOn]);
+    const capture = (0, react_1.useCallback)(async () => {
+        const video = videoRef.current;
+        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 {
+        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/hooks/use-ps-scan-pages.d.ts

@@ -0,0 +1,12 @@
+import type { PsScanAddedPage } from '../models/ps-scan-added-page';
+import type { PsScanPage } from '../models/ps-scan-page';
+import type { PsScanQuad } from '../models/ps-scan-quad';
+export declare const usePsScanPages: () => {
+    add: (sources: Blob[]) => Promise<PsScanAddedPage[]>;
+    move: (from: number, to: number) => void;
+    pages: PsScanPage[];
+    remove: (id: string) => void;
+    replace: (id: string, source: Blob) => Promise<PsScanAddedPage>;
+    setCorners: (id: string, corners: PsScanQuad) => void;
+    update: (id: string, patch: Partial<Pick<PsScanPage, "corners" | "filter" | "rotation">>) => void;
+};

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanPages = void 0;
+const react_1 = require("react");
+const ps_scan_filter_1 = require("../constants/ps-scan-filter");
+const ps_scan_order_service_1 = require("../services/ps-scan-order-service");
+const ps_scan_pipeline_service_1 = require("../services/ps-scan-pipeline-service");
+const usePsScanPages = () => {
+    const [pages, setPages] = (0, react_1.useState)([]);
+    const urls = (0, react_1.useRef)(new Set());
+    const counter = (0, react_1.useRef)(0);
+    (0, react_1.useEffect)(() => () => {
+        urls.current.forEach((url) => URL.revokeObjectURL(url));
+        urls.current.clear();
+    }, []);
+    const build = (0, react_1.useCallback)(async (source) => {
+        const prepared = await ps_scan_pipeline_service_1.PsScanPipelineService.prepare(source);
+        const sourceUrl = URL.createObjectURL(source);
+        counter.current += 1;
+        urls.current.add(sourceUrl);
+        return {
+            isDetected: prepared.isDetected,
+            page: {
+                corners: prepared.corners,
+                filter: ps_scan_filter_1.PsScanFilter.Document,
+                height: prepared.height,
+                id: `scan-page-${counter.current}`,
+                rotation: 0,
+                source,
+                sourceUrl,
+                width: prepared.width,
+            },
+        };
+    }, []);
+    const add = (0, react_1.useCallback)(async (sources) => {
+        const built = [];
+        for (const source of sources)
+            built.push(await build(source));
+        setPages((current) => [...current, ...built.map((item) => item.page)]);
+        return built;
+    }, [build]);
+    const replace = (0, react_1.useCallback)(async (id, source) => {
+        const built = await build(source);
+        setPages((current) => current.map((page) => {
+            if (page.id !== id)
+                return page;
+            URL.revokeObjectURL(page.sourceUrl);
+            urls.current.delete(page.sourceUrl);
+            return { ...built.page, filter: page.filter, id: page.id };
+        }));
+        return built;
+    }, [build]);
+    const update = (0, react_1.useCallback)((id, patch) => setPages((current) => current.map((page) => (page.id === id ? { ...page, ...patch } : page))), []);
+    const setCorners = (0, react_1.useCallback)((id, corners) => update(id, { corners }), [update]);
+    const remove = (0, react_1.useCallback)((id) => setPages((current) => {
+        const target = current.find((page) => page.id === id);
+        if (target !== undefined) {
+            URL.revokeObjectURL(target.sourceUrl);
+            urls.current.delete(target.sourceUrl);
+        }
+        return current.filter((page) => page.id !== id);
+    }), []);
+    const move = (0, react_1.useCallback)((from, to) => setPages((current) => ps_scan_order_service_1.PsScanOrderService.move(current, from, to)), []);
+    return { add, move, pages, remove, replace, setCorners, update };
+};
+exports.usePsScanPages = usePsScanPages;

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

@@ -0,0 +1,2 @@
+import type { PsScanPage } from '../models/ps-scan-page';
+export declare const usePsScanPreviews: (pages: PsScanPage[]) => Record<string, string>;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePsScanPreviews = 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_pipeline_service_1 = require("../services/ps-scan-pipeline-service");
+const usePsScanPreviews = (pages) => {
+    const rasters = (0, react_1.useRef)(new Map());
+    const urls = (0, react_1.useRef)(new Map());
+    const [previews, setPreviews] = (0, react_1.useState)({});
+    const signature = pages
+        .map((page) => `${page.id}:${page.filter}:${page.rotation}:${page.corners.map((point) => `${point.x.toFixed(4)},${point.y.toFixed(4)}`).join(';')}`)
+        .join('|');
+    (0, react_1.useEffect)(() => {
+        let isCancelled = false;
+        const timer = setTimeout(async () => {
+            const stale = [];
+            for (const page of pages) {
+                if (isCancelled)
+                    return;
+                let raster = rasters.current.get(page.id);
+                if (raster === undefined) {
+                    raster = await ps_scan_pipeline_service_1.PsScanPipelineService.measure(page.source);
+                    rasters.current.set(page.id, raster);
+                }
+                const processed = ps_scan_pipeline_service_1.PsScanPipelineService.process(page, raster, ps_scan_config_1.PsScanConfig.previewMaxDimension);
+                const blob = await ps_scan_canvas_service_1.PsScanCanvasService.encode(processed, ps_scan_config_1.PsScanConfig.defaultJpegQuality);
+                if (isCancelled)
+                    return;
+                const previous = urls.current.get(page.id);
+                if (previous !== undefined)
+                    stale.push(previous);
+                urls.current.set(page.id, URL.createObjectURL(blob));
+            }
+            if (isCancelled)
+                return;
+            const ids = new Set(pages.map((page) => page.id));
+            urls.current.forEach((url, id) => {
+                if (ids.has(id))
+                    return;
+                stale.push(url);
+                urls.current.delete(id);
+                rasters.current.delete(id);
+            });
+            setPreviews(Object.fromEntries(urls.current));
+            setTimeout(() => stale.forEach((url) => URL.revokeObjectURL(url)), 1000);
+        }, ps_scan_config_1.PsScanConfig.previewDebounceMs);
+        return () => {
+            isCancelled = true;
+            clearTimeout(timer);
+        };
+    }, [signature]);
+    (0, react_1.useEffect)(() => () => {
+        urls.current.forEach((url) => URL.revokeObjectURL(url));
+        urls.current.clear();
+        rasters.current.clear();
+    }, []);
+    return previews;
+};
+exports.usePsScanPreviews = usePsScanPreviews;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './components/ps-file-list';
 export * from './components/ps-file-picker';
 export * from './components/ps-file-viewer-button';
 export * from './components/ps-file-viewer-content';
+export * from './components/ps-file-viewer-pane';
 export * from './components/ps-file-viewer';
 export * from './components/ps-highlighted-text';
 export * from './components/ps-image-viewer';
@@ -39,6 +40,7 @@ export * from './models/ps-file-selection';
 export * from './models/ps-file-text-state';
 export * from './models/ps-file-viewer-button-tone';
 export * from './models/ps-file-viewer-content-props';
+export * from './models/ps-file-viewer-pane-props';
 export * from './models/ps-label-set';
 export * from './models/ps-page-size';
 export * from './models/ps-pdf-match';
@@ -67,3 +69,9 @@ export * from './hooks/use-ps-active-match-scroll';
 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 './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

@@ -21,6 +21,7 @@ __exportStar(require("./components/ps-file-list"), exports);
 __exportStar(require("./components/ps-file-picker"), exports);
 __exportStar(require("./components/ps-file-viewer-button"), exports);
 __exportStar(require("./components/ps-file-viewer-content"), exports);
+__exportStar(require("./components/ps-file-viewer-pane"), exports);
 __exportStar(require("./components/ps-file-viewer"), exports);
 __exportStar(require("./components/ps-highlighted-text"), exports);
 __exportStar(require("./components/ps-image-viewer"), exports);
@@ -55,6 +56,7 @@ __exportStar(require("./models/ps-file-selection"), exports);
 __exportStar(require("./models/ps-file-text-state"), exports);
 __exportStar(require("./models/ps-file-viewer-button-tone"), exports);
 __exportStar(require("./models/ps-file-viewer-content-props"), exports);
+__exportStar(require("./models/ps-file-viewer-pane-props"), exports);
 __exportStar(require("./models/ps-label-set"), exports);
 __exportStar(require("./models/ps-page-size"), exports);
 __exportStar(require("./models/ps-pdf-match"), exports);
@@ -83,3 +85,9 @@ __exportStar(require("./hooks/use-ps-active-match-scroll"), 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("./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

@@ -0,0 +1,16 @@
+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-props.js

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

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

@@ -0,0 +1,14 @@
+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-document-scanner-sheet-props.js

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

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-file-viewer-pane-props.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { PsFileViewerLabels } from '../constants/ps-file-viewer-labels';
+import type { PsLabelSet } from './ps-label-set';
+export interface PsFileViewerPaneProps {
+    contentType: string;
+    headerActions?: ReactNode;
+    id?: string;
+    labels?: PsLabelSet<typeof PsFileViewerLabels>;
+    name: string;
+    pdfWorkerSrc?: string;
+    url: string;
+}

package/dist/models/ps-file-viewer-pane-props.js

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

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

@@ -0,0 +1,5 @@
+import type { PsScanPage } from './ps-scan-page';
+export interface PsScanAddedPage {
+    isDetected: boolean;
+    page: PsScanPage;
+}

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

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

package/dist/models/ps-scan-camera-session.d.ts

@@ -0,0 +1,5 @@
+export interface PsScanCameraSession {
+    canTorch: boolean;
+    stream: MediaStream;
+    track: MediaStreamTrack;
+}

package/dist/models/ps-scan-camera-session.js

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

package/dist/models/ps-scan-decoded-image.d.ts

@@ -0,0 +1,6 @@
+import type { PsScanRaster } from './ps-scan-raster';
+export interface PsScanDecodedImage {
+    naturalHeight: number;
+    naturalWidth: number;
+    raster: PsScanRaster;
+}

package/dist/models/ps-scan-decoded-image.js

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

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

@@ -0,0 +1,4 @@
+export interface PsScanLevels {
+    black: number;
+    white: number;
+}

package/dist/models/ps-scan-levels.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-output-options.d.ts

@@ -0,0 +1,7 @@
+import type { PsScanOutputFormat } from '../constants/ps-scan-output-format';
+export interface PsScanOutputOptions {
+    fileName: string;
+    format: PsScanOutputFormat;
+    jpegQuality: number;
+    maxDimension: number;
+}

package/dist/models/ps-scan-output-options.js

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

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

@@ -0,0 +1,12 @@
+import type { PsScanFilter } from '../constants/ps-scan-filter';
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanPage {
+    corners: PsScanQuad;
+    filter: PsScanFilter;
+    height: number;
+    id: string;
+    rotation: number;
+    source: Blob;
+    sourceUrl: string;
+    width: 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 {
+    height: number;
+    jpeg: Uint8Array;
+    width: number;
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { PsScanQuad } from './ps-scan-quad';
+export interface PsScanPrepared {
+    corners: PsScanQuad;
+    height: number;
+    isDetected: boolean;
+    width: number;
+}

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

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

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

@@ -0,0 +1,2 @@
+import type { PsPoint } from './ps-point';
+export type PsScanQuad = [PsPoint, PsPoint, PsPoint, PsPoint];