@pallasoft/ps-file-components 1.4.0 → 2.0.0

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

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanGeometryService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
 class PsScanGeometryService {
+    static angles(quad) {
+        return quad.map((point, index) => {
+            const before = quad[(index + quad.length - 1) % quad.length];
+            const after = quad[(index + 1) % quad.length];
+            const ax = before.x - point.x;
+            const ay = before.y - point.y;
+            const bx = after.x - point.x;
+            const by = after.y - point.y;
+            const cosine = (ax * bx + ay * by) / (Math.hypot(ax, ay) * Math.hypot(bx, by));
+            return (Math.acos(Math.min(1, Math.max(-1, cosine))) * 180) / Math.PI;
+        });
+    }
     static area(points) {
         let sum = 0;
         points.forEach((point, index) => {
@@ -14,6 +26,12 @@ class PsScanGeometryService {
     static clamp(point) {
         return { x: Math.min(1, Math.max(0, point.x)), y: Math.min(1, Math.max(0, point.y)) };
     }
+    static cover(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.max(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
     static defaultQuad() {
         const inset = 0.08;
         return [
@@ -26,6 +44,30 @@ class PsScanGeometryService {
     static distance(from, to) {
         return Math.hypot(to.x - from.x, to.y - from.y);
     }
+    static expand(quad, distance) {
+        const lines = quad.map((point, index) => {
+            const next = quad[(index + 1) % quad.length];
+            const length = PsScanGeometryService.distance(point, next);
+            const nx = (next.y - point.y) / length;
+            const ny = -(next.x - point.x) / length;
+            return {
+                dx: next.x - point.x,
+                dy: next.y - point.y,
+                x: point.x + nx * distance,
+                y: point.y + ny * distance,
+            };
+        });
+        return quad.map((point, index) => {
+            const previous = lines[(index + lines.length - 1) % lines.length];
+            const current = lines[index];
+            const denominator = previous.dx * current.dy - previous.dy * current.dx;
+            if (Math.abs(denominator) < 1e-9)
+                return point;
+            const t = ((current.x - previous.x) * current.dy - (current.y - previous.y) * current.dx) /
+                denominator;
+            return { x: previous.x + previous.dx * t, y: previous.y + previous.dy * t };
+        });
+    }
     static fit(container, content) {
         if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
             return { height: 0, width: 0 };
@@ -42,6 +84,20 @@ class PsScanGeometryService {
             width: Math.max(1, Math.round(size.width * scale)),
         };
     }
+    static inset(quad, distance) {
+        const centre = {
+            x: quad.reduce((sum, point) => sum + point.x, 0) / quad.length,
+            y: quad.reduce((sum, point) => sum + point.y, 0) / quad.length,
+        };
+        return quad.map((point) => {
+            const length = PsScanGeometryService.distance(point, centre);
+            const ratio = length <= distance ? 0 : (length - distance) / length;
+            return {
+                x: centre.x + (point.x - centre.x) * ratio,
+                y: centre.y + (point.y - centre.y) * ratio,
+            };
+        });
+    }
     static isConvex(points) {
         let sign = 0;
         for (let index = 0; index < points.length; index += 1) {

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

@@ -1,6 +1,4 @@
 import type { PsPoint } from '../models/ps-point';
 export declare class PsScanHullService {
-    static bestQuad(hull: PsPoint[]): PsPoint[];
     static convexHull(input: PsPoint[]): PsPoint[];
-    private static reduce;
 }

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

@@ -1,28 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanHullService = void 0;
-const ps_scan_config_1 = require("../constants/ps-scan-config");
-const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 class PsScanHullService {
-    static bestQuad(hull) {
-        const points = PsScanHullService.reduce(hull, ps_scan_config_1.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 = ps_scan_geometry_service_1.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)
@@ -41,23 +20,5 @@ class PsScanHullService {
         };
         return [...build(points), ...build([...points].reverse())];
     }
-    static reduce(hull, limit) {
-        const points = [...hull];
-        while (points.length > limit) {
-            let weakest = 0;
-            let weakestArea = Infinity;
-            points.forEach((point, index) => {
-                const previous = points[(index - 1 + points.length) % points.length];
-                const next = points[(index + 1) % points.length];
-                const area = ps_scan_geometry_service_1.PsScanGeometryService.area([previous, point, next]);
-                if (area < weakestArea) {
-                    weakestArea = area;
-                    weakest = index;
-                }
-            });
-            points.splice(weakest, 1);
-        }
-        return points;
-    }
 }
 exports.PsScanHullService = PsScanHullService;

package/dist/services/ps-scan-image-filter-service.d.ts

@@ -2,5 +2,4 @@ import type { PsScanRaster } from '../models/ps-scan-raster';
 export declare class PsScanImageFilterService {
     static blur(gray: Uint8ClampedArray, width: number, height: number): Uint8ClampedArray;
     static grayscale(raster: PsScanRaster): Uint8ClampedArray;
-    static sobel(gray: Uint8ClampedArray, width: number, height: number): Uint16Array;
 }

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

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

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

@@ -0,0 +1,7 @@
+export declare class PsScanMorphologyService {
+    static close(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    static dilate(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    static erode(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    private static horizontal;
+    private static vertical;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanMorphologyService = void 0;
+class PsScanMorphologyService {
+    static close(mask, width, height, radius) {
+        return PsScanMorphologyService.erode(PsScanMorphologyService.dilate(mask, width, height, radius), width, height, radius);
+    }
+    static dilate(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 1), width, height, radius, 1);
+    }
+    static erode(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 0), width, height, radius, 0);
+    }
+    static horizontal(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const from = Math.max(0, x - radius);
+                const to = Math.min(width - 1, x + radius);
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[y * width + at] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        return out;
+    }
+    static vertical(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1) {
+            const from = Math.max(0, y - radius);
+            const to = Math.min(height - 1, y + radius);
+            for (let x = 0; x < width; x += 1) {
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[at * width + x] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        }
+        return out;
+    }
+}
+exports.PsScanMorphologyService = PsScanMorphologyService;

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

@@ -1,10 +1,7 @@
-import type { PsScanPage } from '../models/ps-scan-page';
 import type { PsScanPrepared } from '../models/ps-scan-prepared';
-import type { PsScanRaster } from '../models/ps-scan-raster';
+import type { PsScanQuad } from '../models/ps-scan-quad';
 import type { PsScanRenderedPage } from '../models/ps-scan-rendered-page';
 export declare class PsScanPipelineService {
     static prepare(source: Blob): Promise<PsScanPrepared>;
-    static measure(source: Blob): Promise<PsScanRaster>;
-    static process(page: Pick<PsScanPage, 'corners' | 'filter' | 'rotation'>, raster: PsScanRaster, maxDimension: number): PsScanRaster;
-    static render(page: PsScanPage, maxDimension: number, quality: number): Promise<PsScanRenderedPage>;
+    static render(source: Blob, corners: PsScanQuad, maxDimension: number, quality: number): Promise<PsScanRenderedPage>;
 }

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

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

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

@@ -0,0 +1,4 @@
+import { PsScanPlatform } from '../constants/ps-scan-platform';
+export declare class PsScanPlatformService {
+    static detect(): PsScanPlatform;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanPlatformService = void 0;
+const ps_scan_platform_1 = require("../constants/ps-scan-platform");
+class PsScanPlatformService {
+    static detect() {
+        if (typeof navigator === 'undefined')
+            return ps_scan_platform_1.PsScanPlatform.Desktop;
+        const agent = navigator.userAgent;
+        if (/iPhone|iPad|iPod/i.test(agent))
+            return ps_scan_platform_1.PsScanPlatform.Ios;
+        if (/Macintosh/i.test(agent) && navigator.maxTouchPoints > 1)
+            return ps_scan_platform_1.PsScanPlatform.Ios;
+        if (/Android/i.test(agent))
+            return ps_scan_platform_1.PsScanPlatform.Android;
+        return ps_scan_platform_1.PsScanPlatform.Desktop;
+    }
+}
+exports.PsScanPlatformService = PsScanPlatformService;

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

@@ -0,0 +1,8 @@
+import type { PsPoint } from '../models/ps-point';
+export declare class PsScanPolygonService {
+    static perimeter(points: PsPoint[]): number;
+    static simplify(points: PsPoint[], epsilon: number): PsPoint[];
+    static toQuad(hull: PsPoint[]): PsPoint[] | null;
+    private static chain;
+    private static lineDistance;
+}

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

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

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

@@ -0,0 +1,4 @@
+import type { PsScanRegion } from '../models/ps-scan-region';
+export declare class PsScanRegionService {
+    static enclosed(mask: Uint8Array, width: number, height: number, minArea: number): PsScanRegion[];
+}

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

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

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

@@ -0,0 +1,7 @@
+import type { PsScanQuad } from '../models/ps-scan-quad';
+import type { PsScanStability } from '../models/ps-scan-stability';
+export declare class PsScanStabilityService {
+    static initial(): PsScanStability;
+    static movement(from: PsScanQuad, to: PsScanQuad): number;
+    static next(state: PsScanStability, detected: PsScanQuad | null): PsScanStability;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanStabilityService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
+class PsScanStabilityService {
+    static initial() {
+        return { misses: 0, quad: null };
+    }
+    static movement(from, to) {
+        return Math.max(...from.map((point, index) => ps_scan_geometry_service_1.PsScanGeometryService.distance(point, to[index])));
+    }
+    static next(state, detected) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > ps_scan_config_1.PsScanConfig.liveMissLimit
+                ? { misses, quad: null }
+                : { misses, quad: state.quad };
+        }
+        if (state.quad === null)
+            return { misses: 0, quad: detected };
+        if (PsScanStabilityService.movement(state.quad, detected) < ps_scan_config_1.PsScanConfig.liveDeadzone)
+            return { misses: 0, quad: state.quad };
+        const weight = ps_scan_config_1.PsScanConfig.liveSmoothing;
+        const quad = state.quad.map((point, index) => ({
+            x: point.x + (detected[index].x - point.x) * weight,
+            y: point.y + (detected[index].y - point.y) * weight,
+        }));
+        return { misses: 0, quad };
+    }
+}
+exports.PsScanStabilityService = PsScanStabilityService;

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

@@ -1,6 +1,6 @@
 import type { PsScanQuad } from '../models/ps-scan-quad';
 import type { PsScanRaster } from '../models/ps-scan-raster';
 export declare class PsScanWarpService {
-    static warp(source: PsScanRaster, pixelQuad: PsScanQuad, width: number, height: number): PsScanRaster;
+    static warp(source: PsScanRaster, pixelQuad: PsScanQuad, width: number, height: number): Promise<PsScanRaster>;
     private static sample;
 }

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

@@ -1,19 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanWarpService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
 const ps_scan_homography_service_1 = require("./ps-scan-homography-service");
 const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
+const ps_scan_yield_service_1 = require("./ps-scan-yield-service");
 class PsScanWarpService {
-    static warp(source, pixelQuad, width, height) {
+    static async warp(source, pixelQuad, width, height) {
         const matrix = ps_scan_homography_service_1.PsScanHomographyService.fromUnitSquare(pixelQuad);
         const target = ps_scan_raster_service_1.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(ps_scan_config_1.PsScanConfig.warpChunkPixels / width));
+        for (let y = 0; y < height; y += 1) {
             for (let x = 0; x < width; x += 1) {
                 const point = ps_scan_homography_service_1.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 ps_scan_yield_service_1.PsScanYieldService.next();
+        }
         return target;
     }
     static sample(source, x, y, out, at) {

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

@@ -0,0 +1,3 @@
+export declare class PsScanYieldService {
+    static next(): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanYieldService = void 0;
+class PsScanYieldService {
+    static async next() {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+}
+exports.PsScanYieldService = PsScanYieldService;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-file-components",
-	"version": "1.4.0",
+	"version": "2.0.0",
 	"private": false,
 	"main": "./dist/index.js",
 	"module": "./dist/esm/index.js",
@@ -32,8 +32,8 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@pallasoft/ps-core-components": "^2.27.0",
-		"@pallasoft/ps-icons": "^1.8.1",
+		"@pallasoft/ps-core-components": "^2.29.0",
+		"@pallasoft/ps-icons": "^1.9.0",
 		"@pallasoft/ps-popovers": "^1.10.2",
 		"@pallasoft/ps-utilities": "^2.19.1",
 		"pdfjs-dist": "^6.3.289"

package/dist/components/ps-scan-page-list.d.ts

@@ -1,12 +0,0 @@
-import { PsDocumentScannerLabels } from '../constants/ps-document-scanner-labels';
-import type { PsLabelSet } from '../models/ps-label-set';
-import type { PsScanPage } from '../models/ps-scan-page';
-export interface PsScanPageListProps {
-    activeId: string;
-    labels: PsLabelSet<typeof PsDocumentScannerLabels>;
-    onMove: (from: number, to: number) => void;
-    onSelect: (id: string) => void;
-    pages: PsScanPage[];
-    previews: Record<string, string>;
-}
-export declare const PsScanPageList: ({ activeId, labels, onMove, onSelect, pages, previews, }: PsScanPageListProps) => import("react").JSX.Element;

package/dist/components/ps-scan-page-list.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PsScanPageList = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const ps_core_components_1 = require("@pallasoft/ps-core-components");
-const ps_design_system_1 = require("@pallasoft/ps-design-system");
-const ps_icons_1 = require("@pallasoft/ps-icons");
-const ps_scan_template_service_1 = require("../services/ps-scan-template-service");
-const ps_scan_icon_button_1 = require("./ps-scan-icon-button");
-const PsScanPageList = ({ activeId, labels, onMove, onSelect, pages, previews, }) => {
-    const items = pages.map((page, index) => ({
-        id: page.id,
-        label: `${labels.page} ${index + 1}`,
-    }));
-    const say = (template, label, position) => ps_scan_template_service_1.PsScanTemplateService.fill(template, { count: pages.length, page: label, position });
-    return ((0, jsx_runtime_1.jsx)(ps_core_components_1.PsSortableList, { announcements: {
-            cancelled: (label) => say(labels.reorderCancelled, label, 0),
-            dropped: (label, position) => say(labels.reorderDropped, label, position),
-            lifted: (label, position) => say(labels.reorderLifted, label, position),
-            moved: (label, position) => say(labels.reorderMoved, label, position),
-        }, className: 'flex flex-col gap-2', getHandleLabel: (label) => ps_scan_template_service_1.PsScanTemplateService.fill(labels.dragPage, { page: label }), instructions: labels.reorderInstructions, items: items, onMove: (_id, from, to) => onMove(from, to), renderItem: ({ handle, index, isDragging, item }) => ((0, jsx_runtime_1.jsxs)("div", { className: ps_design_system_1.PallasoftClassNameService.merge('flex items-center gap-2 rounded-ps-control border bg-surface p-1.5', item.id === activeId ? 'border-primary' : 'border-line', isDragging ? 'opacity-80 shadow-lg' : ''), children: [handle, (0, jsx_runtime_1.jsxs)("button", { "aria-current": item.id === activeId, "aria-label": item.label, className: 'ps-focus-ring flex min-h-11 min-w-0 flex-1 items-center gap-3 rounded-ps-control text-left', onClick: () => onSelect(item.id), type: 'button', children: [previews[item.id] === undefined ? ((0, jsx_runtime_1.jsx)("span", { className: 'ps-skeleton h-14 w-10 shrink-0 rounded' })) : ((0, jsx_runtime_1.jsx)("img", { alt: '', className: 'h-14 w-10 shrink-0 rounded border border-line bg-white object-cover object-top', src: previews[item.id] })), (0, jsx_runtime_1.jsx)("span", { className: 'truncate text-sm font-medium text-ink', children: item.label })] }), (0, jsx_runtime_1.jsx)(ps_scan_icon_button_1.PsScanIconButton, { disabled: index === 0, label: ps_scan_template_service_1.PsScanTemplateService.fill(labels.moveUp, { page: item.label }), onClick: () => onMove(index, index - 1), children: (0, jsx_runtime_1.jsx)(ps_icons_1.PsIcon, { "aria-hidden": 'true', className: 'size-5 -rotate-90', iconKey: ps_icons_1.PsIconKey.ChevronRight }) }), (0, jsx_runtime_1.jsx)(ps_scan_icon_button_1.PsScanIconButton, { disabled: index === pages.length - 1, label: ps_scan_template_service_1.PsScanTemplateService.fill(labels.moveDown, { page: item.label }), onClick: () => onMove(index, index + 1), children: (0, jsx_runtime_1.jsx)(ps_icons_1.PsIcon, { "aria-hidden": 'true', className: 'size-5 rotate-90', iconKey: ps_icons_1.PsIconKey.ChevronRight }) })] })), role: 'list' }));
-};
-exports.PsScanPageList = PsScanPageList;