@idscan/idvc2 2.6.0 → 2.6.2

package/dist/types/loader/loadFrontModels.d.ts

@@ -0,0 +1,3 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+declare const loadFrontModels: () => Promise<Array<NeuralModelInitializer> | undefined>;
+export default loadFrontModels;

package/dist/types/loader/loaderBlur.d.ts

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

package/dist/types/loader/loaderClassLocal.d.ts

@@ -0,0 +1,3 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+declare const _default: () => Promise<Array<NeuralModelInitializer>>;
+export default _default;

package/dist/types/loader/loaderFace.d.ts

@@ -0,0 +1,3 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+declare const load: () => Promise<Array<NeuralModelInitializer> | undefined>;
+export default load;

package/dist/types/loader/loaderMRZ.d.ts

@@ -0,0 +1,5 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+declare const _default: ({ commonLicenseKey }: {
+    commonLicenseKey: any;
+}) => Promise<Array<NeuralModelInitializer> | undefined>;
+export default _default;

package/dist/types/loader/loaderMeshFace.d.ts

@@ -0,0 +1,4 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+export declare const faceModuleLoader: (core: any) => Promise<void>;
+declare const loadMeshFace: () => Promise<Array<NeuralModelInitializer>>;
+export default loadMeshFace;

package/dist/types/loader/loaderPDF.d.ts

@@ -0,0 +1,3 @@
+import c from '../context';
+declare const load: ({ pdf417key }: typeof c.keys) => Promise<void>;
+export default load;

package/dist/types/loader/loaderUploadMode.d.ts

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

package/dist/types/loader/loaderZXing.d.ts

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

package/dist/types/loop.d.ts

@@ -0,0 +1,15 @@
+import { IMRZLocation } from './modules/manualUploadProcessing';
+import { Cancel } from './types/loop';
+export interface IMrzCoords {
+    locations: IMRZLocation;
+    color: 'green' | 'yellow';
+}
+export declare const unmountIDVC: () => void;
+export declare const loop: () => Promise<false>;
+declare const _default: {
+    loop: () => Promise<false>;
+    stopProccesing: () => void;
+    cancel: Cancel;
+    unmountIDVC: () => void;
+};
+export default _default;

package/dist/types/loopControl.d.ts

@@ -0,0 +1,10 @@
+export declare const setIsStarted: (val: boolean) => void;
+export declare const stop: () => void;
+export declare const setVisibleVideo: () => Promise<void>;
+export declare const start: () => Promise<void>;
+declare const _default: {
+    start: () => Promise<void>;
+    stop: () => void;
+    setIsStarted: (val: boolean) => void;
+};
+export default _default;

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

@@ -0,0 +1,28 @@
+export declare class BarcodeModule {
+    private module;
+    private isAllocate;
+    private buffer;
+    private readonly res;
+    private stringLib;
+    constructor(core: any);
+    init(stringLib: any): void;
+    allocate(buffer: any): void;
+    free(): void;
+    result(status?: boolean, image?: any, touch?: boolean, text?: string): {
+        status: boolean;
+        image: any;
+        touch: boolean;
+        text: string;
+        cancel: boolean;
+        type: string;
+    };
+    process(data: any, origData: any): {
+        status: boolean;
+        image: any;
+        touch: boolean;
+        text: string;
+        cancel: boolean;
+        type: string;
+    };
+}
+export default BarcodeModule;

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

@@ -0,0 +1,140 @@
+import { IStepConfig, ValidationFn } from '../defaultConfig';
+import { RealFaceMode } from '../environment/realFaceModes';
+import { SupportedLanguage } from '../environment/langs';
+import { StepType } from '../environment/stepsDescription';
+import { DocumentTypeName } from '../environment/documentTypes';
+import { IDocumentTypeConfig } from './validator';
+import { IStepCallback } from './Step';
+import { IDataForSubmit } from '../util';
+/**
+ * @param {string} el,
+ * @param {string} licenseKey,
+ * @param {RealFaceMode} realFaceMode,
+ * @param {IDocumentTypeConfig | null} documentTypes,
+ * @param {boolean} autoContinue?,
+ * @param {number} resizeUploadedImage?,
+ * @param {boolean} fixFrontOrientAfterUpload?,
+ * @param {boolean} useCDN?,
+ * @param {string} networkUrl?,
+ */
+export interface IConfig {
+    /** this is the id of the html tag on the page where the web library will be displayed. Default: videoCapturingEl */
+    el: string;
+    /** license key for the web library provided for you by Idscan.net */
+    licenseKey: string;
+    /**
+     * an option that enables advanced image capturing with volumetric face detection. Available values: 'auto', 'all', 'none'
+     *  - Auto - enable "realFaceMode" only for iPhone
+     *  - All - enable "realFaceMode" for all devices
+     *  - None - disable this option
+     */
+    realFaceMode: RealFaceMode;
+    /**
+     * the array contains an object per document type that is configured. Each object has the document type listed in the type field and then in its steps array you can configure what steps you want the user to complete and what capture modes you will allow (i.e. uploader and/or video)
+     *
+     * Available Document Types
+     *
+     *   - ID (1) – USA driver license and USA ID (non-driver license), Canadian driver licenses
+     *   - Passport (2) – with 2 lines MRZ
+     *   - PassportCard (3) – with 3 lines MRZ (most European IDs, USA passports/cards)
+     *   - GreenCard (6) – USA Permanent Resident Cards (only MRZ)
+     *   - InternationalId (7) – Internationally approved U.S. IDs with 3 lines MRZ
+     *   - VIN (8) – Vehicle Identification Numbers
+     *   - Barcode (9) – 1-D and 2-D barcodes
+     *
+     * Available Step Types
+     *
+     *   - front – capturing the front side of a document
+     *   - mrz – detection and capturing of the MRZ of a document
+     *   - pdf – detection and capturing of pdf417 of a document
+     *   - face – detection and capturing of the end user's face using the front camera
+     *   - barcode – detection and capturing of 1 dimensional (barcodes) or 2 dimensional (qr codes)
+     *   - photo – capturing of a vehicle identification number
+     *
+     * Available Capture Mode
+     *
+     *   - uploader - uploading an image from the file system
+     *   - video - capturing an image using the auto capture feature
+     */
+    documentTypes: IDocumentTypeConfig | null;
+    /** the setting that enables the automatic transition from one step to the next step. Default */
+    autoContinue?: boolean;
+    /** sets the maximum size in pixels (of the largest of the height or width) for a manually uploaded picture */
+    resizeUploadedImage?: number;
+    /** this setting will change the orientation of a front step's image if it is not horizontal when it is uploaded */
+    fixFrontOrientAfterUpload?: boolean;
+    /** set to true if you prefer to load neural networks from a content delivery network instead of from your web server */
+    useCDN?: boolean;
+    /** Path to the folder with neural networks. Specify the path on the server if you need to remove the folder to another location */
+    networkUrl?: string;
+    /** the web library supports two languages, english and spanish. English uses en and Spanish uses es */
+    language?: SupportedLanguage;
+    /**
+     * Path to the folder with chunks. Specify the path on the server if you need to remove the folder to another location.
+     */
+    chunkPublicPath?: string;
+    /**
+     * switches on/off the button to show guide lines
+     */
+    isShowGuidelinesButton?: boolean;
+    /**
+     * if this setting is set to false the document type dialog will not be displayed to the end user
+     */
+    isShowDocumentTypeSelect?: boolean;
+    /**
+     * option to show the button 'submit' after capturing all the images. If the button is turned off, an event will automatically fire that triggers the submit event handler
+     */
+    showSubmitBtn?: boolean;
+    /**
+     * This option switches on/off the HEIC image processing (HEIC is Apple’s proprietary version of the Image File format). It’s possible to upload an image of this type only using a Mac/MacBook
+     */
+    useHeic?: boolean;
+    /**
+     * This option switches image format, that used for image processing. Available values: 'jpeg', 'png', 'webp'
+     */
+    processingImageFormat?: string;
+    /**
+     * This option switches on/off the displaying document titles
+     */
+    hideDocumentTitle?: boolean;
+    /** callback-function which will be called after guidelines button. */
+    clickGuidlines?: () => void;
+    /** function which will be called after each step completes */
+    onChange?: (data: IStepCallback) => void;
+    /**
+     * function which will be called after the retake button is clicked
+     * @param data - Step object of current step
+    */
+    onRetakeHook?: (data: IStepCallback) => void;
+    /** the function that will be called on the component mounted. */
+    onMounted?: () => void;
+    /**
+     *  function which will be called after reset all the steps button is clicked
+     *  @param data - Step objects of current pipeline
+    */
+    onReset?: (data: IDataForSubmit) => void;
+    /** function which will be called in case the camera is not available */
+    onCameraError?: (data: Error) => void;
+    /** function which will be called after clicking the submit button */
+    submit?: (data: IDataForSubmit) => void;
+}
+declare class Config implements IConfig {
+    el: string;
+    commonStepTypes: Set<StepType>;
+    types: DocumentTypeName[];
+    steps: IStepConfig[];
+    documentTypes: IDocumentTypeConfig | null;
+    licenseKey: string;
+    autoContinue: boolean;
+    resizeUploadedImage: number;
+    fixFrontOrientAfterUpload: boolean;
+    useCDN: boolean;
+    networkUrl: string;
+    realFaceMode: "all" | "auto" | "none";
+    language: any;
+    constructor(configObject: IConfig);
+    getFunction(validationFn: ValidationFn): false | import("./validation/ValidateElement").default | import("./validation/ValidateBool").default | import("./validation/ValidateStringInArray").default | import("./validation/ValidateDocumentTypes").default | import("./validation/ValidateFunction").default | import("./validation/ValidateNumber").default | import("./validation/ValidateString").default;
+    validate(configObject: IConfig): void;
+    normalize(configObject: IConfig): void;
+}
+export default Config;

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

@@ -0,0 +1,16 @@
+import { ClassLocalExitType } from '../neural models/classLocal/exits';
+export type Status = 'PENDING' | 'FULFILLED';
+interface ProcessUploadedImageResult {
+    side: ClassLocalExitType;
+    perimeter: 'low' | 'ok';
+}
+interface FillingQueueResult {
+    promise: Promise<ClassLocalExitType>;
+    status: Status;
+}
+export declare const clearQueue: () => void;
+export declare const processUploadedImage: (smallImage: ImageData) => Promise<ProcessUploadedImageResult>;
+export declare const fillingQueue: (smallImage?: ImageData) => Promise<FillingQueueResult>;
+export declare const getBestFrame: () => ImageData;
+export declare const dropPromise: () => void;
+export {};

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

@@ -0,0 +1,20 @@
+import { StepType } from '../environment/stepsDescription';
+interface IStepLog {
+    start: number;
+    end: number;
+    duration: number;
+}
+export default class Logger {
+    data: {
+        steps: Record<StepType, IStepLog>;
+    } | Record<string, any>;
+    currentStep: string;
+    constructor();
+    set step(step: string);
+    get step(): string;
+    get stepData(): any;
+    get steps(): {};
+    start(): void;
+    end(): void;
+}
+export {};

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

@@ -0,0 +1,10 @@
+export default class MetaData {
+    userAgent: string;
+    capturedMethod: string;
+    version: string;
+    logs: Record<string, any>;
+    constructor(version?: string);
+    captureMethod(steps: any): void;
+    getMetaData(steps: any): {};
+    prepareMetaDataForSubmit(steps: any): string;
+}

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

@@ -0,0 +1,75 @@
+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;
+    isNotMRZ: boolean;
+}
+export declare class MrzModule {
+    w: number;
+    h: number;
+    successCount: number;
+    worker: Worker;
+    model: MrzModel;
+    isInitialized: boolean;
+    isProcessing: boolean;
+    MIN_MRZ_FRAMES: number;
+    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,80 @@
+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;
+        isSuccessProcess: boolean;
+    };
+}
+export default PdfModule;

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

@@ -0,0 +1,70 @@
+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;
+    cameraInfo: Record<string, any>;
+    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/blurModule.d.ts

@@ -0,0 +1,6 @@
+export declare class BlurModule {
+    worker: Worker;
+    constructor(worker: Worker);
+    process(imageData: ImageData): Promise<unknown>;
+    drop(): void;
+}

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, IAdditionalConstrains, StartCamera, VideoDevice } 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: (additionalConstrains: IAdditionalConstrains) => Promise<VideoDevice[] | CameraError>;
+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;