@idscan/idvc2 2.5.6 → 2.5.7

package/dist/types/helpers/color.d.ts

@@ -0,0 +1,14 @@
+export interface Color {
+    rgbaToGrayscale(pixels: Uint8Array | number[], rgba: number[], nrows: number, ncols: number): void;
+}
+type TypedArray = Uint8Array | Uint8ClampedArray | Float32Array;
+export declare enum Normalization {
+    STANDART = 255,
+    HALF = 127.5,
+    WITHOUT = 1
+}
+export declare const rgbaToGrayscale: (pixels: Uint8Array | number[], rgba: number[], nrows: number, ncols: number) => void;
+export declare const normalize: <T extends TypedArray>(arr: T, normalization?: Normalization) => T;
+export declare const rgbaToRgb: (rgba: ImageData, normalization?: Normalization) => Float32Array;
+declare const _default: Color;
+export default _default;

package/dist/types/helpers/dataManipulation.d.ts

@@ -0,0 +1,27 @@
+interface Entity {
+    value: string;
+    name: string;
+    status: 'valid' | 'invalid';
+}
+/**
+ * convert mrz parsed data to html represent
+ * @param {Array} data - mrz parsed data
+ */
+export declare const mrzToHtml: (data: Entity[]) => HTMLElement;
+/**
+ * convert pdf parsed data to html represent
+ * @param {Array} data - pdf parsed data
+ */
+export declare const pdfToHtml: (data: Entity[]) => HTMLElement;
+/**
+ * convert barcode parsed data to html represent
+ * @param {String} data - barcode parsed data
+ */
+export declare const barcodeToHtml: (data: string) => HTMLElement;
+/**
+ *
+ * @param {*} data - data to represent in HTML
+ * @param {String} type - type of parsed data maybe mrz|pdf|barcode
+ */
+declare const jsonToHtml: (data: string | Entity[], type: 'mrz' | 'pdf' | 'barcode') => false | HTMLElement;
+export default jsonToHtml;

package/dist/types/helpers/detectLanguage.d.ts

@@ -0,0 +1,3 @@
+import { SupportedLanguage } from '../environment/langs';
+declare const _default: (language?: SupportedLanguage) => void;
+export default _default;

package/dist/types/helpers/geometry.d.ts

@@ -0,0 +1,35 @@
+export type Point = [number, number];
+export interface ICoord {
+    x: number;
+    y: number;
+}
+export interface Geometry {
+    distanceBetweenPoints(p1: Point, p2: Point): number;
+    distanceBetweenPointsX(p1: Point, p2: Point): number;
+    distanceBetweenPointsXoR(p1: Point, p2: Point): number;
+    sizeByTwoPoints(p1: Point, p2: Point): number;
+    rectCenter(start: Point, end: Point): Point;
+    angleBetweenTwoVectors(vector1: number[], vector2: number[]): number;
+    triangleArea(a: number, b: number, c: number): number;
+}
+/**
+ * calculates distance between two points
+ * @param {Number[]} p1 - first coord [x1, y1]
+ * @param {Number[]} p2 - second coord [x2, y2]
+ * @return {number}
+ */
+export declare const distanceBetweenPoints: (p1: Point, p2: Point) => number;
+/**
+ * calculates distance between two points
+ * @param {Number[]} p1 - first coord [x1, y1]
+ * @param {Number[]} p2 - second coord [x2, y2]
+ * @return {number}
+ */
+export declare const distanceBetweenPointsX: (p1: Point, p2: Point) => number;
+export declare const sizeByTwoPoints: (p1: Point, p2: Point) => number;
+export declare const rectCenter: (start: Point, end: Point) => Point;
+export declare const angleBetweenTwoVectors: (vector1: number[], vector2: number[]) => number;
+export declare const distanceBetweenPointsXoR: (p1: Point, p2: Point) => number;
+export declare const triangleArea: (a: number, b: number, c: number) => number;
+declare const geometry: Geometry;
+export default geometry;

package/dist/types/helpers/html.d.ts

@@ -0,0 +1,26 @@
+interface AttributeCollection {
+    [name: string]: string | boolean;
+}
+type CreateElement = (tagName?: string, params?: AttributeCollection | null, classNames?: string[], parent?: HTMLElement | null, children?: HTMLElement[]) => HTMLElement;
+/**
+ * create and return HTMLElement
+ * @param { String } tagName - default 'div'
+ * @param { AttributeCollection | null } params
+ * @param { Array<String> } classNames - array of class names
+ * @param { HTMLElement } parent - element to which needs append created element
+ * @param { Array<HTMLElement> } children  - elements which will appended to created element
+ * @returns { HTMLElement } - created element
+ */
+export declare const createElement: CreateElement;
+/**
+ * creates a script tag
+ * @param {string} scriptUrl - url to remote script
+ * @param {'module'} type - create script as module
+ * @return {Promise<unknown>}
+ */
+export declare const loadScript: (scriptUrl: string) => Promise<unknown>;
+declare const _default: {
+    createElement: CreateElement;
+    loadScript: (scriptUrl: string) => Promise<unknown>;
+};
+export default _default;

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

@@ -0,0 +1,36 @@
+import { ICrop } from './ts/common';
+export type Base64Image = string;
+export type RGBAColor = string;
+export type RGBColor8 = Uint8ClampedArray;
+export type RGBColor32 = Float32Array;
+type PixelPosition = number;
+type Segmentize = (binarizedImg: Uint8ClampedArray, width: number) => Set<PixelPosition>[];
+type Binarize = (img: ImageData, threshold?: number) => Uint8ClampedArray;
+type GetResizedSizes = (size: number, baseSize: IBaseSize) => ISize;
+export interface IOffset {
+    top: number;
+    left: number;
+}
+/**
+ * { width: number, height: number }
+ */
+export interface ISize {
+    width: number;
+    height: number;
+}
+interface IBaseSize {
+    baseWidth: number;
+    baseHeight: number;
+}
+export declare const generateFaceColorFromAngle: (angle: number) => RGBAColor;
+/**
+ *
+ * @param {ImageData} iData
+ * @param {number} threshold
+ * @return number[] - black and whited array;
+ */
+export declare const binarize: Binarize;
+export declare const segmentize2: Segmentize;
+export declare const getResizedSizes: GetResizedSizes;
+export declare const getCrop: (src: ISize, dst: ISize) => ICrop;
+export {};

package/dist/types/helpers/imageprocessing.d.ts

@@ -0,0 +1,11 @@
+import { ILoopResult } from '../environment/loopResult';
+declare const _default: {
+    processImage4: () => {
+        status: boolean;
+        cancel: boolean;
+        touch: boolean;
+        image: ImageData;
+    };
+    processImage5: (sideDetect?: boolean) => ILoopResult;
+};
+export default _default;

package/dist/types/helpers/licenceKeyError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * sets licence key error
+ * @param {Number} errorCode
+ */
+declare const _default: (errorCode?: number) => void;
+export default _default;

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

@@ -0,0 +1,7 @@
+export declare const resizeImageForStepProcessing: (data: any) => Promise<ImageData>;
+declare const _default: {
+    getSmallImage: (data: string) => Promise<ImageData>;
+    setCurrentImage: (data: any) => Promise<void>;
+    fixOrientation: (image: HTMLImageElement) => Promise<ImageData>;
+};
+export default _default;

package/dist/types/helpers/math.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Compute the mean value of values or a list with values.
+ * @param {number[]|number} args - (a, b, c) or []
+ * @returns {number}
+ */
+export declare const mean: (...args: number[] | [number[]]) => number;
+type NormalizationFunctionNames = 'unbiased' | 'biased' | 'uncorrected';
+export declare const normalizationFunction: {
+    unbiased: (arr: number[]) => number;
+    biased: (arr: number[]) => number;
+    uncorrected: (arr: number[]) => number;
+};
+/**
+ * calculate standard deviation or return -1
+ * @param {Number[]} vals
+ * @param {'unbiased'|'biased'|'uncorrected'} normalization - 'unbiased' - divide by n - 1,
+ * 'uncorrected' - divide by n,
+ * 'biased' - divide by n + 1. default 'unbiased'.
+ * @param {number} fixed - how many digits after the decimal.
+ * @return number -1 if input values are wrong
+ */
+export declare const STD: (vals: number[], normalization?: NormalizationFunctionNames, fixed?: number) => number;
+/**
+ * get random integer number from range, included min and max
+ * @param {number} min
+ * @param {number} max
+ * @return {number}
+ */
+export declare const randomIntFromInterval: (min: number, max: number) => number;
+declare const _default: {
+    randomIntFromInterval: (min: number, max: number) => number;
+    mean: (...args: number[] | [number[]]) => number;
+    STD: (vals: number[], normalization?: NormalizationFunctionNames, fixed?: number) => number;
+};
+export default _default;

package/dist/types/helpers/mobileChecker.d.ts

@@ -0,0 +1,15 @@
+export declare const isiOS: () => boolean;
+export declare const checkTouchPoints: () => boolean;
+export declare const checkIsTouchScreen: () => boolean;
+/**
+ *
+ * @param {Number} maxWidth - preferable max width device
+ */
+export declare const isMobile: () => {
+    isMobileUserAgent: () => boolean;
+    isTouchable: () => boolean;
+    isTouchScreen: () => boolean;
+    isSurface: () => boolean;
+};
+declare const checkIfMobile: () => boolean;
+export default checkIfMobile;

package/dist/types/helpers/numbers.d.ts

@@ -0,0 +1,2 @@
+import { GetRandomNumber } from '../types/helpers/numbers';
+export declare const getRandomNumber: GetRandomNumber;

package/dist/types/helpers/step-background.d.ts

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

package/dist/types/helpers/strings.d.ts

@@ -0,0 +1,9 @@
+import { Base64Image } from './image';
+export declare const encodeMeta: (metadata: any) => string;
+export declare const decodeMeta: (str: string) => any;
+export declare const base64ToArrayBuffer: (base64: string) => Uint8Array;
+export declare const getDataFromBase64Img: (imgString: Base64Image) => string;
+export declare const splitWordByUpperLetters: (word: string) => string[];
+export declare const normalizeCamelCase: (word: string) => string;
+export declare const removeHtmlEntities: (str: string) => string;
+export declare const normalizeString: (str: string) => string;

package/dist/types/helpers/time.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number} ms
+ * @returns {Promise<>}
+ */
+export declare const timeout: (ms: number) => Promise<unknown>;
+export declare const nextFrame: (fn?: () => Promise<any> | void) => Promise<unknown>;
+declare const _default: {
+    timeout: (ms: number) => Promise<unknown>;
+};
+export default _default;

package/dist/types/helpers/ts/common.d.ts

@@ -0,0 +1,17 @@
+export type PartialRecord<T extends string, U> = {
+    [V in T]?: U;
+};
+export interface IPosition {
+    x: number;
+    y: number;
+}
+export interface IOffset {
+    left: number;
+    top: number;
+}
+export interface ISize {
+    width: number;
+    height: number;
+}
+export interface ICrop extends ISize, IPosition {
+}

package/dist/types/helpers/updateSelecetTypes.d.ts

@@ -0,0 +1,3 @@
+import SelectDocumentType from '../modules/ui/SelectDocumentType';
+declare const updateSelectTypes: (selectDocumentType: SelectDocumentType) => void;
+export default updateSelectTypes;

package/dist/types/helpers/validators.d.ts

@@ -0,0 +1,44 @@
+/**
+ * check value to be boolean
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidBool: (val: any) => boolean;
+/**
+ * check value to be object
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidObject: (val: any) => boolean;
+/**
+ * check value to be function
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidFunction: (val: any) => boolean;
+/**
+ * check value to be string
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidString: (val: any) => boolean;
+/**
+ * check value to be finite number
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidNumber: (val: any) => boolean;
+/**
+ * validates string in given array and set its value
+ * @param {String[]} availableValues - array of available values
+ * @param {String} valueToSet - value that should be set
+ */
+export declare const isValidDistinctStringInArray: (availableValues: string[], valueToSet: string) => boolean;
+declare const _default: {
+    isValidBool: (val: any) => boolean;
+    isValidFunction: (val: any) => boolean;
+    isValidString: (val: any) => boolean;
+    isValidNumber: (val: any) => boolean;
+    isValidDistinctStringInArray: (availableValues: string[], valueToSet: string) => boolean;
+};
+export default _default;

package/dist/types/idvc.d.ts

@@ -0,0 +1,19 @@
+import './assets/scss/index.scss';
+import { IConfig } from './modules/Config';
+import { SupportedLanguage } from './environment/langs';
+import { IDocumentTypeConfig } from './modules/validator';
+declare class VideoCapturing {
+    constructor(config: IConfig);
+    private init;
+    /**
+     *
+     * @param language
+     */
+    changeLanguage(language: SupportedLanguage): void;
+    get version(): string;
+    resetAllSteps(): void;
+    reloadComponent(newConfig: Partial<IConfig>): void;
+    updateDocumentTypes(documentTypes: IDocumentTypeConfig): void;
+    showSpinner(val: any): void;
+}
+export default VideoCapturing;

package/dist/types/initialize.d.ts

@@ -0,0 +1,12 @@
+export declare const typesInit: () => void;
+declare const _default: {
+    typesInit: () => void;
+    checkCompatibility: () => void;
+    start: () => void;
+    isCameraRequired: () => any;
+    isUploaderRequired: () => any;
+    isCameraNeeded: () => any;
+    detectAndSetBrowser: () => void;
+    detectAndSetRealFaceMode: () => void;
+};
+export default _default;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+declare const _default: ({ commonLicenseKey }: {
+    commonLicenseKey: any;
+}) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,3 @@
+export declare const faceModuleLoader: (core: any) => Promise<void>;
+declare const loadMeshFace: () => Promise<void>;
+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,13 @@
+import { IMRZLocation } from './modules/manualUploadProcessing';
+import { Cancel } from './types/loop';
+export interface IMrzCoords {
+    locations: IMRZLocation;
+    color: 'green' | 'yellow';
+}
+export declare const loop: () => Promise<false>;
+declare const _default: {
+    loop: () => Promise<false>;
+    stopProccesing: () => void;
+    cancel: Cancel;
+};
+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,131 @@
+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;
+    /** */
+    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 only one document type is configured in the documentTypes array AND 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;
+    /** 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;
+}
+export default Config;

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

@@ -0,0 +1,11 @@
+import { ClassLocalExitType } from '../neural models/classLocal/exits';
+type Status = 'PENDING' | 'FULFILLED';
+interface FillingQueueResult {
+    promise: Promise<ClassLocalExitType>;
+    status: Status;
+}
+export declare const clearQueue: () => void;
+export declare const fillingQueue: (smallImage?: ImageData, isUpload?: boolean) => FillingQueueResult;
+export declare const getBestFrame: () => ImageData;
+export declare const dropPromise: () => 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;
+}