@jaak.ai/stamps 2.0.0-dev.30 → 2.0.0-dev.32

package/dist/types/components/my-component/my-component.d.ts

@@ -9,106 +9,85 @@ export declare class JaakStamps {
     preferredCamera: 'auto' | 'front' | 'back';
     captureCompleted: EventEmitter<any>;
     isReady: EventEmitter<boolean>;
-    isVideoActive: boolean;
-    statusMessage: string;
-    statusColor: string;
-    bestScore: number;
-    capturedFullFrame: string | null;
-    capturedCroppedId: string | null;
-    capturedBackFullFrame: string | null;
-    capturedBackCroppedId: string | null;
-    captureStep: 'front' | 'back' | 'completed';
-    isCapturing: boolean;
-    showFlipAnimation: boolean;
-    showSuccessAnimation: boolean;
-    shouldMirrorVideo: boolean;
+    detectionBoxes: Array<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        score: number;
+    }>;
     sideAlignment: {
         top: boolean;
         right: boolean;
         bottom: boolean;
         left: boolean;
     };
-    isDetectionPaused: boolean;
-    isLoading: boolean;
-    isModelPreloaded: boolean;
     isMaskReady: boolean;
-    availableCameras: MediaDeviceInfo[];
-    selectedCameraId: string | null;
+    shouldMirrorVideo: boolean;
     showCameraSelector: boolean;
-    isMultipleCamerasAvailable: boolean;
+    isSwitchingCamera: boolean;
+    currentStatus: {
+        message: string;
+        description?: string;
+        type: 'initializing' | 'ready' | 'loading' | 'active' | 'error';
+        isInitialized: boolean;
+    };
+    performanceData: {
+        fps: number;
+        inferenceTime: number;
+        memoryUsage: number;
+        onnxLoadTime: number;
+        frameProcessingTime: number;
+        totalDetections: number;
+        successfulDetections: number;
+        detectionRate: number;
+    };
+    isPerformanceMonitorMinimized: boolean;
+    private serviceContainer;
+    private logger;
+    private eventBus;
+    private stateManager;
+    private cameraService;
+    private detectionService;
     private videoRef?;
-    private canvasRef?;
-    private session?;
-    private startTime?;
+    private detectionContainer?;
     private videoStream?;
     private animationId?;
-    private hasScreenshotTaken;
     private lastDetectedBox?;
-    private mobileNetSession?;
-    private mobileNetClassMap?;
-    private deviceType;
-    private preferredCameraFacing;
+    private startTime?;
+    private hasScreenshotTaken;
+    private alignmentStartTime?;
+    private alignmentTimer?;
+    private performanceMetrics;
+    private performanceUpdateInterval?;
     private frameSkipCounter;
     private readonly FRAME_SKIP;
     private consecutiveFailures;
     private readonly MAX_FAILURES;
     private lastInferenceTime;
     private readonly MIN_INFERENCE_INTERVAL;
-    private preprocessCanvas?;
-    private preprocessCtx?;
-    private captureCanvas?;
-    private captureCtx?;
-    private readonly MODEL_PATH;
-    private readonly MOBILENET_MODEL_PATH;
-    private readonly MOBILENET_CLASSES_PATH;
-    private readonly INPUT_SIZE;
-    private readonly CONFIDENCE_THRESHOLD;
-    private readonly ID1_ASPECT_RATIO;
-    private logger;
-    private validateMaskSize;
-    private validateCropMargin;
-    private validatePreferredCamera;
-    private emitReadyEvent;
-    private isRearCamera;
-    private detectDeviceTypeAndCameras;
-    private enumerateAndDetectCameras;
-    private checkCameraPermission;
-    private handleCameraPermissionError;
-    private setInitialCameraPreference;
-    private loadCameraPreference;
-    private saveCameraPreference;
-    private switchCamera;
-    private setupCameraWithRetry;
-    private toggleCameraSelector;
-    private flipCamera;
     componentDidLoad(): Promise<void>;
-    private setupResizeObserver;
+    private initializeServices;
+    private setupEventListeners;
+    private initializeComponent;
+    private validateProps;
+    private loadOnnxRuntime;
+    private finalizeInitialization;
+    private updateStatus;
+    private emitReadyEvent;
+    private handleStateChange;
+    private initializeResizeObserver;
     private handleResize;
     private updateMaskDimensions;
-    private initializeCanvasPool;
-    disconnectedCallback(): void;
-    getCapturedImages(): Promise<{
-        front: {
-            fullFrame: string;
-            cropped: string;
-        };
-        back: {
-            fullFrame: string;
-            cropped: string;
-        };
-        metadata: {
-            hasBackCapture: boolean;
-            totalImages: number;
-        };
-    }>;
+    getCapturedImages(): Promise<import("../../services/interfaces/IStateManager").CapturedImages>;
     isProcessCompleted(): Promise<boolean>;
     startCapture(): Promise<void>;
     stopCapture(): Promise<void>;
     resetCapture(): Promise<void>;
+    skipBackCapture(): Promise<void>;
     getStatus(): Promise<{
         isVideoActive: boolean;
         captureStep: "front" | "back" | "completed";
-        statusMessage: string;
         hasImages: boolean;
         isProcessCompleted: boolean;
         isModelPreloaded: boolean;
@@ -122,48 +101,37 @@ export declare class JaakStamps {
         error: any;
         message?: undefined;
     }>;
-    skipBackCapture(): Promise<void>;
     getCameraInfo(): Promise<{
-        availableCameras: {
-            id: string;
-            label: string;
-            selected: boolean;
-        }[];
-        selectedCameraId: string;
-        deviceType: "mobile" | "desktop" | "tablet";
+        availableCameras: import("../../services/interfaces/ICameraService").CameraInfo[];
+        selectedCameraId: string | null;
+        deviceType: string;
         isMultipleCamerasAvailable: boolean;
-        preferredFacing: "environment" | "user";
-        userPreferredCamera: "auto" | "front" | "back";
+        preferredFacing: "environment" | "user" | null;
     }>;
     setPreferredCamera(camera: 'auto' | 'front' | 'back'): Promise<{
         success: boolean;
         selectedCamera: string;
         availableCameras: number;
     }>;
-    private loadMobileNetModel;
-    private preprocessMobileNet;
-    private classifyDocument;
-    private cleanup;
-    private cleanupCanvasPool;
-    private getMaxResolution;
-    private setupCamera;
-    private preprocess;
-    private float32ToFloat16;
-    private getDeviceMemoryInfo;
-    private getSessionOptions;
     private startDetection;
+    private initializeVideoStream;
     private detectFrame;
-    private isCardInFrame;
-    private checkSideAlignment;
-    private areAllSidesAligned;
+    disconnectedCallback(): void;
+    private cleanup;
+    render(): any;
+    private updateDetectionBoxes;
     private updateMaskColor;
-    private updateGuidanceStatus;
-    private drawDetections;
     private takeScreenshot;
     private triggerCaptureAnimation;
+    private completeProcess;
     private stopDetection;
+    private toggleCameraSelector;
+    private handleCameraSwitch;
     private resetDetection;
-    private completeProcess;
     private exitSession;
-    render(): any;
+    private initializePerformanceMonitor;
+    private updatePerformanceMetrics;
+    private recordOnnxPerformance;
+    private recordFrameProcessing;
+    private togglePerformanceMonitor;
 }

package/dist/types/components.d.ts

@@ -19,9 +19,9 @@ export namespace Components {
           * @default false
          */
         "debug": boolean;
-        "getCameraInfo": () => Promise<{ availableCameras: { id: string; label: string; selected: boolean; }[]; selectedCameraId: string; deviceType: "mobile" | "desktop" | "tablet"; isMultipleCamerasAvailable: boolean; preferredFacing: "environment" | "user"; userPreferredCamera: "auto" | "front" | "back"; }>;
-        "getCapturedImages": () => Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>;
-        "getStatus": () => Promise<{ isVideoActive: boolean; captureStep: "front" | "back" | "completed"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>;
+        "getCameraInfo": () => Promise<{ availableCameras: import("/home/runner/work/jaak-stamps-webcomponent/jaak-stamps-webcomponent/src/services/interfaces/ICameraService").CameraInfo[]; selectedCameraId: string | null; deviceType: string; isMultipleCamerasAvailable: boolean; preferredFacing: "environment" | "user" | null; }>;
+        "getCapturedImages": () => Promise<import("/home/runner/work/jaak-stamps-webcomponent/jaak-stamps-webcomponent/src/services/interfaces/IStateManager").CapturedImages>;
+        "getStatus": () => Promise<{ isVideoActive: boolean; captureStep: "front" | "back" | "completed"; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>;
         "isProcessCompleted": () => Promise<boolean>;
         /**
           * @default 90

package/dist/types/services/CameraService.d.ts

@@ -0,0 +1,41 @@
+import { ICameraService, CameraInfo } from './interfaces/ICameraService';
+import { ILogger } from './interfaces/ILogger';
+import { IEventBus } from './interfaces/IEventBus';
+export declare class CameraService implements ICameraService {
+    private logger;
+    private eventBus;
+    private availableCameras;
+    private selectedCameraId;
+    private deviceType;
+    private preferredCameraFacing;
+    private preferredCamera;
+    constructor(logger: ILogger, eventBus: IEventBus, preferredCamera?: 'auto' | 'front' | 'back');
+    detectDeviceType(): Promise<'mobile' | 'desktop' | 'tablet'>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    getAvailableCameras(): MediaDeviceInfo[];
+    isMultipleCamerasAvailable(): boolean;
+    getSelectedCameraId(): string | null;
+    setSelectedCamera(cameraId: string): Promise<void>;
+    getPreferredFacing(): 'environment' | 'user' | null;
+    setupCamera(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+    switchCamera(cameraId: string): Promise<void>;
+    flipToNextCamera(): Promise<void>;
+    savePreference(): void;
+    loadPreference(): void;
+    isRearCamera(stream: MediaStream): boolean;
+    getCameraInfo(): {
+        availableCameras: CameraInfo[];
+        selectedCameraId: string | null;
+        deviceType: string;
+        isMultipleCamerasAvailable: boolean;
+        preferredFacing: 'environment' | 'user' | null;
+    };
+    private checkCameraPermission;
+    private handleCameraPermissionError;
+    private setInitialCameraPreference;
+    private selectFrontCamera;
+    private selectBackCamera;
+    private selectAutoCamera;
+    private updatePreferredFacing;
+    private getMaxResolution;
+}

package/dist/types/services/DetectionService.d.ts

@@ -0,0 +1,35 @@
+import { IDetectionService, DetectionBox, SideAlignment, ClassificationResult } from './interfaces/IDetectionService';
+import { ILogger } from './interfaces/ILogger';
+export declare class DetectionService implements IDetectionService {
+    private logger;
+    private debug;
+    private useDocumentClassification;
+    private session?;
+    private mobileNetSession?;
+    private mobileNetClassMap?;
+    private modelLoaded;
+    private deviceStrategy;
+    private readonly MODEL_PATH;
+    private readonly MOBILENET_MODEL_PATH;
+    private readonly MOBILENET_CLASSES_PATH;
+    private readonly INPUT_SIZE;
+    private readonly CONFIDENCE_THRESHOLD;
+    private preprocessCanvas?;
+    private preprocessCtx?;
+    private captureCanvas?;
+    constructor(logger: ILogger, debug?: boolean, useDocumentClassification?: boolean);
+    loadModel(): Promise<void>;
+    loadClassificationModel(): Promise<void>;
+    isModelLoaded(): boolean;
+    preprocess(video: HTMLVideoElement): any;
+    runInference(inputTensor: any): Promise<DetectionBox[]>;
+    classifyDocument(canvas: HTMLCanvasElement): Promise<ClassificationResult | null>;
+    checkSideAlignment(box: DetectionBox, maskConfig: any): SideAlignment;
+    isCardInFrame(box: DetectionBox): boolean;
+    areAllSidesAligned(alignment: SideAlignment): boolean;
+    cleanup(): void;
+    private initializeCanvasPool;
+    private cleanupCanvasPool;
+    private float32ToFloat16;
+    private preprocessMobileNet;
+}

package/dist/types/services/EventBusService.d.ts

@@ -0,0 +1,9 @@
+import { IEventBus, EventCallback } from './interfaces/IEventBus';
+export declare class EventBusService implements IEventBus {
+    private events;
+    on<T = any>(event: string, callback: EventCallback<T>): void;
+    off(event: string, callback: EventCallback): void;
+    emit<T = any>(event: string, data?: T): void;
+    once<T = any>(event: string, callback: EventCallback<T>): void;
+    clear(): void;
+}

package/dist/types/services/LoggerService.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from './interfaces/ILogger';
+export declare class LoggerService implements ILogger {
+    private debugMode;
+    constructor(debug?: boolean);
+    setDebugMode(debug: boolean): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    state(state: string, data?: any): void;
+    performance(operation: string, duration: number): void;
+}

package/dist/types/services/ServiceContainer.d.ts

@@ -0,0 +1,26 @@
+import { ILogger } from './interfaces/ILogger';
+import { ICameraService } from './interfaces/ICameraService';
+import { IDetectionService } from './interfaces/IDetectionService';
+import { IStateManager } from './interfaces/IStateManager';
+import { IEventBus } from './interfaces/IEventBus';
+export interface ComponentConfig {
+    debug: boolean;
+    alignmentTolerance: number;
+    maskSize: number;
+    cropMargin: number;
+    useDocumentClassification: boolean;
+    preferredCamera: 'auto' | 'front' | 'back';
+}
+export declare class ServiceContainer {
+    private services;
+    constructor(config: ComponentConfig);
+    private initializeServices;
+    get<T>(serviceName: string): T;
+    getLogger(): ILogger;
+    getEventBus(): IEventBus;
+    getStateManager(): IStateManager;
+    getCameraService(): ICameraService;
+    getDetectionService(): IDetectionService;
+    updateConfig(config: Partial<ComponentConfig>): void;
+    cleanup(): void;
+}

package/dist/types/services/StateManagerService.d.ts

@@ -0,0 +1,15 @@
+import { IStateManager, CaptureState, CapturedImages } from './interfaces/IStateManager';
+import { IEventBus } from './interfaces/IEventBus';
+export declare class StateManagerService implements IStateManager {
+    private eventBus;
+    private captureState;
+    private capturedImages;
+    constructor(eventBus: IEventBus);
+    getCaptureState(): CaptureState;
+    updateCaptureState(updates: Partial<CaptureState>): void;
+    getCapturedImages(): CapturedImages;
+    setCapturedImages(images: Partial<CapturedImages>): void;
+    reset(): void;
+    isProcessCompleted(): boolean;
+    canProceedToBack(): boolean;
+}

package/dist/types/services/factories/DeviceStrategyFactory.d.ts

@@ -0,0 +1,4 @@
+import { IDeviceStrategy } from '../strategies/IDeviceStrategy';
+export declare class DeviceStrategyFactory {
+    static createStrategy(): IDeviceStrategy;
+}

package/dist/types/services/interfaces/ICameraService.d.ts

@@ -0,0 +1,32 @@
+export interface CameraInfo {
+    id: string;
+    label: string;
+    selected: boolean;
+}
+export interface CameraPreference {
+    cameraId: string;
+    facing: 'environment' | 'user' | null;
+    timestamp: number;
+}
+export interface ICameraService {
+    detectDeviceType(): Promise<'mobile' | 'desktop' | 'tablet'>;
+    enumerateDevices(): Promise<MediaDeviceInfo[]>;
+    getAvailableCameras(): MediaDeviceInfo[];
+    isMultipleCamerasAvailable(): boolean;
+    getSelectedCameraId(): string | null;
+    setSelectedCamera(cameraId: string): Promise<void>;
+    getPreferredFacing(): 'environment' | 'user' | null;
+    setupCamera(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+    switchCamera(cameraId: string): Promise<void>;
+    flipToNextCamera(): Promise<void>;
+    savePreference(): void;
+    loadPreference(): void;
+    isRearCamera(stream: MediaStream): boolean;
+    getCameraInfo(): {
+        availableCameras: CameraInfo[];
+        selectedCameraId: string | null;
+        deviceType: string;
+        isMultipleCamerasAvailable: boolean;
+        preferredFacing: 'environment' | 'user' | null;
+    };
+}

package/dist/types/services/interfaces/IDetectionService.d.ts

@@ -0,0 +1,31 @@
+export interface DetectionBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    score: number;
+    classId?: number;
+}
+export interface SideAlignment {
+    top: boolean;
+    right: boolean;
+    bottom: boolean;
+    left: boolean;
+}
+export interface ClassificationResult {
+    class: string;
+    confidence: number;
+    classIndex: number;
+}
+export interface IDetectionService {
+    loadModel(): Promise<void>;
+    loadClassificationModel(): Promise<void>;
+    isModelLoaded(): boolean;
+    preprocess(video: HTMLVideoElement): any;
+    runInference(inputTensor: any): Promise<DetectionBox[]>;
+    classifyDocument(canvas: HTMLCanvasElement): Promise<ClassificationResult | null>;
+    checkSideAlignment(box: DetectionBox, maskConfig: any): SideAlignment;
+    isCardInFrame(box: DetectionBox): boolean;
+    areAllSidesAligned(alignment: SideAlignment): boolean;
+    cleanup(): void;
+}

package/dist/types/services/interfaces/IEventBus.d.ts

@@ -0,0 +1,16 @@
+export type EventCallback<T = any> = (data: T) => void;
+export interface IEventBus {
+    on<T = any>(event: string, callback: EventCallback<T>): void;
+    off(event: string, callback: EventCallback): void;
+    emit<T = any>(event: string, data?: T): void;
+    once<T = any>(event: string, callback: EventCallback<T>): void;
+    clear(): void;
+}
+export interface ComponentEvents {
+    'capture-completed': any;
+    'ready': boolean;
+    'camera-changed': string;
+    'detection-updated': any[];
+    'state-changed': any;
+    'error': Error;
+}

package/dist/types/services/interfaces/ILogger.d.ts

@@ -0,0 +1,8 @@
+export interface ILogger {
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    state(state: string, data?: any): void;
+    performance(operation: string, duration: number): void;
+}

package/dist/types/services/interfaces/IStateManager.d.ts

@@ -0,0 +1,35 @@
+export interface CaptureState {
+    step: 'front' | 'back' | 'completed';
+    isCapturing: boolean;
+    isDetectionPaused: boolean;
+    isVideoActive: boolean;
+    isLoading: boolean;
+    showFlipAnimation: boolean;
+    showSuccessAnimation: boolean;
+    bestScore: number;
+    hasScreenshotTaken: boolean;
+}
+export interface CapturedImages {
+    front: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    back: {
+        fullFrame: string | null;
+        cropped: string | null;
+    };
+    metadata: {
+        totalImages: number;
+        processCompleted: boolean;
+        backCaptureSkipped: boolean;
+    };
+}
+export interface IStateManager {
+    getCaptureState(): CaptureState;
+    updateCaptureState(updates: Partial<CaptureState>): void;
+    getCapturedImages(): CapturedImages;
+    setCapturedImages(images: Partial<CapturedImages>): void;
+    reset(): void;
+    isProcessCompleted(): boolean;
+    canProceedToBack(): boolean;
+}

package/dist/types/services/strategies/HighPerformanceDeviceStrategy.d.ts

@@ -0,0 +1,6 @@
+import { IDeviceStrategy, DeviceInfo, SessionOptions } from './IDeviceStrategy';
+export declare class HighPerformanceDeviceStrategy implements IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/dist/types/services/strategies/IDeviceStrategy.d.ts

@@ -0,0 +1,21 @@
+export interface DeviceInfo {
+    estimatedRAM: number;
+    isLowMemory: boolean;
+    isSlowConnection: boolean;
+}
+export interface SessionOptions {
+    executionProviders: string[];
+    graphOptimizationLevel: string;
+    logSeverityLevel: number;
+    logVerbosityLevel?: number;
+    enableCpuMemArena: boolean;
+    enableMemPattern: boolean;
+    executionMode: string;
+    interOpNumThreads: number;
+    intraOpNumThreads: number;
+}
+export interface IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/dist/types/services/strategies/LowMemoryDeviceStrategy.d.ts

@@ -0,0 +1,6 @@
+import { IDeviceStrategy, DeviceInfo, SessionOptions } from './IDeviceStrategy';
+export declare class LowMemoryDeviceStrategy implements IDeviceStrategy {
+    getDeviceInfo(): DeviceInfo;
+    getSessionOptions(_debug: boolean): SessionOptions;
+    shouldUseSequentialLoading(): boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaak.ai/stamps",
-  "version": "2.0.0-dev.30",
+  "version": "2.0.0-dev.32",
   "description": "Jaak Document Identifier",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",
@@ -52,8 +52,8 @@
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^11.0.3",
-    "@semantic-release/npm": "^12.0.1",
+    "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "semantic-release": "^24.2.5"
+    "semantic-release": "^24.2.6"
   }
 }