@regulaforensics/vp-frontend-face-components 1.4.0 → 2.0.1

package/lib/contexts/DocumentAttributesContext.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { CameraSnapshotResponseType, DocumentDictionaries, DocumentReaderResponseType, Locales } from '../types';
+import { DocumentEventActions, InternalScenarios, ErrorTypes } from '../constants';
+declare type DocumentCallbackArgTypes = DocumentReaderResponseType | CameraSnapshotResponseType;
+export declare type DocumentAttributesContextType = {
+    onAction: ({ manual, action }: {
+        manual: boolean;
+        action: DocumentEventActions;
+    }) => void;
+    onResponse: (response: DocumentCallbackArgTypes) => void;
+    onFail: (reason: ErrorTypes) => void;
+    locale?: Locales;
+    internalScenario?: InternalScenarios;
+    multipageProcessing?: boolean;
+    startScreen?: boolean;
+    multiple?: boolean;
+    license?: string;
+    copyright?: boolean;
+    cameraId?: string;
+    changeCamera?: boolean;
+    translations?: DocumentDictionaries;
+};
+export declare const DocumentAttributesContext: import("react").Context<DocumentAttributesContextType>;
+export declare const useDocumentContext: () => DocumentAttributesContextType;
+export {};

package/lib/contexts/DocumentSDKContext.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import DocumentReaderService from '../services/DocumentReaderService';
+declare type DocumentSDKContextType = {
+    service: DocumentReaderService | null;
+};
+export declare const DocumentSDKContext: import("react").Context<DocumentSDKContextType>;
+export declare const useDocumentSDKContext: () => DocumentSDKContextType;
+export {};

package/lib/contexts/FaceAttributesContext.d.ts

@@ -1,24 +1,26 @@
-import React from 'react';
-import { FaceDetectionResponseType, FaceLivenessResponseType } from '../types';
-import { faceEventActions, WebComponentsError } from '../constants';
-declare type FaceCallbackArgTypes = FaceLivenessResponseType | FaceDetectionResponseType;
+/// <reference types="react" />
+import { FaceDetectionResponseType, Locales, FaceLivenessResponseType } from '../types';
+import { FaceEventActions, ErrorTypes } from '../constants';
+declare type FaceCallbackArgTypes = FaceDetectionResponseType | FaceLivenessResponseType;
 export declare type FaceAttributesContextType = {
     onAction: ({ manual, action }: {
         manual: boolean;
-        action: faceEventActions;
+        action: FaceEventActions;
     }) => void;
     onResponse: (response: FaceCallbackArgTypes) => void;
-    onFail: (reason: WebComponentsError) => void;
-    startScale?: number;
-    endScale?: number;
-    ovalOffset?: number;
-    locale?: string;
+    onFail: (reason: ErrorTypes) => void;
+    locale?: Locales;
     url?: string;
     debug?: boolean;
-    mode?: number;
     headers?: Record<string, string>;
+    sessionId?: string;
     copyright?: boolean;
     cameraId?: string;
+    changeCamera?: boolean;
+    startScreen?: boolean;
+    videoRecording?: boolean;
+    deviceOrientation?: boolean;
 };
-export declare const FaceAttributesContext: React.Context<FaceAttributesContextType>;
+export declare const FaceAttributesContext: import("react").Context<FaceAttributesContextType>;
+export declare const useFaceContext: () => FaceAttributesContextType;
 export {};

package/lib/hoc/withDocumentAttributesContext.d.ts

@@ -0,0 +1,4 @@
+import { DocumentAttributesContextType } from '../contexts/DocumentAttributesContext';
+import { ComponentType } from 'react';
+declare function withDocumentAttributesContext<T extends DocumentAttributesContextType>(Component: ComponentType<T>): ComponentType<T>;
+export default withDocumentAttributesContext;

package/lib/hoc/withDocumentSDKContext.d.ts

@@ -0,0 +1,3 @@
+import { ComponentType } from 'react';
+declare function withDocumentSDKContext<T>(Component: ComponentType<T>): ComponentType<T>;
+export default withDocumentSDKContext;

package/lib/hoc/withFaceAttributesContext.d.ts

@@ -1,4 +1,4 @@
-import * as React from 'react';
 import { FaceAttributesContextType } from '../contexts/FaceAttributesContext';
-declare function withFaceAttributesContext<T extends FaceAttributesContextType>(Component: React.ComponentType<T>): React.ComponentType<T>;
+import { ComponentType } from 'react';
+declare function withFaceAttributesContext<T extends FaceAttributesContextType>(Component: ComponentType<T>): ComponentType<T>;
 export default withFaceAttributesContext;

package/lib/hoc/withLocalize.d.ts

@@ -1,7 +1,8 @@
-import * as React from 'react';
-import { DirectionType } from '../constants';
-interface Locale {
-    locale: string | undefined;
+import { DocumentDictionaries, Locales } from '../types';
+import { ComponentType } from 'react';
+interface LocalizedProps {
+    locale?: Locales;
+    translations?: DocumentDictionaries;
 }
-declare function withLocalize<T>(Component: React.ComponentType<T>): React.ComponentType<T & Locale & DirectionType>;
+declare function withLocalize<T>(Component: ComponentType<T>): ComponentType<T & LocalizedProps>;
 export default withLocalize;

package/lib/hooks/useDocumentReaderSeries.d.ts

@@ -0,0 +1,19 @@
+import { Response } from '../models/DocReaderWebclient/ext';
+import { DocumentCaptureStatus, InternalScenarios, StreamStatus } from '../constants';
+import { ImageInputParamType, VideoParamsType } from '../types';
+declare type ResponseType = {
+    status: DocumentCaptureStatus;
+    initialized: boolean;
+    error: unknown;
+    response: Response | null;
+};
+interface IUseDocumentReaderSeries extends ResponseType {
+    frameParams: ImageInputParamType;
+}
+declare type TUseDocumentReaderSeriesOptions = {
+    scenario?: InternalScenarios;
+    multipageProcessing?: boolean;
+    license?: string;
+};
+declare function useDocumentReaderSeries(videoElementParams: VideoParamsType, videoStatus: StreamStatus, options: TUseDocumentReaderSeriesOptions): IUseDocumentReaderSeries;
+export default useDocumentReaderSeries;

package/lib/hooks/useDocumentReaderSingle.d.ts

@@ -0,0 +1,14 @@
+import { DocumentCaptureStatus, InternalScenarios } from '../constants';
+import { Response } from '../models/DocReaderWebclient/ext';
+declare type ResponseType = {
+    status: DocumentCaptureStatus;
+    error: unknown;
+    response: Response | null;
+    initialized: boolean;
+    prepared: boolean;
+};
+declare function useDocumentReaderSingle(imageDataArray: Array<ImageData>, options: {
+    scenario?: InternalScenarios;
+    license?: string;
+}): ResponseType;
+export default useDocumentReaderSingle;

package/lib/hooks/useFaceLiveness.d.ts

@@ -1,33 +1,41 @@
-import { eFL_Message, eFL_MessageStyle, eFL_ProcessingStage, eFL_Status, faceEventActions } from '../constants';
-import { CustomErrorObjectType, FrameObject, VideoParamsType } from '../types';
-import CameraModel from '../models/CameraModel';
-declare type UseFaceDetectionProps = {
-    videoFrame: Uint8ClampedArray;
-    sourceCaptureFrame: FrameObject;
-    videoElementParams: VideoParamsType;
-    onAction: ({ manual, action }: {
-        manual: boolean;
-        action: faceEventActions;
-    }) => void;
-    cameraInfo: CameraModel;
-    uuid?: string;
-    mode?: number;
-    url?: string;
-    tryCount?: number;
-    debug?: boolean;
-};
-declare type responseType = {
-    message: eFL_Message;
-    messageStyle: eFL_MessageStyle;
-    processingStage: eFL_ProcessingStage;
-    status: eFL_Status;
+import { FaceMessage, FaceProcessingStage, FaceStatus, FaceEventActions, StreamStatus } from '../constants';
+import { CameraTypes, FaceDebugOutput, FacePositionLivenessDetection, Oval, VideoParamsType } from '../types';
+import CustomError from '../models/CustomError';
+declare type ResponseType = {
+    message: FaceMessage;
+    processingStage: FaceProcessingStage;
+    status: FaceStatus;
     request: Uint8Array | null;
     requestSize: number | null;
     initialized: boolean;
-    debugOutput: Record<string, any>;
+    debugOutput: FaceDebugOutput | null;
     prepared: boolean;
     images: Array<string>;
-    wasmError: CustomErrorObjectType | null;
+    ovals: Array<Oval>;
+    step: number;
+    currSector: number;
+    numSectors: number;
+    targetSector: number | undefined;
+    readiness: number;
+    publicKey: string | null;
+    error: CustomError | null;
+    facePosition: FacePositionLivenessDetection;
 };
-declare function useFaceLiveness({ videoFrame, sourceCaptureFrame, videoElementParams, onAction, cameraInfo, uuid, mode, url, tryCount, debug, }: UseFaceDetectionProps): responseType;
+declare function useFaceLiveness(options: {
+    videoStatus: StreamStatus;
+    videoElementParams: VideoParamsType;
+    cameraInfo: CameraTypes;
+    setSessionId?: (id: string) => void;
+    setTransactionId?: (id: string) => void;
+    sessionId?: string;
+    url?: string;
+    debug?: boolean;
+    faceSnapshot?: boolean;
+    backendUrl?: string;
+    abortProcess?: boolean;
+    videoRecording?: boolean;
+}, onAction: ({ manual, action }: {
+    manual: boolean;
+    action: FaceEventActions;
+}) => void): ResponseType;
 export default useFaceLiveness;

package/lib/hooks/useImageInputParam.d.ts

@@ -0,0 +1,7 @@
+import { ImageInputParamType, WidthAndHeight } from '../types';
+declare type UseImageInputParamPropsType = {
+    videoSize: WidthAndHeight;
+    scenario: string;
+};
+declare function useImageInputParam({ videoSize, scenario }: UseImageInputParamPropsType): ImageInputParamType;
+export default useImageInputParam;

package/lib/hooks/useStateCallback.d.ts

@@ -0,0 +1 @@
+export declare function useStateCallback<T>(initialState: T): [T, (state: T, cb?: (state: T) => void) => void];

package/lib/hooks/useStream.d.ts

@@ -1,15 +1,9 @@
-import { cameraFacingMode, streamStatus } from '../constants';
-import CameraModel from '../models/CameraModel';
-interface StreamDataType {
-    status: streamStatus;
-    stream: MediaStream | null;
-    camera: CameraModel;
-    twoFacingModesAvailable: boolean;
-}
+import { CameraFacingMode } from '../constants';
+import { StreamDataType } from '../types';
 interface UseStreamReturnType extends StreamDataType {
     onPlay: () => void;
 }
-declare function useStream(mode?: cameraFacingMode, resolution?: {
+declare function useStream(mode?: CameraFacingMode, resolution?: {
     width: number;
     height: number;
 }, preferredCameraId?: string): UseStreamReturnType;