@idscan/idvc2 2.6.0 → 2.6.2

package/dist/types/modules/validation/validatorFactory.d.ts

@@ -0,0 +1,10 @@
+import { ValidationFn } from '../../defaultConfig';
+import ValidateElement from './ValidateElement';
+import ValidateBool from './ValidateBool';
+import ValidateDistinctStringInArray from './ValidateStringInArray';
+import ValidateDocumentTypes from './ValidateDocumentTypes';
+import ValidateFunction from './ValidateFunction';
+import ValidateNumber from './ValidateNumber';
+import ValidateString from './ValidateString';
+declare const validatorFactory: (name: ValidationFn) => false | ValidateElement | ValidateBool | ValidateDistinctStringInArray | ValidateDocumentTypes | ValidateFunction | ValidateNumber | ValidateString;
+export default validatorFactory;

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

@@ -0,0 +1,12 @@
+import { DocumentTypeName } from '../environment/documentTypes';
+import { DefaultConfigName, IStepConfig } from '../defaultConfig';
+export type IDocumentTypeConfig = {
+    type: DocumentTypeName;
+    steps: IStepConfig[];
+}[];
+type SimpleValidate<T> = (val: T, fallback: T, configName: DefaultConfigName) => any;
+type OneOfArray<T> = (valueToSet: T, defaultValue: T, configName: DefaultConfigName, availableValues: T[]) => any;
+export interface IValidator<T> {
+    validate: SimpleValidate<T> | OneOfArray<T>;
+}
+export {};

package/dist/types/neural models/Provider.d.ts

@@ -0,0 +1,4 @@
+export declare enum Provider {
+    WASM = "wasm",
+    WEBGL = "webgl"
+}

package/dist/types/neural models/anglesModel.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from './Provider';
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+interface Prediction {
+    label: string;
+    score: number;
+}
+export default class AnglesModel extends NeuralModel {
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    predict(rgb: RGBColor32): Promise<import("onnxruntime-web").InferenceSession.OnnxValueMapType>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): Promise<Prediction[]>;
+    interpret(data: Float32Array): Prediction[];
+}
+export {};

package/dist/types/neural models/blazeFaceModel.d.ts

@@ -0,0 +1,27 @@
+import { Provider } from './Provider';
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+import { BlazeFaceResult } from '../types/neural models/blazeFace';
+import { ICrop } from '../helpers/ts/common';
+export declare const ELEMENT_NUM_OF_ANCHOR = 16;
+export declare const ANCHOR_GRID_SIZE: readonly [readonly [16, 16], readonly [8, 8]];
+export declare const ANCHOR_NUM: readonly [2, 6];
+export default class BlazeFaceModel extends NeuralModel {
+    private anchorList;
+    private scoreList;
+    private regressorList;
+    private thresholdLogit;
+    private bBoxList;
+    private keyPoints;
+    private origSize;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    createAnchor(): void;
+    processImage(crop: ICrop): BlazeFaceResult;
+    predict(rgb: RGBColor32): Promise<void>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | ImageData, dstCanvas?: HTMLCanvasElement): Promise<BlazeFaceResult>;
+    private getBoundingBoxes;
+    private calculateIoU;
+    private nms;
+    private fixInScreen;
+    private fillKeyPoints;
+}

package/dist/types/neural models/classLocal/exits.d.ts

@@ -0,0 +1,4 @@
+export type ClassLocalExitType = 'Back' | 'BackWithoutBarcode' | 'Front' | 'None';
+export declare const exits: ClassLocalExitType[];
+export default exits;
+export declare const validBackExits: Set<string>;

package/dist/types/neural models/classLocalModel.d.ts

@@ -0,0 +1,28 @@
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+import { ClassLocalExitType } from './classLocal/exits';
+import { Bbox } from '../types/geometry';
+import { IOffset, ISize } from '../helpers/ts/common';
+/**
+ * perimeterInPercents: document perimeter in percents
+ */
+export interface InterpretClassLocalRes {
+    side: ClassLocalExitType;
+    bbox: Bbox;
+    perimeterInPercents: ISize;
+}
+interface Prediction {
+    label: ClassLocalExitType;
+    score: number;
+}
+export type PredictionList = Prediction[];
+export default class ClassLocalModel extends NeuralModel {
+    private canvasSize;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    setSizes({ height, width }: ISize): void;
+    predict(rgb: RGBColor32): Promise<import("onnxruntime-web").InferenceSession.OnnxValueMapType>;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement | ImageData, dstCanvas?: HTMLCanvasElement, offsets?: IOffset, cropSizes?: ISize): Promise<any[] | InterpretClassLocalRes>;
+    interpret(classifierData: Float32Array, bboxData: Float32Array): InterpretClassLocalRes;
+}
+export {};

package/dist/types/neural models/meshFaceModel.d.ts

@@ -0,0 +1,17 @@
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+import { IBoundingBbox, KeyPointList } from '../types/neural models/blazeFace';
+import { FaceMeshPrediction } from '../types/neural models/meshFace';
+import { ICrop, ISize } from '../helpers/ts/common';
+export default class MeshFaceModel extends NeuralModel {
+    origSize: ISize;
+    crop: ICrop;
+    landmarkList: Float32Array;
+    keypointList: KeyPointList;
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    preProcess(bbox: IBoundingBbox): void;
+    predict(rgb: RGBColor32): Promise<FaceMeshPrediction>;
+    prepareMesh(src: HTMLCanvasElement | HTMLVideoElement, dst: HTMLCanvasElement): ImageData;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): Promise<FaceMeshPrediction>;
+}

package/dist/types/neural models/mrzModel.d.ts

@@ -0,0 +1,20 @@
+import { InferenceSession } from 'onnxruntime-web';
+import NeuralModel from './neuralModel';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+interface Prediction {
+    value: string;
+    confidence: number;
+}
+export type PredictionList = Prediction[];
+export default class MrzModel extends NeuralModel {
+    promiseList: Promise<InferenceSession.OnnxValueMapType>[];
+    predictionList: PredictionList[];
+    constructor(url?: string, provider?: Provider, wasmPaths?: string);
+    predict(rgb: RGBColor32): Promise<InferenceSession.OnnxValueMapType>;
+    predictFromArray(input: Float32Array, batchSize: number): Promise<PredictionList[]>;
+    interpret(data: Float32Array): PredictionList;
+    get isLoading(): boolean;
+    predictFromImage(input: any, dstCanvas: any): void;
+}
+export {};

package/dist/types/neural models/neuralModel.d.ts

@@ -0,0 +1,21 @@
+import { InferenceSession } from 'onnxruntime-web';
+import { Provider } from './Provider';
+import { RGBColor32 } from '../helpers/image';
+export type NeuralModelInitializer = () => Promise<void>;
+declare abstract class NeuralModel {
+    private readonly model;
+    private readonly provider;
+    private url;
+    protected loading: boolean;
+    protected session: InferenceSession;
+    constructor(model?: string, provider?: Provider, url?: string);
+    initialize(): Promise<void>;
+    createSrc(input: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | ImageData, id?: string): HTMLCanvasElement | HTMLVideoElement;
+    prepareUri(url: string): void;
+    initWasmPath(): void;
+    initWasm(): Promise<void>;
+    init(): Promise<void>;
+    abstract predict(rgb: RGBColor32): any;
+    abstract predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): unknown;
+}
+export default NeuralModel;

package/dist/types/neural models/preload.d.ts

@@ -0,0 +1,7 @@
+import NeuralModel from './neuralModel';
+import { RGBColor32 } from '../helpers/image';
+export default class Preload extends NeuralModel {
+    constructor(wasmPaths: any);
+    predict(rgb: RGBColor32): void;
+    predictFromImage(input: HTMLCanvasElement | HTMLImageElement, dstCanvas?: HTMLCanvasElement): unknown;
+}

package/dist/types/stepProcessing.d.ts

@@ -0,0 +1,27 @@
+export declare const generateSteps: () => void;
+export declare const updateSteps: () => void;
+export declare const changeStep: (nextStepNumber: number) => void;
+export declare const getNextStep: () => number;
+export declare const changeStepAuto: () => void;
+export declare const updateStepImgCallback: () => void;
+export declare const submitIfFullSteps: (payload?: {}) => void;
+export declare const resetStepResults: (stepIndex?: number) => void;
+export declare const again: () => void;
+export declare const setStepImage: () => Promise<void>;
+/**
+ * emits change function,
+ * emit change step function and
+ * emit submit function if all steps filled with image
+ * @param {Boolean} isNeedToChangeStep - is need to change step
+ */
+export declare const emitCurrentStepChangeImage: (isNeedToChangeStep?: boolean) => void;
+declare const _default: {
+    changeStepAuto: () => void;
+    updateStepImgCallback: () => void;
+    generateSteps: () => void;
+    submitIfFullSteps: (payload?: {}) => void;
+    again: () => void;
+    resetStepResults: (stepIndex?: number) => void;
+    updateSteps: () => void;
+};
+export default _default;

package/dist/types/types/enums/realFace.d.ts

@@ -0,0 +1,4 @@
+export declare enum RealFaceTurnSide {
+    LEFT = 0,
+    RIGHT = 1
+}

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

@@ -0,0 +1,20 @@
+export declare enum CameraType {
+    Back = "environment",
+    Front = "user"
+}
+export declare enum CameraNotSupportedReason {
+    /** navigator.mediaDevices.getUserMedia
+     * is not supported by current browser for current context.
+    * */
+    MediaDevicesNotSupported = "MediaDevicesNotSupported",
+    /** Camera with requested features is not available on current device. */
+    CameraNotFound = "CameraNotFound",
+    /** Camera access was not granted by the user. */
+    CameraNotAllowed = "CameraNotAllowed",
+    /** Unable to start playing because camera is already in use. */
+    CameraInUse = "CameraInUse",
+    /** Camera is currently not available due to a OS or hardware error. */
+    CameraNotAvailable = "CameraNotAvailable",
+    /** Camera with requested features is not available on current device when needs document verification */
+    CameraNotFoundInVerification = "CameraNotFoundInVerification"
+}

package/dist/types/ui.d.ts

@@ -0,0 +1,90 @@
+import ForceBtn from './modules/ui/forceCaptruringBtn';
+import { ISize } from './helpers/image';
+import SelectDocumentType from './modules/ui/SelectDocumentType';
+import MessageBox from './modules/ui/MessageBox';
+import MaskCapture from './modules/ui/MaskCapture';
+import Flashlight from './modules/ui/Flashlight';
+import { IManualSwitchBtn } from './modules/ui/manualSwitchBtn';
+import CanvasUi from './modules/ui/canvas';
+export declare const getCoefficient: () => number;
+declare class Ui {
+    dialogTypeBackground: HTMLDivElement;
+    stepImg: HTMLDivElement;
+    videoError: HTMLDivElement;
+    btnsWrap: HTMLDivElement;
+    uploaderWrap: HTMLDivElement;
+    videoPos: HTMLDivElement;
+    fakeContour: HTMLDivElement;
+    stepsWrapper: HTMLDivElement;
+    guidlinesBtn: HTMLDivElement;
+    videoWrap: HTMLDivElement;
+    resetAllStepsBtn: HTMLDivElement;
+    version: HTMLDivElement;
+    selectDocumentTypeText: HTMLDivElement;
+    retakeBtn: HTMLButtonElement;
+    continueBtn: HTMLButtonElement;
+    submitBtn: HTMLButtonElement;
+    changeBtn: HTMLButtonElement;
+    correctBtn: HTMLButtonElement;
+    cancelBtn: HTMLButtonElement;
+    doneBtn: HTMLButtonElement;
+    closeBtn: HTMLButtonElement;
+    pressToUpdateText: HTMLElement;
+    pressToUpdateTextSuccess: HTMLElement;
+    documentType: HTMLParagraphElement;
+    videoErrorText: HTMLElement;
+    mainContainer: HTMLElement;
+    Mask: MaskCapture;
+    selectDocumentType: SelectDocumentType;
+    forceBtn: ForceBtn;
+    msBtn: IManualSwitchBtn;
+    messageBox: MessageBox;
+    flashlight: Flashlight;
+    canvas: CanvasUi;
+    video: HTMLVideoElement;
+    constructor();
+    initTypeSelect(): void;
+    resizeMainContainer(): void;
+    updateHoldText(data?: number, isCorrectDirection?: boolean): void;
+    updateStepImg(): void;
+    showVideoError(errorCode: string): void;
+    hideVideoError(): void;
+    updateVideoWrap(): void;
+    setVideoWrapEnabled(val?: boolean): void;
+    updateContinueBtn(): void;
+    updateBtnsWrap(): void;
+    updateSubmitBtn(): void;
+    updateResetAllBtn(): void;
+    updateRetakeButton(): void;
+    updateKeyError(): void;
+    initGeneralText(): void;
+    toggleUploaderWrap(): void;
+    setUploaderWrapEnabled(val?: boolean): void;
+    toggleVideoPos(): void;
+    resizeBorders(): void;
+    initDocumentTitle(): void;
+    setDefaultVideoCanvasSizes(): void;
+    setOffsets(baseWidth: number, baseHeight: number): void;
+    setCropSizes(baseWidth: number, baseHeight: number): void;
+    getResizedBaseSizes(coefficient: number): {
+        resizedBaseWidth: number;
+        resizedBasedHeight: number;
+    };
+    setResizedCrops(resizedBaseWidth: number, resizedBasedHeight: number): void;
+    setResizedOffsets(): void;
+    getCropSizes(coefficient: number): {
+        width: number;
+        height: number;
+    };
+    setCropFace(): void;
+    setFaceOffsets({ width }: ISize): void;
+    setResizedCanvasSizes({ width, height }: ISize): void;
+    getFakeContourWidth(width: number): number;
+    setFakeContourStyles(width: number): void;
+    setMirroring(): void;
+}
+declare const ui: {
+    ui: Ui | null;
+};
+export declare const initUi: () => void;
+export default ui;

package/dist/types/util.d.ts

@@ -0,0 +1,35 @@
+import { Base64Image } from './helpers/image';
+import { IStepCallback } from './modules/Step';
+import { DocumentTypeIndex } from './environment/documentTypes';
+import { Context } from './context';
+export interface IDataForSubmit {
+    metaData?: string;
+    payload?: Record<string, any>;
+    steps: IStepCallback[];
+    documentType: DocumentTypeIndex | 0;
+}
+interface IError {
+    code?: string;
+    message?: string;
+    name?: string;
+}
+export declare const checkIsTouchScreen: () => boolean;
+export declare const filterWithForbiddenKeysValues: (obj: any, forbiddenKeys: any, forbiddenValues: any) => {};
+declare const _default: {
+    checkIsTouchScreen: () => boolean;
+    prepareCameraErr(err: IError): IError;
+    formDataForSubmit(steps: IStepCallback[], c: Context, payload?: {}): IDataForSubmit;
+    /**
+     *
+     * @param img
+     * @returns {ImageData}
+     */
+    imageToImageData(img: HTMLImageElement): ImageData;
+    /**
+     *
+     * @param base64
+     * @returns {Promise<ImageData>}
+     */
+    base64ToImageData(base64: Base64Image): Promise<ImageData>;
+};
+export default _default;

package/dist/types/workers/blurWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/workers/bubbleWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/workers/mrzWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idscan/idvc2",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "component for the capturing documents",
   "main": "dist/idvc.js",
   "types": "dist/types/idvc.d.ts",
@@ -15,13 +15,16 @@
   "scripts": {
     "prepush": "npm run lint && npm run test",
     "start": "webpack serve --mode development",
-    "build": "(webpack --mode production --progress --color) & tsc",
+    "start:logging": "webpack serve --mode development --env logging",
+    "build": "webpack --mode production --progress --color && tsc",
     "build:develop": "webpack --mode development --progress --color && npm run pack",
+    "build:logging": "webpack --mode production --env logging && tsc",
     "pack": "npm pack",
     "minor": "npm version minor",
     "patch": "npm version patch",
     "test": "jest --coverage",
-    "lint": "eslint ./src"
+    "lint": "eslint ./src",
+    "tsc": "tsc"
   },
   "devDependencies": {
     "@swc/core": "1.3.59",
@@ -57,6 +60,7 @@
     "webpack-merge": "5.8.0"
   },
   "dependencies": {
+    "@supabase/supabase-js": "^2.32.0",
     "assert": "2.0.0",
     "buffer": "6.0.3",
     "core-js": "3.30.2",