@idscan/idvc2 2.5.6 → 2.5.7

package/dist/types/modules/MrzModule.d.ts

@@ -0,0 +1,73 @@
+import { IMRZLocation } from './manualUploadProcessing';
+import { IMrzScanRes } from '../types/mrz';
+import { IMrzCoords } from '../loop';
+import { StepFunctionResult } from '../types/loop';
+import MrzModel, { PredictionList } from '../neural models/mrzModel';
+interface IMrzStepResult extends StepFunctionResult {
+    coords?: IMrzCoords;
+    needToCut?: boolean;
+    results?: {
+        mrzText: string;
+    };
+}
+interface ILicenceError {
+    errorType: string;
+    error: boolean;
+    errorVal: string;
+}
+interface IDetectRes {
+    status: boolean;
+    results?: {
+        mrzText: string;
+    } | null;
+    locations?: IMRZLocation;
+    error?: ILicenceError;
+}
+export declare class MrzModule {
+    w: number;
+    h: number;
+    successCount: number;
+    worker: Worker;
+    model: MrzModel;
+    isInitialized: boolean;
+    isProcessing: boolean;
+    constructor(worker: any, key: string, networkUrl: string);
+    getErrorVal(errorId: number): any;
+    /**
+     * returns error Object
+     * @return {ILicenceError}
+     */
+    licenseError(errorId: number): ILicenceError;
+    yComparator(point1: any, point2: any): any[];
+    allocate(): void;
+    prepareMRZlocation(locations: any): IMRZLocation;
+    writeResults(mrzResults: IMrzScanRes): {
+        mrzText: string;
+    };
+    predict(batchArr: Float32Array, batchSize: any): Promise<PredictionList[]>;
+    scan(iData: ImageData): Promise<IMrzScanRes>;
+    /**
+     * process frame for MRZ
+     * @param data
+     */
+    processMRZ(data: any): Promise<IMrzStepResult | {
+        error: ILicenceError;
+        status: {
+            value: number;
+        };
+        fields: import("../types/mrz").MrzFields;
+        count: number;
+        location: import("../types/mrz").IMRZLocation;
+        errorStatus?: string;
+        symbolsConf: number;
+        errorId: number;
+    }>;
+    estimateResults(data: any): number;
+    /**
+     * detects MRZ on ImageData
+     * @param {ImageData} imageData
+     * @return {Promise<>}
+     */
+    detectMrz(imageData: ImageData): Promise<IDetectRes>;
+}
+export default MrzModule;

package/dist/types/modules/PdfModule.d.ts

@@ -0,0 +1,79 @@
+import { ISize } from '../helpers/image';
+interface Coord {
+    x: number;
+    y: number;
+}
+export declare class PdfModule {
+    module: any;
+    reader: any;
+    handle: any;
+    bw: number;
+    bh: number;
+    src: any;
+    out: any;
+    isAllocate: boolean;
+    successCount: number;
+    _errorId: number;
+    edgMem: any;
+    src2: any;
+    outLen: any;
+    locations: any;
+    pdfCount: number;
+    geometry: {
+        angleBetweenTwoVectors: any;
+    };
+    minPDFframes: number;
+    cropSizes: ISize;
+    canvasSizes: ISize;
+    constructor(core: any, processor: any);
+    /**
+     *
+     * @param geometry
+     * @param {number} minPDFframes - c.config.minPDFframes
+     * @param {{width: number, height: number}} cropSize - c.config.cropSize
+     * @param {{width: number, height: number}} canvasSizes - ui.borderCanvas
+     */
+    init(geometry: any, minPDFframes: any, cropSize: any, canvasSizes: any): void;
+    set errorId(id: number);
+    get errorId(): number;
+    get errorVal(): any;
+    /**
+     * returns error Object
+     * @return {{errorType: string, error: boolean, errorVal: string}}
+     */
+    licenseError(): {
+        error: boolean;
+        errorType: string;
+        errorVal: any;
+    };
+    getLocations(): void;
+    setResizedData(data: any): void;
+    initReader(key: any): void;
+    destroyReader(): void;
+    setPdfData(data: any): void;
+    readPdf(): any;
+    releasePdf(): void;
+    create(): void;
+    free(): void;
+    setSizes(bw: any, bh: any): void;
+    getSizes(): {
+        bw: number;
+        bh: number;
+    };
+    allocate(): void;
+    readPDF(data: any): any;
+    drawCords(locations: Record<string, number>): Coord[];
+    proccessPDF(data: ImageData): {
+        status: boolean;
+        predict: boolean;
+        touch: boolean;
+        image: any;
+        type: string;
+        error: any;
+        coords: any[];
+        trackString: string;
+        pdfSuccessCount: number;
+        pdfCount: number;
+    };
+}
+export default PdfModule;

package/dist/types/modules/Step.d.ts

@@ -0,0 +1,69 @@
+import { Base64Image } from '../helpers/image';
+import { StepType } from '../environment/stepsDescription';
+import { IStepMode } from '../defaultConfig';
+export interface IStepConfigMode {
+    name: 'mode';
+    value: IStepMode;
+}
+export type StepConfig = IStepConfigMode;
+export type StepConfigNames = StepConfig['name'];
+export type StepConfigValues = StepConfig['value'];
+export interface IStepObj {
+    name: string;
+    type: StepType;
+    camera: VideoFacingModeEnum;
+    img: Base64Image | null;
+    err?: string | null;
+    text?: string;
+    time?: number;
+    configs?: StepConfig[];
+}
+export interface IStepCallback {
+    /** base64 encoded step image */
+    img: Base64Image | null;
+    /** blob step image */
+    blob: Blob | null;
+    /** step type */
+    type: StepType;
+    /** is it autocaptured from camera */
+    isAuto?: boolean;
+    /** image source */
+    source?: 'video' | 'file' | '';
+    /** step index */
+    index?: number;
+    /** trackstring from mrz or pdf */
+    trackString?: string;
+    /** mrz recognized text */
+    mrzText?: string;
+    /** cropped base64 encoded mrz image */
+    mrzImg?: Base64Image | null;
+    /** cropped blob mrz image */
+    mrzBlob?: Blob | null;
+    /** recognized text */
+    text?: string;
+}
+export default class Step implements IStepCallback, IStepObj {
+    blob: Blob | null;
+    errorCode: string | null | undefined;
+    mrzText?: string;
+    mrzImg?: Base64Image | null;
+    mrzBlob?: Blob | null;
+    trackString?: string;
+    err?: string | null;
+    text?: string;
+    isAuto?: boolean;
+    source?: 'video' | 'file';
+    configs: StepConfig[];
+    name: string;
+    type: StepType;
+    camera: VideoFacingModeEnum;
+    img: Base64Image | null;
+    constructor(nameOrObj: string | IStepObj, type?: StepType, camera?: VideoFacingModeEnum, time?: number, img?: Base64Image | null);
+    setConfig(configName: StepConfigNames, configValue: StepConfigValues): void;
+    hasConfig(configName: StepConfigNames): StepConfig | undefined;
+    getConfig(configName: StepConfigNames): StepConfigValues | null;
+    get isShowManualSwitchButton(): boolean;
+    get capturingMode(): IStepMode;
+    prepareStepForCallback(index: number): IStepCallback;
+    static createStep(stepObj: IStepObj): Step;
+}

package/dist/types/modules/blur.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (core: any) => {
+    analyze: (iData: ImageData) => any;
+};
+export default _default;

package/dist/types/modules/browwserCompatibilities.d.ts

@@ -0,0 +1,7 @@
+export declare const browserCompatibilities: {
+    simdSupport: boolean;
+    wasmSupport: boolean;
+    mediaSupport: boolean;
+    secureConnection: boolean;
+};
+export declare const detectBrowserCompatibilities: () => void;

package/dist/types/modules/camera/camera.d.ts

@@ -0,0 +1,14 @@
+import { ISize } from '../../helpers/image';
+export declare const stopTrack: () => void;
+export declare const cameraErrorHandling: (err: Error) => Promise<never>;
+declare const _default: {
+    initUploader: () => Promise<void>;
+    stopTrack: () => void;
+    init: () => Promise<void>;
+    start: (mode: VideoFacingModeEnum) => Promise<void>;
+    setCapture: (val: boolean) => void;
+    checkFlashAvailable: (mode?: VideoFacingModeEnum) => void;
+    getResolution: (mode: VideoFacingModeEnum) => Promise<ISize>;
+    dropResolutions: () => void;
+};
+export default _default;

package/dist/types/modules/camera/cameraManager.d.ts

@@ -0,0 +1,9 @@
+import { CameraObjects, StartCamera } from '../../types/modules/camera';
+import { CameraError } from '../initErrorHandler';
+/**
+ * all available cameras
+ */
+export declare const cameraObjects: CameraObjects;
+export declare const stopTrack: (mediaStream: MediaStream) => void;
+export declare const fillVideoDevices: () => Promise<CameraError | CameraObjects>;
+export declare const startCamera: StartCamera;

package/dist/types/modules/face/Face.d.ts

@@ -0,0 +1,63 @@
+import { Geometry } from '../../helpers/geometry';
+import { Color } from '../../helpers/color';
+declare class Face {
+    module: any;
+    protected isAllocate: boolean;
+    private n;
+    protected w: number;
+    protected h: number;
+    prcsq: number | null;
+    rcsq: Float32Array | null;
+    maxndetections: number;
+    ppixels: number | null;
+    faceSuccessCount: number;
+    faceFailCount: number;
+    faceNotRecognizedCount: number;
+    private memory;
+    pixels: Uint8Array;
+    res: {
+        cancel: boolean;
+        image: null;
+        touch: boolean;
+        type: string;
+        status: boolean;
+    };
+    private color;
+    protected geometry: Geometry | null;
+    protected edgesColor: string;
+    constructor(core: any);
+    init(geometry: Geometry, color: Color): void;
+    initMemory(): void;
+    updateMemory(dets: number[][]): any[];
+    allocate(w: number, h: number): void;
+    findFace(data: number[]): {
+        tresh: number;
+        face: {
+            x: number;
+            y: number;
+            radius: number;
+        };
+        thresh?: undefined;
+    } | {
+        thresh: number;
+        face: {
+            x: number;
+            y: number;
+            radius: number;
+        };
+        tresh?: undefined;
+    };
+    setColorFromAngle(angle: number): void;
+    result(status?: boolean, image?: any, touch?: boolean): {
+        status: boolean;
+        image: any;
+        faceSuccessCount: number;
+        faceFailCount: number;
+        faceNotRecognizedCount: number;
+        touch: boolean;
+        cancel: boolean;
+        type: string;
+    };
+    processFace(): void;
+}
+export default Face;

package/dist/types/modules/face/MeshFace.d.ts

@@ -0,0 +1,48 @@
+import { Geometry } from '../../helpers/geometry';
+import { FacePrediction, RealFaceResultObject } from '../../types/modules/realFace';
+import { RealFaceTurnSide } from '../../types/enums/realFace';
+export declare class MeshFace {
+    private realFace;
+    private moveToCenter;
+    private noFace;
+    private perimeter;
+    private distance;
+    private baseSizes;
+    private lowFacePerimeterPercent;
+    private readonly lowFacePerimeterPercentDefault;
+    private correctDirection;
+    private direction;
+    private turnDistances;
+    private prediction;
+    private faceFailCount;
+    private faceSuccessCount;
+    private readonly res;
+    private geometry;
+    constructor();
+    init(geometry: Geometry): void;
+    result(status?: boolean): RealFaceResultObject;
+    noPredictions(): RealFaceResultObject;
+    processFace(prediction: FacePrediction, resizedSize: HTMLCanvasElement | HTMLVideoElement): RealFaceResultObject;
+    dropSuccess(): void;
+    getDirection(): RealFaceTurnSide;
+    setDirection(value: any): void;
+    getMf(center: any): number[];
+    processBadPerimeter(perimeter: any): void;
+    main(perimeter: any, mf: any): void;
+    processRealFace(): void;
+    calculateFace(): {
+        perimeter: number;
+        mf: number[];
+    };
+    processPrediction(): void;
+    processDistance(): void;
+    /**
+     * calculates head turn in degrees
+     * @param {number} firstDistance
+     * @param {number} secondDistance
+     * @returns {number}
+     */
+    calculateTurn(firstDistance: any, secondDistance: any): number;
+    calculateDistance(): void;
+}
+export default MeshFace;

package/dist/types/modules/face/SimpleFace.d.ts

@@ -0,0 +1,23 @@
+import Face from './Face';
+export declare class SimpleFace extends Face {
+    private initialized;
+    private readonly shiftFactor;
+    private readonly minSize;
+    private readonly maxSize;
+    private readonly scaleFactor;
+    constructor(core: any);
+    initPico(data: ImageData): Promise<void>;
+    rgbaToGrayScale(rgba: any, width: any, height: any): Uint8Array;
+    detect(faceData: ImageData): {
+        status: boolean;
+        image: any;
+        faceSuccessCount: number;
+        faceFailCount: number;
+        faceNotRecognizedCount: number;
+        touch: boolean;
+        cancel: boolean;
+        type: string;
+    };
+    dropResults(): void;
+}
+export default SimpleFace;

package/dist/types/modules/feature-detect/simd.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/dist/types/modules/frameQuality.d.ts

@@ -0,0 +1,10 @@
+/**
+ * detect frame quality based on comparing pixels intesivity.
+ */
+interface IData {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+export declare const getFrameQuality: ({ data, width, height }: IData) => number;
+export {};

package/dist/types/modules/heic.d.ts

@@ -0,0 +1,11 @@
+export declare class HeicModule {
+    private core;
+    constructor(core?: any);
+    processSingleImage(image: any): Promise<unknown>;
+    private heifDecode;
+    convert(e: any): Promise<{
+        imageDataArr: any[];
+        error: string;
+    }>;
+}
+export default HeicModule;

package/dist/types/modules/image.d.ts

@@ -0,0 +1,13 @@
+import { BrowserInfo } from 'detect-browser';
+export type Angle = 0 | 90 | 180 | 270;
+export declare function dataURItoBlob(dataURL: string): Blob;
+export declare const rotateImageByAngle: (src: string, angle: Angle) => Promise<unknown>;
+export declare const rotateImageByExif: (src: string, browser: BrowserInfo) => Promise<string>;
+/**
+ *
+ * @param src - string
+ * @param maxSize - integer
+ * @param browser - object
+ * @returns {Promise<DataURL>}
+ */
+export declare const resizeImage: (src: string, maxSize: number | 'none', browser: BrowserInfo) => Promise<string>;

package/dist/types/modules/initErrorHandler.d.ts

@@ -0,0 +1,10 @@
+import { CameraNotSupportedReason } from '../types/modules/camera.enum';
+/**
+ * The error object thrown when VideoRecognizer fails to open the camera feed.
+ */
+export declare class CameraError extends Error {
+    /** The reason why opening the camera failed. */
+    readonly reason: CameraNotSupportedReason;
+    constructor(reason: CameraNotSupportedReason, ...params: any[]);
+}
+export declare const CameraErrorHandler: (error: CameraError) => void;

package/dist/types/modules/licenseKeyChecker.d.ts

@@ -0,0 +1 @@
+export declare const checkCommonKey: (key: string) => Promise<void>;

package/dist/types/modules/manualUpload.d.ts

@@ -0,0 +1,7 @@
+import { Base64Image } from '../helpers/image';
+interface Base64Object {
+    data: ImageData | Base64Image | null;
+    err: boolean;
+}
+declare const dropFile: (base64Obj: Base64Object) => Promise<void>;
+export default dropFile;

package/dist/types/modules/manualUploadProcessing.d.ts

@@ -0,0 +1,30 @@
+import { Base64Image } from '../helpers/image';
+interface ICoord {
+    x: number;
+    y: number;
+}
+export interface IMRZLocation {
+    leftTop: ICoord;
+    rightTop: ICoord;
+    rightBottom: ICoord;
+    leftBottom: ICoord;
+}
+/**
+ * process manually uploaded image for MRZ
+ * @param {ImageData} smallImage - resized image data
+ * @return {Promise<boolean>}
+ */
+export declare const mrzProcess: (smallImage: ImageData) => Promise<boolean>;
+export declare const pdfProcess: (smallImage: ImageData) => boolean;
+/**
+ *
+ * @param {Base64Image} data - base64 image
+ */
+export declare const barCodeProcess: (data: Base64Image) => Promise<boolean>;
+export declare const frontProcess: (smallImage: ImageData) => Promise<boolean>;
+declare const _default: {
+    mrzProcess: (smallImage: ImageData) => Promise<boolean>;
+    pdfProcess: (smallImage: ImageData) => boolean;
+    barCodeProcess: (data: string) => Promise<boolean>;
+};
+export default _default;

package/dist/types/modules/mediaDevices.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (isiOS: boolean) => Promise<string>;
+export default _default;

package/dist/types/modules/moduleInitializer.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    hasModule: (name: any) => boolean;
+    pdf: (module: any) => any;
+    face: (module: any) => any;
+    docDetector: (module: any) => any;
+    barcode: (module: any) => any;
+};
+export default _default;

package/dist/types/modules/step-functions/face.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<any>;
+export default _default;

package/dist/types/modules/step-functions/pdf.d.ts

@@ -0,0 +1,13 @@
+declare const _default: (data: ImageData) => Promise<{
+    status: boolean;
+    predict: boolean;
+    touch: boolean;
+    image: ImageData;
+    type: string;
+    error: any;
+    coords: any[];
+    trackString: string;
+    pdfSuccessCount: number;
+    pdfCount: number;
+}>;
+export default _default;

package/dist/types/modules/step-result-processing/barcode.d.ts

@@ -0,0 +1,2 @@
+declare const barcode: (resultObject: any) => void;
+export default barcode;

package/dist/types/modules/step-result-processing/common.d.ts

@@ -0,0 +1 @@
+export declare const setDetectFace: (val: any) => void;

package/dist/types/modules/step-result-processing/mrz.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/pdf.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/simpleFace.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/volumeFace.d.ts

@@ -0,0 +1,7 @@
+import { RealFaceResultObject } from '../../types/modules/realFace';
+import { Point } from '../../helpers/geometry';
+type DrawPath = (region: Path2D, points: Point[], closePath: boolean) => void;
+export declare const drawPath: DrawPath;
+export declare const drawFacePoints: (keypointList: any, color: string) => void;
+declare const _default: (resultObject: RealFaceResultObject) => void;
+export default _default;

package/dist/types/modules/stepFunctions.d.ts

@@ -0,0 +1,5 @@
+type ModuleNames = 'mrz' | 'pdf' | 'face' | 'front' | 'barcode';
+type FunctionNames = ModuleNames | 'photo';
+declare const stepFunctionWrapper: (functionName: FunctionNames, ...args: any[]) => any;
+export declare const isStepFunctionExist: (functionName: FunctionNames) => boolean;
+export default stepFunctionWrapper;

package/dist/types/modules/stepResultProcessing.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    hasFn: (fnName: string) => boolean;
+    pdf: (resultObject: any) => void;
+    mrz: (resultObject: any) => void;
+    SimpleFace: (resultObject: any) => void;
+    VolumeFace: (resultObject: import("../types/modules/realFace").RealFaceResultObject) => void;
+    barcode: (resultObject: any) => void;
+};
+export default _default;

package/dist/types/modules/ui/Flashlight.d.ts

@@ -0,0 +1,17 @@
+declare class Flashlight {
+    private icon;
+    private onIcon;
+    private offIcon;
+    private isEnableFlashLight;
+    constructor();
+    /**
+     * switches visible of lightning icon
+     * @param {boolean} val
+     */
+    show(val: boolean): void;
+    turnOff(): void;
+    turnOn(): void;
+    get isTurnedOn(): boolean;
+    addClickEventListener(fn?: () => void): void;
+}
+export default Flashlight;

package/dist/types/modules/ui/MaskCapture.d.ts

@@ -0,0 +1,52 @@
+declare class MaskCapture {
+    #private;
+    private svg;
+    private strokeMask;
+    private successMask;
+    private type;
+    private cssVarContainer;
+    private borders;
+    private cssVars;
+    _mainContainerSizes: {
+        width: string;
+        height: string;
+    };
+    constructor(cssVarContainer: any);
+    /**
+     * get computed width and height of element
+     * @param {HTMLElement} el
+     * @return {{width: string, height: string}}
+     */
+    getSizes: (el: any) => {
+        width: string;
+        height: string;
+    };
+    get svgSizes(): {
+        width: string;
+        height: string;
+    };
+    get strokeSizes(): {
+        width: number;
+        height: number;
+    };
+    get strokeLength(): number;
+    set sizes({ width, height }: {
+        width: any;
+        height: any;
+    });
+    set fillPercentage(percentage: any);
+    /**
+     * sets the type of capturing mask and it position on screen
+     * @param {VideoFacingModeEnum} type - 'environment', 'user'
+     */
+    set maskType(type: any);
+    /**
+     * resizes frame based on width and height of main container
+     * @param {{width: number, height: number}} param - width and height of main container
+     */
+    set mainContainerSizes({ width, height }: {
+        width: any;
+        height: any;
+    });
+}
+export default MaskCapture;

package/dist/types/modules/ui/MessageBox.d.ts

@@ -0,0 +1,19 @@
+type MessageBoxType = 'error' | 'primary' | null;
+type CallbackHandler = (event: Event) => void;
+declare class MessageBox {
+    #private;
+    constructor();
+    private setClass;
+    get type(): MessageBoxType;
+    /**
+     * sets the message in message-box
+     * @param {string} text - text to set in message-box
+     * @param {'error', 'primary'} type - type of message. Default: primary
+     */
+    message(text?: string, type?: string): void;
+    updateByTypesCount(typesCount?: number): void;
+    addChangeDocumentTypeListener(handler: CallbackHandler): void;
+    removeAllChangeDocumentTypeListener(): void;
+    setCaretVisible(val: boolean): void;
+}
+export default MessageBox;