@pallasoft/ps-file-components 1.4.0 → 1.5.0

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

@@ -4,13 +4,45 @@ exports.PsScanCameraService = void 0;
 const ps_scan_camera_status_1 = require("../constants/ps-scan-camera-status");
 const ps_scan_config_1 = require("../constants/ps-scan-config");
 class PsScanCameraService {
+    static async attach(video, session) {
+        if (video.srcObject !== session.stream)
+            video.srcObject = session.stream;
+        await video.play().catch(() => undefined);
+    }
+    static async check() {
+        if (globalThis.isSecureContext === false)
+            return ps_scan_camera_status_1.PsScanCameraStatus.Insecure;
+        if (!PsScanCameraService.isSupported())
+            return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        if (!(await PsScanCameraService.hasCamera()))
+            return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        const permission = await PsScanCameraService.permission();
+        if (permission === null)
+            return ps_scan_camera_status_1.PsScanCameraStatus.Prompt;
+        if (permission.state === 'granted')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Starting;
+        return permission.state === 'denied' ? ps_scan_camera_status_1.PsScanCameraStatus.Denied : ps_scan_camera_status_1.PsScanCameraStatus.Prompt;
+    }
     static classify(error) {
         const name = typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
-        return name === 'NotAllowedError' ||
-            name === 'SecurityError' ||
-            name === 'PermissionDeniedError'
-            ? ps_scan_camera_status_1.PsScanCameraStatus.Denied
-            : ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+        if (name === 'NotAllowedError' || name === 'PermissionDeniedError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Denied;
+        if (name === 'SecurityError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Insecure;
+        if (name === 'NotReadableError' || name === 'TrackStartError' || name === 'AbortError')
+            return ps_scan_camera_status_1.PsScanCameraStatus.Busy;
+        return ps_scan_camera_status_1.PsScanCameraStatus.Unavailable;
+    }
+    static async hasCamera() {
+        if (typeof navigator.mediaDevices.enumerateDevices !== 'function')
+            return true;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.length === 0 || devices.some((device) => device.kind === 'videoinput');
+        }
+        catch {
+            return true;
+        }
     }
     static isSupported() {
         return (typeof navigator !== 'undefined' &&
@@ -29,6 +61,19 @@ class PsScanCameraService {
         const track = stream.getVideoTracks()[0];
         return { canTorch: PsScanCameraService.supportsTorch(track), stream, track };
     }
+    static async permission() {
+        if (typeof navigator.permissions === 'undefined' ||
+            typeof navigator.permissions.query !== 'function')
+            return null;
+        try {
+            return await navigator.permissions.query({
+                name: ps_scan_config_1.PsScanConfig.cameraPermission,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     static async setTorch(track, isOn) {
         try {
             await track.applyConstraints({

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

@@ -4,5 +4,6 @@ export declare class PsScanCanvasService {
     static decode(blob: Blob, maxDimension: number): Promise<PsScanDecodedImage>;
     static encode(raster: PsScanRaster, quality: number): Promise<Blob>;
     static fromVideo(video: HTMLVideoElement, quality: number): Promise<Blob>;
+    static sample(video: HTMLVideoElement, maxDimension: number): PsScanRaster;
     private static context;
 }

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

@@ -30,6 +30,12 @@ class PsScanCanvasService {
         context.drawImage(video, 0, 0);
         return await PsScanCanvasService.encode(context.getImageData(0, 0, video.videoWidth, video.videoHeight), quality);
     }
+    static sample(video, maxDimension) {
+        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin({ height: video.videoHeight, width: video.videoWidth }, maxDimension);
+        const context = PsScanCanvasService.context(size.width, size.height);
+        context.drawImage(video, 0, 0, size.width, size.height);
+        return context.getImageData(0, 0, size.width, size.height);
+    }
     static context(width, height) {
         if (typeof OffscreenCanvas !== 'undefined') {
             const context = new OffscreenCanvas(width, height).getContext('2d', {

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

@@ -36,7 +36,7 @@ class PsScanEdgeService {
             return null;
         if (!ps_scan_geometry_service_1.PsScanGeometryService.isConvex(quad))
             return null;
-        return quad.map((point) => ({
+        return ps_scan_geometry_service_1.PsScanGeometryService.inset(quad, ps_scan_config_1.PsScanConfig.detectInset).map((point) => ({
             x: Math.min(1, Math.max(0, point.x / (width - 1))),
             y: Math.min(1, Math.max(0, point.y / (height - 1))),
         }));

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

@@ -4,10 +4,12 @@ import type { PsScanQuad } from '../models/ps-scan-quad';
 export declare class PsScanGeometryService {
     static area(points: PsPoint[]): number;
     static clamp(point: PsPoint): PsPoint;
+    static cover(container: PsPageSize, content: PsPageSize): PsPageSize;
     static defaultQuad(): PsScanQuad;
     static distance(from: PsPoint, to: PsPoint): number;
     static fit(container: PsPageSize, content: PsPageSize): PsPageSize;
     static fitWithin(size: PsPageSize, maxDimension: number): PsPageSize;
+    static inset(quad: PsScanQuad, distance: number): PsScanQuad;
     static isConvex(points: PsPoint[]): boolean;
     static isUsable(quad: PsScanQuad): boolean;
     static nudge(quad: PsScanQuad, index: number, dx: number, dy: number): PsScanQuad;

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

@@ -14,6 +14,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 [
@@ -42,6 +48,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-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-stability-service.d.ts

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

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

@@ -0,0 +1,45 @@
+"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 disarm(state) {
+        return { ...state, isArmed: false, stableMs: 0 };
+    }
+    static initial() {
+        return { isArmed: true, misses: 0, quad: null, raw: null, stableMs: 0 };
+    }
+    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, elapsedMs) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > ps_scan_config_1.PsScanConfig.liveMissLimit
+                ? { isArmed: true, misses, quad: null, raw: null, stableMs: 0 }
+                : { ...state, misses, stableMs: 0 };
+        }
+        if (state.quad === null || state.raw === null)
+            return { ...state, misses: 0, quad: detected, raw: detected, stableMs: 0 };
+        const movement = PsScanStabilityService.movement(state.raw, detected);
+        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 {
+            isArmed: state.isArmed || movement > ps_scan_config_1.PsScanConfig.liveRearmMovement,
+            misses: 0,
+            quad,
+            raw: detected,
+            stableMs: movement <= ps_scan_config_1.PsScanConfig.liveStillMovement ? state.stableMs + elapsedMs : 0,
+        };
+    }
+    static progress(state) {
+        if (!state.isArmed || state.quad === null)
+            return 0;
+        return Math.min(1, state.stableMs / ps_scan_config_1.PsScanConfig.autoCaptureMs);
+    }
+}
+exports.PsScanStabilityService = PsScanStabilityService;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pallasoft/ps-file-components",
-	"version": "1.4.0",
+	"version": "1.5.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"