@pallasoft/ps-file-components 1.3.0 → 1.4.0

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

@@ -0,0 +1,96 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanGeometryService {
+    static area(points) {
+        let sum = 0;
+        points.forEach((point, index) => {
+            const next = points[(index + 1) % points.length];
+            sum += point.x * next.y - next.x * point.y;
+        });
+        return Math.abs(sum) / 2;
+    }
+    static clamp(point) {
+        return { x: Math.min(1, Math.max(0, point.x)), y: Math.min(1, Math.max(0, point.y)) };
+    }
+    static defaultQuad() {
+        const inset = 0.08;
+        return [
+            { x: inset, y: inset },
+            { x: 1 - inset, y: inset },
+            { x: 1 - inset, y: 1 - inset },
+            { x: inset, y: 1 - inset },
+        ];
+    }
+    static distance(from, to) {
+        return Math.hypot(to.x - from.x, to.y - from.y);
+    }
+    static fit(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.min(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
+    static fitWithin(size, maxDimension) {
+        const longest = Math.max(size.width, size.height);
+        if (longest <= maxDimension)
+            return { height: Math.round(size.height), width: Math.round(size.width) };
+        const scale = maxDimension / longest;
+        return {
+            height: Math.max(1, Math.round(size.height * scale)),
+            width: Math.max(1, Math.round(size.width * scale)),
+        };
+    }
+    static isConvex(points) {
+        let sign = 0;
+        for (let index = 0; index < points.length; index += 1) {
+            const a = points[index];
+            const b = points[(index + 1) % points.length];
+            const c = points[(index + 2) % points.length];
+            const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+            if (Math.abs(cross) < 1e-9)
+                return false;
+            if (sign === 0)
+                sign = Math.sign(cross);
+            else if (Math.sign(cross) !== sign)
+                return false;
+        }
+        return true;
+    }
+    static isUsable(quad) {
+        return (PsScanGeometryService.isConvex(quad) &&
+            PsScanGeometryService.area(quad) > PsScanConfig.minCornerGap * PsScanConfig.minCornerGap);
+    }
+    static nudge(quad, index, dx, dy) {
+        const moved = PsScanGeometryService.clamp({ x: quad[index].x + dx, y: quad[index].y + dy });
+        const next = quad.map((point, at) => (at === index ? moved : point));
+        return PsScanGeometryService.isUsable(next) ? next : quad;
+    }
+    static order(points) {
+        const centre = {
+            x: points.reduce((sum, point) => sum + point.x, 0) / points.length,
+            y: points.reduce((sum, point) => sum + point.y, 0) / points.length,
+        };
+        const sorted = [...points].sort((a, b) => Math.atan2(a.y - centre.y, a.x - centre.x) - Math.atan2(b.y - centre.y, b.x - centre.x));
+        const sums = sorted.map((point) => point.x + point.y);
+        const start = sums.indexOf(Math.min(...sums));
+        return [0, 1, 2, 3].map((offset) => sorted[(start + offset) % 4]);
+    }
+    static outputSize(quad, raster) {
+        const pixels = PsScanGeometryService.toPixels(quad, raster);
+        const width = (PsScanGeometryService.distance(pixels[0], pixels[1]) +
+            PsScanGeometryService.distance(pixels[3], pixels[2])) /
+            2;
+        const height = (PsScanGeometryService.distance(pixels[0], pixels[3]) +
+            PsScanGeometryService.distance(pixels[1], pixels[2])) /
+            2;
+        return { height: Math.max(1, Math.round(height)), width: Math.max(1, Math.round(width)) };
+    }
+    static rotateSize(size, rotation) {
+        return rotation % 180 === 0 ? size : { height: size.width, width: size.height };
+    }
+    static toPixels(quad, size) {
+        return quad.map((point) => ({
+            x: point.x * size.width,
+            y: point.y * size.height,
+        }));
+    }
+}

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

@@ -0,0 +1,46 @@
+export class PsScanHomographyService {
+    static apply(matrix, x, y) {
+        const w = matrix[6] * x + matrix[7] * y + matrix[8];
+        return {
+            x: (matrix[0] * x + matrix[1] * y + matrix[2]) / w,
+            y: (matrix[3] * x + matrix[4] * y + matrix[5]) / w,
+        };
+    }
+    static fromUnitSquare(quad) {
+        const unit = [
+            [0, 0],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+        ];
+        const rows = [];
+        unit.forEach(([u, v], index) => {
+            const { x, y } = quad[index];
+            rows.push([u, v, 1, 0, 0, 0, -u * x, -v * x, x]);
+            rows.push([0, 0, 0, u, v, 1, -u * y, -v * y, y]);
+        });
+        return [...PsScanHomographyService.solve(rows), 1];
+    }
+    static solve(rows) {
+        const size = rows.length;
+        const matrix = rows.map((row) => [...row]);
+        for (let column = 0; column < size; column += 1) {
+            let pivot = column;
+            for (let row = column + 1; row < size; row += 1)
+                if (Math.abs(matrix[row][column]) > Math.abs(matrix[pivot][column]))
+                    pivot = row;
+            [matrix[column], matrix[pivot]] = [matrix[pivot], matrix[column]];
+            const lead = matrix[column][column];
+            if (Math.abs(lead) < 1e-12)
+                return [1, 0, 0, 0, 1, 0, 0, 0];
+            for (let row = 0; row < size; row += 1) {
+                if (row === column)
+                    continue;
+                const factor = matrix[row][column] / lead;
+                for (let at = column; at <= size; at += 1)
+                    matrix[row][at] -= factor * matrix[column][at];
+            }
+        }
+        return matrix.map((row, index) => row[size] / row[index]);
+    }
+}

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

@@ -0,0 +1,59 @@
+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)
+            return points;
+        const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+        const build = (list) => {
+            const chain = [];
+            list.forEach((point) => {
+                while (chain.length >= 2 &&
+                    cross(chain[chain.length - 2], chain[chain.length - 1], point) <= 0)
+                    chain.pop();
+                chain.push(point);
+            });
+            chain.pop();
+            return chain;
+        };
+        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

@@ -0,0 +1,52 @@
+export class PsScanImageFilterService {
+    static blur(gray, width, height) {
+        const kernel = [1, 4, 6, 4, 1];
+        const pass = new Float32Array(width * height);
+        const out = new Uint8ClampedArray(width * height);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += gray[y * width + Math.min(width - 1, Math.max(0, x + k))] * kernel[k + 2];
+                pass[y * width + x] = sum / 16;
+            }
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += pass[Math.min(height - 1, Math.max(0, y + k)) * width + x] * kernel[k + 2];
+                out[y * width + x] = sum / 16;
+            }
+        return out;
+    }
+    static grayscale(raster) {
+        const out = new Uint8ClampedArray(raster.width * raster.height);
+        for (let index = 0; index < out.length; index += 1) {
+            const at = index * 4;
+            out[index] =
+                0.299 * raster.data[at] + 0.587 * raster.data[at + 1] + 0.114 * raster.data[at + 2];
+        }
+        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-order-service.js

@@ -0,0 +1,13 @@
+export class PsScanOrderService {
+    static move(items, from, to) {
+        if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length)
+            return items;
+        const next = [...items];
+        const [item] = next.splice(from, 1);
+        next.splice(to, 0, item);
+        return next;
+    }
+    static step(items, index, direction) {
+        return PsScanOrderService.move(items, index, index + direction);
+    }
+}

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

@@ -0,0 +1,24 @@
+import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
+import { PsScanFileNameService } from './ps-scan-file-name-service';
+import { PsScanPdfService } from './ps-scan-pdf-service';
+import { PsScanPipelineService } from './ps-scan-pipeline-service';
+export class PsScanOutputService {
+    static async build(pages, options) {
+        const rendered = [];
+        for (const page of pages)
+            rendered.push(await PsScanPipelineService.render(page, options.maxDimension, options.jpegQuality));
+        const type = PsScanFileNameService.mimeType(options.format);
+        if (options.format === PsScanOutputFormat.Jpeg)
+            return rendered.map((item, index) => new File([item.blob], PsScanFileNameService.build(options.fileName, options.format, index, rendered.length), { type }));
+        const jpegs = await Promise.all(rendered.map(async (item) => ({
+            height: item.height,
+            jpeg: new Uint8Array(await item.blob.arrayBuffer()),
+            width: item.width,
+        })));
+        return [
+            new File([PsScanPdfService.build(jpegs)], PsScanFileNameService.build(options.fileName, options.format, 0, 1), {
+                type,
+            }),
+        ];
+    }
+}

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

@@ -0,0 +1,56 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanPdfService {
+    static build(pages) {
+        const encoder = new TextEncoder();
+        const chunks = [];
+        const offsets = [];
+        let length = 0;
+        const push = (chunk) => {
+            chunks.push(chunk);
+            length += chunk.length;
+        };
+        const text = (value) => push(encoder.encode(value));
+        const begin = (id) => {
+            offsets[id] = length;
+            text(`${id} 0 obj\n`);
+        };
+        const kids = pages.map((_, index) => `${3 + index * 3} 0 R`).join(' ');
+        push(Uint8Array.from([
+            0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x34, 0x0a, 0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a,
+        ]));
+        begin(1);
+        text('<< /Type /Catalog /Pages 2 0 R >>\nendobj\n');
+        begin(2);
+        text(`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>\nendobj\n`);
+        pages.forEach((page, index) => {
+            const pageId = 3 + index * 3;
+            const widthPt = PsScanPdfService.points(page.width);
+            const heightPt = PsScanPdfService.points(page.height);
+            const content = `q ${widthPt} 0 0 ${heightPt} 0 0 cm /Im0 Do Q`;
+            begin(pageId);
+            text(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${widthPt} ${heightPt}] /Resources << /XObject << /Im0 ${pageId + 2} 0 R >> >> /Contents ${pageId + 1} 0 R >>\nendobj\n`);
+            begin(pageId + 1);
+            text(`<< /Length ${content.length} >>\nstream\n${content}\nendstream\nendobj\n`);
+            begin(pageId + 2);
+            text(`<< /Type /XObject /Subtype /Image /Width ${page.width} /Height ${page.height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${page.jpeg.length} >>\nstream\n`);
+            push(page.jpeg);
+            text('\nendstream\nendobj\n');
+        });
+        const count = 3 + pages.length * 3;
+        const xrefAt = length;
+        text(`xref\n0 ${count}\n0000000000 65535 f \n`);
+        for (let id = 1; id < count; id += 1)
+            text(`${String(offsets[id]).padStart(10, '0')} 00000 n \n`);
+        text(`trailer\n<< /Size ${count} /Root 1 0 R >>\nstartxref\n${xrefAt}\n%%EOF\n`);
+        const out = new Uint8Array(length);
+        let at = 0;
+        chunks.forEach((chunk) => {
+            out.set(chunk, at);
+            at += chunk.length;
+        });
+        return out;
+    }
+    static points(pixels) {
+        return Math.round((pixels * PsScanConfig.pdfPointsPerInch * 100) / PsScanConfig.pdfDpi) / 100;
+    }
+}

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

@@ -0,0 +1,40 @@
+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);
+        return {
+            corners: detected === null ? PsScanGeometryService.defaultQuad() : detected,
+            height: decoded.naturalHeight,
+            isDetected: detected !== null,
+            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,
+        }), 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,
+            width: raster.width,
+        };
+    }
+}

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

@@ -0,0 +1,67 @@
+export class PsScanRasterService {
+    static create(width, height) {
+        return { data: new Uint8ClampedArray(width * height * 4), height, width };
+    }
+    static resize(source, width, height) {
+        if (width === source.width && height === source.height)
+            return source;
+        const target = PsScanRasterService.create(width, height);
+        const scaleX = source.width / width;
+        const scaleY = source.height / height;
+        for (let y = 0; y < height; y += 1) {
+            const y0 = Math.floor(y * scaleY);
+            const y1 = Math.min(source.height, Math.max(y0 + 1, Math.ceil((y + 1) * scaleY)));
+            for (let x = 0; x < width; x += 1) {
+                const x0 = Math.floor(x * scaleX);
+                const x1 = Math.min(source.width, Math.max(x0 + 1, Math.ceil((x + 1) * scaleX)));
+                let r = 0;
+                let g = 0;
+                let b = 0;
+                let a = 0;
+                let count = 0;
+                for (let sy = y0; sy < y1; sy += 1)
+                    for (let sx = x0; sx < x1; sx += 1) {
+                        const at = (sy * source.width + sx) * 4;
+                        r += source.data[at];
+                        g += source.data[at + 1];
+                        b += source.data[at + 2];
+                        a += source.data[at + 3];
+                        count += 1;
+                    }
+                const out = (y * width + x) * 4;
+                target.data[out] = r / count;
+                target.data[out + 1] = g / count;
+                target.data[out + 2] = b / count;
+                target.data[out + 3] = a / count;
+            }
+        }
+        return target;
+    }
+    static rotate(source, degrees) {
+        const turns = ((Math.round(degrees / 90) % 4) + 4) % 4;
+        if (turns === 0)
+            return source;
+        const swapped = turns % 2 === 1;
+        const width = swapped ? source.height : source.width;
+        const height = swapped ? source.width : source.height;
+        const target = PsScanRasterService.create(width, height);
+        for (let y = 0; y < source.height; y += 1)
+            for (let x = 0; x < source.width; x += 1) {
+                let tx = x;
+                let ty = y;
+                if (turns === 1)
+                    [tx, ty] = [source.height - 1 - y, x];
+                else if (turns === 2)
+                    [tx, ty] = [source.width - 1 - x, source.height - 1 - y];
+                else
+                    [tx, ty] = [y, source.width - 1 - x];
+                const from = (y * source.width + x) * 4;
+                const to = (ty * width + tx) * 4;
+                target.data[to] = source.data[from];
+                target.data[to + 1] = source.data[from + 1];
+                target.data[to + 2] = source.data[from + 2];
+                target.data[to + 3] = source.data[from + 3];
+            }
+        return target;
+    }
+}

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

@@ -0,0 +1,5 @@
+export class PsScanTemplateService {
+    static fill(template, values) {
+        return template.replace(/\{(\w+)\}/g, (match, key) => key in values ? String(values[key]) : match);
+    }
+}

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

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

@@ -0,0 +1,66 @@
+"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.Starting);
+    const [canTorch, setCanTorch] = (0, react_1.useState)(false);
+    const [isTorchOn, setIsTorchOn] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        if (!isActive)
+            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) => {
+            if (isCancelled) {
+                ps_scan_camera_service_1.PsScanCameraService.stop(session.stream);
+                return;
+            }
+            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);
+        })
+            .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]);
+    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)
+            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 };
+};
+exports.usePsScanCamera = usePsScanCamera;

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;
+};