@regulaforensics/vp-frontend-document-components 2.1.0 → 2.3.0

package/lib/index-document.d.ts

@@ -1,5 +1,4 @@
 import '@webcomponents/webcomponentsjs/webcomponents-bundle.js';
-import DocumentReaderService from './services/DocumentReaderService';
-import DocumentReaderProcessor from './services/DocumentReaderProcessor';
-declare function defineComponents(): Promise<Awaited<CustomElementConstructor>[]>;
-export { DocumentReaderService, DocumentReaderProcessor, defineComponents };
+export declare function defineComponents(): Promise<[CustomElementConstructor, CustomElementConstructor, CustomElementConstructor]>;
+export { default as DocumentReaderService } from './services/DocumentReaderService';
+export { default as DocumentReaderProcessor } from './services/DocumentReaderProcessor';

package/lib/media-resources/resourcesBase64.d.ts

@@ -0,0 +1,7 @@
+export declare const videoInstructionBase64: string;
+export declare const videoInstructionCaptureBase64: string;
+export declare const spriteHint1: string;
+export declare const spriteHint2: string;
+export declare const spriteHint3: string;
+export declare const spriteHint4: string;
+export declare const spriteHint5: string;

package/lib/services/DebugService.d.ts

@@ -1,8 +1,12 @@
 import { logLevels } from '../constants';
 declare class DebugService {
     private readonly logLvl;
+    private prevTime;
+    private frameResults;
     constructor(logLvl: logLevels);
     private log;
+    private frameInfoLog;
+    private shutDownInfoLog;
     private time;
     debug(message: string, ...optionalParams: Array<any>): void;
     info(message: string, ...optionalParams: Array<any>): void;

package/lib/services/DocumentReaderProcessor.d.ts

@@ -1,4 +1,4 @@
-import { CurrentPage, ProcessingRequest, ImageProcessingRequest, StreamParams } from '../types';
+import { CurrentPage, ImageProcessingRequest, ProcessingRequest, StreamParams } from '../types';
 import { Response } from '../models/DocReaderWebclient/ext';
 declare type ServiceListener = ((data: Response) => void) | null;
 declare type ResponseListener = (currentPage: CurrentPage) => void;
@@ -16,7 +16,7 @@ declare class DocumentReaderProcessor {
     private _isProcessing;
     private _pageIdx;
     constructor(videoElement?: HTMLVideoElement);
-    get streamParam(): StreamParams;
+    get streamParam(): Partial<StreamParams>;
     set streamParam(params: Partial<StreamSettings>);
     get recognizerProcessParam(): ProcessingRequest;
     set recognizerProcessParam(params: ProcessingRequest);
@@ -30,10 +30,11 @@ declare class DocumentReaderProcessor {
     get isInitialized(): boolean;
     get isProcessing(): boolean;
     private startStream;
+    private getImageData;
     private detect;
     private startNewPage;
     private startNewDocument;
-    startRecognition(responseListener?: ResponseListener): Promise<Response>;
+    startRecognition(responseListener?: ResponseListener): Promise<Response | null>;
     processImage(images: FileList | Array<Blob>): Promise<Response>;
     stopRecognition(): void;
     prepare(): Promise<void>;

package/lib/services/DocumentReaderService.d.ts

@@ -21,9 +21,9 @@ declare class DocumentReaderService {
     get imageProcessParam(): ImageProcessingRequest;
     set imageProcessParam(params: ImageProcessingRequest);
     get isInitialized(): boolean;
-    private set isInitialized(value);
+    set isInitialized(value: boolean);
     get isPrepared(): boolean;
-    private set isPrepared(value);
+    set isPrepared(value: boolean);
     get isProcessing(): boolean;
     get prepareListener(): PrepareListener | null;
     set prepareListener(listener: PrepareListener | null);

package/lib/services/FaceLivenessService.d.ts

@@ -1,36 +1,55 @@
-import { UserAgentType } from '../types';
 import EventEmitter from './EventEmitter';
 import CameraModel from '../models/CameraModel';
-declare type MetadataType = {
+import { ConfigLivenessParams } from '../types';
+declare type InitializedFaceLivenessData = {
+    config: ConfigLivenessParams;
+    publicKey: string;
+    schema: string;
+    sessionId: string;
+    transactionId: string;
+    metadata: {
+        platform: string;
+        osVersion: string;
+        sdkVersion: string;
+        hostAppId: string;
+        deviceModel: string;
+        currentCameraId: string;
+        cameraState: CameraModel[];
+        ctx: {
+            userIp: string;
+        };
+    };
+};
+export declare type InitializedFaceCaptureData = {
+    config: {
+        scenario: number;
+        frameWidth: number;
+        frameHeight: number;
+        debugOutput: boolean | undefined;
+        numChannels: number;
+    };
     metadata: {
         hostAppId: string;
         sdkVersion: string;
         deviceModel: string;
         camera: CameraModel;
     };
-    try_id?: number;
-    guid?: string;
-    userAgent: UserAgentType;
-    mode?: number;
+};
+declare type InitializeData = InitializedFaceLivenessData | InitializedFaceCaptureData;
+declare type ParamsData = {
+    initializedData: InitializeData;
 };
 declare class FaceLivenessService {
     initialized: boolean;
     processing: boolean;
     prepared: boolean;
     worker: Worker | null;
-    params: {
-        width: number;
-        height: number;
-        metadata?: MetadataType;
-    };
+    params: ParamsData | null;
     eventEmitter: EventEmitter;
     constructor();
     prepare(listener: (data: any) => void): Promise<void>;
     initialize(params: {
-        width: number;
-        height: number;
-        metadata: MetadataType;
-        debug?: boolean;
+        initializedData: InitializeData;
     }): void;
     private postCustomMessage;
     private emit;
@@ -38,6 +57,6 @@ declare class FaceLivenessService {
     private printErr;
     private onWorkerMessage;
     shutdown(): void;
-    processImage(videoFrame: Uint8ClampedArray): void;
+    processImage(videoFrame: Uint8ClampedArray, abortSession?: boolean): void;
 }
 export default FaceLivenessService;

package/lib/services/FaceService.d.ts

@@ -1,12 +1,37 @@
-import { FaceLivenessResultType } from '../types';
-declare type GetLivenessResultOptions = {
-    uuid: string;
-    try_id: number;
+import { ConfigLivenessParams, FaceLivenessResultType } from '../types';
+import CameraModel from '../models/CameraModel';
+declare type GetLivenessDetectionResultOptions = {
+    transactionId: string;
     backendURL?: string;
     headers?: Record<string, string>;
+    publicKey: string;
 };
-declare function getLivenessResult(encryptedBody: Uint8Array, { uuid, try_id, backendURL, headers }: GetLivenessResultOptions): Promise<FaceLivenessResultType>;
+declare type DeviceMetadata = {
+    platform: string;
+    osVersion: string;
+    sdkVersion: string;
+    hostAppId: string;
+    deviceModel: string;
+    currentCameraId: string;
+    cameraState: CameraModel[];
+};
+declare type InitializedFaceLivenessDataResult = {
+    config: ConfigLivenessParams;
+    metadata: {
+        ctx: {
+            userIp: string;
+        };
+        serverTime: string;
+    };
+    publicKey: string;
+    schema: string;
+    sessionId: string;
+    transactionId: string;
+};
+declare function getLivenessDetectionResult(encryptedBody: Uint8Array, { transactionId, backendURL, headers, publicKey }: GetLivenessDetectionResultOptions): Promise<FaceLivenessResultType>;
+declare function getInitialisingData(deviceMetadata: DeviceMetadata, sessionId?: string, backendUrl?: string): Promise<InitializedFaceLivenessDataResult>;
 declare const _default: {
-    getLivenessResult: typeof getLivenessResult;
+    getInitialisingData: typeof getInitialisingData;
+    getLivenessDetectionResult: typeof getLivenessDetectionResult;
 };
 export default _default;

package/lib/types.d.ts

@@ -1,6 +1,51 @@
 import { Response } from './models/DocReaderWebclient/ext';
+import dictionaries from './i18n/dictionaries/_dictionaries';
 import { DocumentEventActions, FaceEventActions, InternalScenarios, ObjectFit, ResponseCode, StreamStatus, ErrorTypes, CameraFacingMode } from './constants';
 import CameraModel from './models/CameraModel';
+declare type DocumentTranslations = {
+    scanIDInBrowser?: string;
+    useYourDeviceCamera?: string;
+    success?: string;
+    processingFinished?: string;
+    largeFile?: string;
+    selectSmallerFile?: string;
+    versionNotSupported?: string;
+    updateBrowser?: string;
+    licenseError?: string;
+    licenseExpired?: string;
+    fileCorrupt?: string;
+    selectAnotherFile?: string;
+    timeout?: string;
+    error?: string;
+    somethingWentWrong?: string;
+    tryAgain?: string;
+    fromCamera?: string;
+    fromGallery?: string;
+    processing?: string;
+    preparingService?: string;
+    detectingDocument?: string;
+    placeDocumentIntoFrame?: string;
+    positionDocumentCenter?: string;
+    noFocus?: string;
+    moveCloser?: string;
+    glaresOnDocument?: string;
+    holdDocumentStraight?: string;
+    documentProcessing?: string;
+    flipDocument?: string;
+    cameraUnavailable?: string;
+    preparingCamera?: string;
+    noCameraAvailable?: string;
+    incorrectCameraId?: string;
+    allowAccessToCamera?: string;
+    cameraConnection?: string;
+    checkCameraId?: string;
+    verified?: string;
+    photoCapturedSuccessfully?: string;
+    uploadPhoto?: string;
+    useCameraOrGallery?: string;
+};
+export declare type Locales = keyof typeof dictionaries | string;
+export declare type DocumentDictionaries = Partial<Record<Locales, DocumentTranslations>>;
 export declare type XY = {
     x: number;
     y: number;
@@ -29,7 +74,6 @@ export declare type FacingModeType = keyof typeof CameraFacingMode;
 export declare type VideoStatusParamsType = {
     videoStatus: StreamStatus;
     camera: CameraTypes;
-    twoFacingModesAvailable: boolean;
 };
 export declare type CaptureFrameType = {
     imageData: Array<ImageData>;
@@ -54,78 +98,60 @@ export declare type UserAgentType = {
     vendor: string;
     vendorSub: string;
 };
-declare type FaceLivenessEyesType = {
-    predLeft: number;
-    predRight: number;
-    probLeft: number;
-    probRight: number;
-};
-declare type FaceLivenessOcclusionType = {
-    foreheadGlasses: boolean;
-    glasses: boolean;
-    hat: boolean;
-    medicineMask: boolean;
-    occlusion: boolean;
-    openedMouth: boolean;
-    sunglasses: boolean;
-};
-declare type FaceLivenessQualityType = {
-    blur: number;
-    brightness: number;
-    noise: number;
-};
-export declare type FaceLivenessResponseType = {
+export declare type ConfigLivenessParams = {
+    ballSmoothingWeight: number;
+    circleRadiusToMinDim: number;
+    compressDepthMap: boolean;
+    debugOutput: boolean | undefined;
+    depthMapBits: number;
+    distNormalMaxDeviation: number;
+    dontShowReadinessTimeoutMs: number;
+    faceBestHeight: number;
+    fitFaceMultNear: number;
+    frameHeight: number;
+    frameWidth: number;
+    holdStillNearTimeoutMs: number;
+    holdStillNormalTimeoutMs: number;
+    maxPitchNear: number;
+    maxPitchNormal: number;
+    maxRollNormal: number;
+    maxYawNear: number;
+    maxYawNormal: number;
+    minReadinessNear: number;
+    minReadinessNormal: number;
+    moveAwayMultNear: number;
+    moveCloserMultNear: number;
+    nearTimeoutMs: number;
+    normalTimeoutMs: number;
+    numChannels: number;
+    numSectors: number;
+    pin: number[];
+    resizedFrameHeight: number;
+    resizedFrameWidth: number;
+    scenario: number;
+    showGraySectors: boolean;
+    showHintDurationMs: number;
+    showHintTimeoutMs: number;
+    sizeNormalMaxDeviation: number;
+    targetSectorRelChange: number;
+};
+export declare type FaceLivenessResultType = {
     code: number;
-    msg: string;
-    results: {
-        faceIdx: number;
-        livenessStatus: number;
-        metadata: {
-            ageNear: string;
-            ageNormal: string;
-            distance: number;
-            evaluationTime: number;
-            eyesNear: FaceLivenessEyesType;
-            eyesNormal: FaceLivenessEyesType;
-            faceQuality: {
-                details: Array<{
-                    attribute: string;
-                    score: number;
-                }>;
-                score: number;
-            };
-            faceTrackBreak: number;
-            occlusionNear: FaceLivenessOcclusionType;
-            occlusionNormal: FaceLivenessOcclusionType;
-            predArtMaskNear: number;
-            predArtMaskNormal: number;
-            predElectronicDeviceNear: number;
-            predElectronicDeviceNormal: number;
-            predGeometryClassifier: number;
-            predLivenessViewNear: number;
-            predLivenessViewNormal: number;
-            predOpticalFlow: number;
-            predShadesNear: number;
-            predShadesNormal: number;
-            predTotal: number;
-            probArtMaskNear: number;
-            probArtMaskNormal: number;
-            probElectronicDeviceNear: number;
-            probElectronicDeviceNormal: number;
-            probGeometryClassifier: number;
-            probOpticalFlow: number;
-            probShadesNear: number;
-            probShadesNormal: number;
-            qualityNear: FaceLivenessQualityType;
-            qualityNormal: FaceLivenessQualityType;
-            smileNear: string;
-            smileNormal: string;
-            symNear: number;
-            symNormal: number;
+    config: ConfigLivenessParams;
+    elapsed: number;
+    metadata: {
+        ctx: {
+            userIp: string;
         };
+        serverTime: string;
     };
-    versionDescriptor: string;
-    versionSDK: string;
+    portrait: string;
+    sessionId: string;
+    status: number;
+    transactionId: string;
+    video: string;
+};
+export declare type FaceLivenessResponseType = FaceLivenessResultType & {
     images: Array<string>;
 };
 export declare type FaceDetectionResponseType = {
@@ -133,7 +159,6 @@ export declare type FaceDetectionResponseType = {
 };
 export declare type DocumentReaderResponseType = Response;
 export declare type CameraSnapshotResponseType = CaptureType;
-export declare type FaceLivenessResultType = Omit<FaceLivenessResponseType, 'images'>;
 export declare type FaceDebugOutput = {
     cft: boolean;
     face: {
@@ -241,6 +266,30 @@ export declare type DocumentReaderProcessParam = {
     timeoutFromFirstDocType?: number;
     resultTypeOutput?: Array<string>;
     customParams?: Record<string, any>;
+    imageOutputMaxHeight?: number;
+    imageOutputMaxWidth?: number;
+    doublePageSpread?: boolean;
+    generateDoublePageSpreadImage?: boolean;
+    fieldTypesFilter?: Array<number>;
+    dateFormat?: string;
+    measureSystem?: number;
+    imageDpiOutMax?: number;
+    alreadyCropped?: boolean;
+    fastDocDetect?: boolean;
+    updateOCRValidityByGlare?: boolean;
+    returnCroppedBarcode?: boolean;
+    respectImageQuality?: boolean;
+    forceDocFormat?: number;
+    noGraphics?: boolean;
+    documentAreaMin?: number;
+    depersonalizeLog?: boolean;
+    multiDocOnImage?: boolean;
+    shiftExpiryDate?: number;
+    minimalHolderAge?: number;
+    mrzFormatsFilter?: Array<string>;
+    forceReadMrzBeforeLocate?: boolean;
+    parseBarcodes?: boolean;
+    splitNames?: boolean;
     imageQa?: {
         expectedPass?: Array<string>;
         dpiThreshold?: number;
@@ -269,7 +318,6 @@ export interface StreamDataType {
     status: StreamStatus;
     stream: MediaStream | null;
     camera: CameraTypes;
-    twoFacingModesAvailable: boolean;
 }
 export declare type StreamParams = {
     cameraMode: FacingModeType;
@@ -282,7 +330,7 @@ export declare type CameraTypes = {
     backCameras: Array<CameraModel>;
 };
 export declare type CurrentPage = {
-    data: Response;
+    data: Response | null;
     startNextPage: () => Promise<void>;
     finishRecognition: () => void;
 };
@@ -295,10 +343,11 @@ declare global {
     }
 }
 interface IBaseComponent {
-    locale?: string;
+    locale?: Locales;
     copyright?: boolean;
     'camera-id'?: string;
     'change-camera'?: boolean;
+    'start-screen'?: boolean;
 }
 interface IDocumentBaseComponent extends IBaseComponent {
     'start-screen'?: boolean;
@@ -318,9 +367,17 @@ export interface IFaceDetection extends IBaseComponent {
     debug?: boolean;
 }
 export declare type ICameraSnapshot = IDocumentBaseComponent;
-export { DocumentReaderService, DocumentReaderProcessor, defineComponents } from './index-document';
+export declare type FacePositionLivenessDetection = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export { default as DocumentReaderService } from './services/DocumentReaderService';
+export { default as DocumentReaderProcessor } from './services/DocumentReaderProcessor';
 export { default as DocumentReaderCaptureWebComponent } from './web-components/CameraSnapshot';
 export { default as DocumentReaderWebComponent } from './web-components/DocumentReader';
 export { default as FaceDetectionWebComponent } from './web-components/FaceDetection';
 export { default as FaceLivenessWebComponent } from './web-components/FaceLiveness';
 export { default as FullScreenContainer } from './web-components/FullScreenContainer';
+export { defineComponents } from './index-document';

package/lib/web-components/CameraSnapshot.d.ts

@@ -1,11 +1,14 @@
-import { Root } from 'react-dom/client';
+import { DocumentDictionaries } from '../types';
 export default class DocumentReaderCaptureWebComponent extends HTMLElement {
-    root: Root;
-    mounted: boolean;
+    private _root;
+    private _mounted;
+    private _translations;
     constructor();
     static get observedAttributes(): Array<string>;
     attributeChangedCallback(name: string): void;
     connectedCallback(): void;
+    set translations(dictionary: DocumentDictionaries | null);
+    get translations(): DocumentDictionaries | null;
     render(): void;
     disconnectedCallback(): void;
 }

package/lib/web-components/DocumentReader.d.ts

@@ -1,11 +1,14 @@
-import { Root } from 'react-dom/client';
+import { DocumentDictionaries } from '../types';
 export default class DocumentReaderWebComponent extends HTMLElement {
-    root: Root;
-    mounted: boolean;
+    private _root;
+    private _mounted;
+    private _translations;
     constructor();
     static get observedAttributes(): Array<string>;
     attributeChangedCallback(name: string): void;
     connectedCallback(): void;
+    set translations(dictionary: DocumentDictionaries | null);
+    get translations(): DocumentDictionaries | null;
     render(): void;
     disconnectedCallback(): void;
 }

package/lib/web-components/FaceDetection.d.ts

@@ -1,7 +1,6 @@
-import { Root } from 'react-dom/client';
 export default class FaceDetectionWebComponent extends HTMLElement {
-    root: Root;
-    mounted: boolean;
+    private _root;
+    private _mounted;
     constructor();
     static get observedAttributes(): Array<string>;
     attributeChangedCallback(name: string): void;

package/lib/web-components/FaceLiveness.d.ts

@@ -1,14 +1,16 @@
-import { Root } from 'react-dom/client';
 export default class FaceLivenessWebComponent extends HTMLElement {
-    root: Root;
-    mounted: boolean;
-    requestHeaders: Record<string, string>;
+    private _root;
+    private _mounted;
+    private _headers;
+    private _sessionIdValue;
     constructor();
     static get observedAttributes(): Array<string>;
     attributeChangedCallback(name: string): void;
     connectedCallback(): void;
     set headers(headersData: Record<string, string>);
     get headers(): Record<string, string>;
+    set sessionId(id: string);
+    get sessionId(): string;
     render(): void;
     disconnectedCallback(): void;
 }

package/lib/web-components/FullScreenContainer.d.ts

@@ -1,4 +1,4 @@
 export default class FullScreenContainer extends HTMLElement {
-    root: ShadowRoot;
+    private _root;
     constructor();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regulaforensics/vp-frontend-document-components",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Regula framework agnostic web components to work with webcamera",
   "types": "lib/types.d.ts",
   "main": "dist/main.js",
@@ -14,7 +14,6 @@
   "license": "MIT",
   "homepage": "https://storybook-document.regulaforensics.com/",
   "scripts": {
-    "start": "webpack serve --config webpack.dev.js",
     "build-face": "npm run clean-lib && npm run generate-face-types && webpack --config webpack.face-umd.js",
     "build-document": "npm run clean-lib && npm run generate-document-types && webpack --config webpack.document-umd.js && webpack --config webpack.document-esm.js",
     "storybook": "start-storybook -p 6006 -c .storybook-development -h localhost",
@@ -24,6 +23,8 @@
     "build-storybook-document-rc": "build-storybook -c .storybook-rc/document",
     "build-storybook-face-release": "build-storybook -c .storybook-release/face",
     "build-storybook-document-release": "build-storybook -c .storybook-release/document",
+    "build-storybook-document-beta": "build-storybook -c .storybook-beta/document",
+    "build-storybook-face-beta": "build-storybook -c .storybook-beta/face",
     "generate-dictionaries": "node scripts/xml-dictionary-parser/index.js Translator.xml src/i18n/dictionaries",
     "clean-lib": "rm -rf ./lib",
     "generate-face-types": "tsc --project ./configs/face.tsconfig.json",
@@ -36,7 +37,7 @@
   },
   "dependencies": {
     "@regulaforensics/facesdk-webclient": "^3.1.2",
-    "@webcomponents/webcomponentsjs": "^2.6.0",
+    "@webcomponents/webcomponentsjs": "2.6.0",
     "localize-react": "^1.7.1",
     "react": "^18.2.0",
     "react-device-detect": "^2.2.2",
@@ -56,6 +57,8 @@
     "@regulaforensics/vp-frontend-face-components": "*",
     "@regulaforensics/vp-frontend-face-components-nightly": "*",
     "@regulaforensics/vp-frontend-face-components-rc": "*",
+    "@regulaforensics/vp-frontend-document-components-beta": "*",
+    "@regulaforensics/vp-frontend-face-components-beta": "*",
     "@storybook/addon-actions": "^6.5.13",
     "@storybook/addon-essentials": "^6.5.13",
     "@storybook/addon-links": "^6.5.13",
@@ -77,7 +80,6 @@
     "eslint-plugin-react": "^7.31.8",
     "fast-xml-parser": "^4.0.10",
     "he": "^1.2.0",
-    "html-webpack-plugin": "^5.5.0",
     "husky": "^8.0.0",
     "lint-staged": "^13.0.3",
     "prettier": "^2.7.1",

package/lib/common/InstructionIconFaceDetection.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="react" />
-declare function InstructionIconFaceDetection({ size }: {
-    size?: number;
-}): JSX.Element;
-export default InstructionIconFaceDetection;

package/lib/common/InstructionIconFaceLiveness.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="react" />
-declare function InstructionIconFaceLiveness({ size }: {
-    size?: number;
-}): JSX.Element;
-export default InstructionIconFaceLiveness;

package/lib/common/NoGlareIcon.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="react" />
-declare function NoGlareIcon({ size }: {
-    size?: number;
-}): JSX.Element;
-export default NoGlareIcon;

package/lib/common/NoSmilingIcon.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="react" />
-declare function NoSmilingIcon({ size }: {
-    size?: number;
-}): JSX.Element;
-export default NoSmilingIcon;

package/lib/components/InstructionScreen.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="react" />
-declare type InstructionScreenProps = {
-    onStart: () => void;
-    icon: string;
-    title: string;
-    subtitle: string;
-};
-declare function InstructionScreen({ onStart, icon, title, subtitle }: InstructionScreenProps): JSX.Element;
-export default InstructionScreen;

package/lib/components/RetryScreen.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="react" />
-declare type RetryScreenProps = {
-    errorCode: number;
-    onReset: () => void;
-};
-declare function RetryScreen({ errorCode, onReset }: RetryScreenProps): JSX.Element;
-export default RetryScreen;