@regulaforensics/vp-frontend-document-components 7.2.1705-nightly → 7.2.1707-nightly

package/README.md

@@ -93,7 +93,7 @@ import { defineComponents, DocumentReaderService } from '@regulaforensics/vp-fro
 ```
 Without module bundler:
 ```javascript
-import { defineComponents, DocumentReaderService } from './node_modules/@regulaforensics/vp-frontend-document-components/esm/main.js';
+import { defineComponents, DocumentReaderService } from './node_modules/@regulaforensics/vp-frontend-document-components/dist/main.js';
 ```
 
 **Step 3.** Define the components, depending on the functionality that you need.
@@ -148,7 +148,7 @@ Use the CDN link in a format as follows: `unpkg.com/:package@:version/:file`
 
 For example:
 ```html
-<script src="https://unpkg.com/@regulaforensics/vp-frontend-document-components@latest/dist/main.js"></script>
+<script src="https://unpkg.com/@regulaforensics/vp-frontend-document-components@latest/dist/main.iife.js"></script>
 ```
 
 **Note:** You can find all available script versions in the corresponding section of npm, using the same link from the previous example.
@@ -1074,7 +1074,7 @@ import { DocumentReaderProcessor } from '@regulaforensics/vp-frontend-document-c
 
 Without module bundler:
 ```javascript
-import { DocumentReaderProcessor } from '/node_modules/@regulaforensics/vp-frontend-document-components/esm/main.js';
+import { DocumentReaderProcessor } from '/node_modules/@regulaforensics/vp-frontend-document-components/dist/main.js';
 ```
    
 **Step 3.** Add a video tag to the `.html` file, then prepare and initialize `DocumentReaderProcessor`.
@@ -1130,7 +1130,7 @@ Use the CDN link in a format as follows: `unpkg.com/:package@:version/:file`
 
 For example:
 ```html
-<script src="https://unpkg.com/@regulaforensics/vp-frontend-document-components@latest/dist/main.js"></script>
+<script src="https://unpkg.com/@regulaforensics/vp-frontend-document-components@latest/dist/main.iife.js"></script>
 ```
 
 **Note:** You can find all available script versions in the corresponding section of npm, using the same link from the previous example.

package/dist/index.d.ts

@@ -0,0 +1,588 @@
+import { ContainerList } from '@regulaforensics/document-reader-webclient';
+import { DocumentFormat } from '@regulaforensics/document-reader-webclient';
+import { MeasureSystem } from '@regulaforensics/document-reader-webclient';
+import { MRZFormat } from '@regulaforensics/document-reader-webclient';
+import { Response as Response_2 } from '@regulaforensics/document-reader-webclient';
+import { Result } from '@regulaforensics/document-reader-webclient';
+import { TextFieldType } from '@regulaforensics/document-reader-webclient';
+
+export declare interface BaseRequest {
+    tag?: string;
+    tenant?: string;
+    env?: string;
+}
+
+export declare enum CameraFacingMode {
+    user = "user",
+    environment = "environment"
+}
+
+declare enum CameraSnapshotAttributes {
+    locale = "locale",
+    multiple = "multiple",
+    copyright = "copyright",
+    startScreen = "start-screen",
+    cameraId = "camera-id",
+    changeCamera = "change-camera",
+    closeButton = "close-button"
+}
+
+export declare type CameraSnapshotDetailType = DetailEvent<EventActions, CameraSnapshotResponseType>;
+
+export declare type CameraSnapshotResponseType = Array<{
+    raw: string;
+    mimeType: string;
+}>;
+
+export declare interface CameraSnapshotSettings {
+    startScreen?: boolean;
+    locale?: Locales | string;
+    multipleFileInput?: boolean;
+    regulaLogo?: boolean;
+    cameraId?: string;
+    changeCameraButton?: boolean;
+    closeButton?: boolean;
+    resolution?: Resolution;
+    cameraMode?: CameraFacingMode;
+    nonce?: string;
+    statusTextColor?: string;
+    statusBackgroundColor?: string;
+}
+
+export declare type CaptureFrameType = {
+    imageData: Array<ImageData>;
+    raw: string;
+    mimeType: string;
+};
+
+export declare enum CaptureMode {
+    auto = "auto",
+    captureVideo = "captureVideo",
+    captureFrame = "captureFrame"
+}
+
+export declare type CaptureType = Array<Omit<CaptureFrameType, 'imageData'>>;
+
+export declare interface CurrentPage {
+    data: Response_2 | null;
+    startNextPage: () => Promise<void>;
+    finishRecognition: () => void;
+}
+
+export declare interface CustomEventDataType<R> {
+    status: ResponseCode;
+    details?: unknown;
+    reason?: ErrorTypes;
+    response?: R;
+    video?: VideoData;
+}
+
+export declare function defineComponents(): Promise<void>;
+
+export declare interface DetailEvent<A, R> {
+    action: A;
+    data: CustomEventDataType<R> | null;
+}
+
+export declare type DocumentDictionaries = Partial<Record<Locales, DocumentTranslations>>;
+
+declare enum DocumentReaderAttributes {
+    locale = "locale",
+    multiple = "multiple",
+    license = "license",
+    copyright = "copyright",
+    startScreen = "start-screen",
+    internalScenario = "internal-scenario",
+    multipageProcessing = "multipage-processing",
+    cameraId = "camera-id",
+    changeCamera = "change-camera",
+    closeButton = "close-button",
+    captureButton = "capture-button"
+}
+
+export declare class DocumentReaderCaptureWebComponent extends HTMLElement {
+    private _root;
+    private _mounted;
+    private _translations;
+    private _settings;
+    constructor();
+    static get observedAttributes(): CameraSnapshotAttributes[];
+    private onEvent;
+    attributeChangedCallback(name: CameraSnapshotAttributes): void;
+    connectedCallback(): void;
+    set translations(dictionary: Partial<Record<string, DocumentTranslations>> | null);
+    get translations(): Partial<Record<string, DocumentTranslations>> | null;
+    set settings(params: CameraSnapshotSettings);
+    get settings(): CameraSnapshotSettings;
+    private render;
+    disconnectedCallback(): void;
+}
+
+export declare type DocumentReaderDetailType = DetailEvent<EventActions, DocumentReaderResponseType>;
+
+export declare interface DocumentReaderImage {
+    data: string;
+    light: number;
+    pageIdx: number;
+}
+
+export declare class DocumentReaderProcessor {
+    private _streamData;
+    private _documentReaderService;
+    private _canvas;
+    private _cameraInfo;
+    private _sortedDevices;
+    private _devices;
+    private _videoEventListener;
+    private _frameListener;
+    private _pageIdx;
+    private _streamParam;
+    isProcessing: boolean;
+    isInitialized: boolean;
+    videoElement: HTMLVideoElement | null;
+    constructor(videoElement?: HTMLVideoElement);
+    get recognizeListener(): ((data: Response_2) => void) | null;
+    set recognizeListener(listener: ((data: Response_2) => void) | null);
+    get streamParam(): Partial<StreamParams>;
+    set streamParam(params: Partial<StreamParams>);
+    get recognizerProcessParam(): ProcessingRequest;
+    set recognizerProcessParam(params: ProcessingRequest);
+    get imageProcessParam(): ImageProcessingRequest;
+    set imageProcessParam(params: ImageProcessingRequest);
+    get workerPath(): string;
+    set workerPath(url: string);
+    private startStream;
+    private stopStream;
+    private startRecognizeProcess;
+    private stopRecognizeProcess;
+    private startNewPage;
+    private startNewDocument;
+    switchCamera(): Promise<void>;
+    startRecognition(responseListener?: ResponseListener): Promise<Response_2 | null>;
+    processImage(images: FileList | Array<Blob>): Promise<Response_2>;
+    stopRecognition(): void;
+    initialize(license?: {
+        license: string | undefined;
+    }): Promise<License>;
+    shutdown(): void;
+}
+
+export declare interface DocumentReaderProcessParam {
+    returnPackageForReprocess?: boolean;
+    returnUncroppedImage?: boolean;
+    scenario?: InternalScenarios;
+    multipageProcessing?: boolean;
+    timeout?: number;
+    log?: boolean;
+    timeoutFromFirstDetect?: number;
+    timeoutFromFirstDocType?: number;
+    resultTypeOutput?: Array<Result>;
+    customParams?: Record<string, object>;
+    imageOutputMaxHeight?: number;
+    imageOutputMaxWidth?: number;
+    fieldTypesFilter?: Array<TextFieldType>;
+    dateFormat?: string;
+    measureSystem?: MeasureSystem;
+    imageDpiOutMax?: number;
+    alreadyCropped?: boolean;
+    fastDocDetect?: boolean;
+    updateOCRValidityByGlare?: boolean;
+    returnCroppedBarcode?: boolean;
+    respectImageQuality?: boolean;
+    forceDocFormat?: DocumentFormat;
+    noGraphics?: boolean;
+    documentAreaMin?: number;
+    depersonalizeLog?: boolean;
+    multiDocOnImage?: boolean;
+    shiftExpiryDate?: number;
+    minimalHolderAge?: number;
+    mrzFormatsFilter?: Array<MRZFormat>;
+    forceReadMrzBeforeLocate?: boolean;
+    parseBarcodes?: boolean;
+    splitNames?: boolean;
+    imageQa?: {
+        expectedPass?: Array<string>;
+        dpiThreshold?: number;
+        glaresCheck?: boolean;
+        glaresCheckParams?: {
+            imgMarginPart?: number;
+            maxGlaringPart?: number;
+        };
+    };
+    backendProcessing?: {
+        serviceURL?: string;
+        httpHeaders?: Record<string, string>;
+    };
+}
+
+export declare type DocumentReaderResponseType = Response_2 & {
+    TransactionInfo?: TransactionInfo;
+};
+
+export declare class DocumentReaderService {
+    private _worker;
+    private _prepareListener;
+    private _initializeListener;
+    private _processingListener;
+    isAutoPrepare: boolean;
+    isPrepared: boolean;
+    isInitialized: boolean;
+    isProcessing: boolean;
+    initData: License | null;
+    recognizerProcessParam: ProcessingRequest;
+    imageProcessParam: ImageProcessingRequest;
+    recognizeListener: RecognizeListener | null;
+    workerPath: string;
+    version: {
+        component: string;
+    };
+    get processingListener(): TProcessingListener | null;
+    set processingListener(listener: TProcessingListener | null);
+    get prepareListener(): TPrepareListener | null;
+    set prepareListener(listener: TPrepareListener | null);
+    get initializeListener(): TInitializeListener | null;
+    set initializeListener(listener: TInitializeListener | null);
+    private createProcessImageRequest;
+    private sendMessage;
+    prepare(): Promise<void>;
+    initialize(initData?: {
+        license: string | undefined;
+    }): Promise<License>;
+    processImageBase64(base64ImagesArray: Array<string>, params: ProcessingRequest): Promise<Response_2>;
+    process(imageDataArray: Array<ImageData>, params?: ProcessingRequest): Promise<Response_2>;
+    processImage(imageDataArray: Array<ImageData>, params?: ProcessingRequest): Promise<Response_2>;
+    startNewPage(): Promise<void>;
+    startNewDocument(metadata?: Record<string, any>): Promise<NewTransaction>;
+    createBackendTransaction(metadata?: Record<string, any>): Promise<NewTransaction>;
+    finalizePackage(): Promise<TransactionInfo>;
+    addDataToPackage(data: Uint8ClampedArray, params: PackageParams): Promise<void>;
+    shutdown(): void;
+}
+
+export declare interface DocumentReaderSettings extends CameraSnapshotSettings {
+    internalScenario?: InternalScenarios;
+    multipageProcessing?: boolean;
+    devLicense?: string;
+    captureButton?: boolean;
+    captureMode?: CaptureMode;
+    flipFrontIcon?: string;
+    flipBackIcon?: string;
+    skipButton?: boolean;
+    cameraFrameBorderWidth?: number;
+    backgroundMaskAlpha?: number;
+    cameraFramePortraitAspectRatio?: number;
+    cameraFrameLandscapeAspectRatio?: number;
+    statusPositionMultiplier?: number;
+    statusIcon?: boolean;
+    cameraFrameOffsetWidth?: number;
+    cameraFrameVerticalPositionMultiplier?: number;
+    cameraFrameShapeType?: FrameShapeType;
+    cameraFrameLineCap?: FrameLineCap;
+    cameraFrameLineLength?: number;
+    cameraFrameCornerRadius?: number;
+    cameraFrameActiveColor?: string;
+    cameraFrameDefaultColor?: string;
+    cameraFrame?: boolean;
+    captureButtonDelay?: number;
+    videoRecord?: boolean | VideoRecordSettings;
+    videoCaptureMotionControl?: boolean;
+}
+
+export declare class DocumentReaderWebComponent extends HTMLElement {
+    private _root;
+    private _mounted;
+    private _translations;
+    private _settings;
+    constructor();
+    static get observedAttributes(): DocumentReaderAttributes[];
+    private onEvent;
+    attributeChangedCallback(name: DocumentReaderAttributes): void;
+    connectedCallback(): void;
+    set translations(dictionary: Partial<Record<string, DocumentTranslations>> | null);
+    get translations(): Partial<Record<string, DocumentTranslations>> | null;
+    set settings(params: DocumentReaderSettings);
+    get settings(): DocumentReaderSettings;
+    private render;
+    disconnectedCallback(): void;
+}
+
+export declare interface 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;
+    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;
+    photoCapturedSuccessfully?: string;
+    uploadPhoto?: string;
+    useCameraOrGallery?: string;
+    connect?: string;
+    disconnect?: string;
+    process?: string;
+    device?: string;
+    service?: string;
+    autoScan?: string;
+    keepDeviceStill?: string;
+}
+
+export declare enum ErrorTypes {
+    WASM_ERROR = "WASM_ERROR",
+    WASM_LICENSE = "WASM_LICENSE",
+    FILE_SIZE = "FILE_SIZE",
+    INCORRECT_FILE = "INCORRECT_FILE",
+    INCORRECT_SCENARIO = "INCORRECT_SCENARIO",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    NOT_SUPPORTED = "NOT_SUPPORTED",
+    CAMERA_UNKNOWN_ERROR = "CAMERA_UNKNOWN_ERROR",
+    CAMERA_PERMISSION_DENIED = "CAMERA_PERMISSION_DENIED",
+    NO_CAMERA = "NO_CAMERA",
+    INCORRECT_CAMERA_ID = "INCORRECT_CAMERA_ID",
+    CONNECTION_ERROR = "CONNECTION_ERROR"
+}
+
+export declare enum EventActions {
+    ELEMENT_VISIBLE = "ELEMENT_VISIBLE",
+    PRESS_CAMERA_BUTTON = "PRESS_CAMERA_BUTTON",
+    PRESS_FILE_BUTTON = "PRESS_FILE_BUTTON",
+    PRESS_RETRY_BUTTON = "PRESS_RETRY_BUTTON",
+    PRESS_SKIP_BUTTON = "PRESS_SKIP_BUTTON",
+    PRESS_CAPTURE_BUTTON = "PRESS_CAPTURE_BUTTON",
+    PRESS_CHANGE_CAMERA_BUTTON = "PRESS_CHANGE_CAMERA_BUTTON",
+    PRESS_MIRRORING_BUTTON = "PRESS_MIRRORING_BUTTON",
+    PRESS_CONNECT_BUTTON = "PRESS_CONNECT_BUTTON",
+    PRESS_DISCONNECT_BUTTON = "PRESS_DISCONNECT_BUTTON",
+    PRESS_AUTOSCAN_BUTTON = "PRESS_AUTOSCAN_BUTTON",
+    PRESS_PROCESS_BUTTON = "PRESS_PROCESS_BUTTON",
+    NEW_PAGE_AVAILABLE = "NEW_PAGE_AVAILABLE",
+    NEW_PAGE_STARTED = "NEW_PAGE_STARTED",
+    CLOSE = "CLOSE",
+    CAMERA_PROCESS_CLOSED = "CAMERA_PROCESS_CLOSED",
+    CAMERA_PROCESS_STARTED = "CAMERA_PROCESS_STARTED",
+    VIDEO_STARTED = "VIDEO_STARTED",
+    VIDEO_STOPPED = "VIDEO_STOPPED",
+    FILE_PROCESS_STARTED = "FILE_PROCESS_STARTED",
+    PROCESS_STARTED = "PROCESS_STARTED",
+    PROCESS_FINISHED = "PROCESS_FINISHED",
+    SERVICE_INITIALIZED = "SERVICE_INITIALIZED"
+}
+
+export declare enum FrameLineCap {
+    butt = "butt",
+    round = "round",
+    square = "square"
+}
+
+export declare enum FrameShapeType {
+    line = "line",
+    corners = "corners"
+}
+
+export declare class FullScreenContainer extends HTMLElement {
+    private _root;
+    constructor();
+}
+
+export declare interface ICameraSnapshot {
+    locale?: Locales;
+    copyright?: boolean;
+    'camera-id'?: string;
+    'change-camera'?: boolean;
+    'start-screen'?: boolean;
+    multiple?: boolean;
+    'close-button'?: boolean;
+}
+
+export declare interface IDocumentReader extends ICameraSnapshot {
+    'internal-scenario'?: InternalScenarios;
+    'multipage-processing'?: boolean;
+    license?: string;
+    'capture-button'?: boolean;
+}
+
+export declare interface ImageInputParamType {
+    frameBottom: number;
+    frameLeft: number;
+    frameRight: number;
+    frameTop: number;
+    light: number;
+    resolutionType: number;
+}
+
+export declare interface ImageProcessingRequest extends BaseRequest {
+    imageInputParam?: ImageInputParamType;
+    processParam: Pick<DocumentReaderProcessParam, 'returnPackageForReprocess' | 'returnUncroppedImage' | 'scenario' | 'backendProcessing'>;
+}
+
+export declare enum InternalScenarios {
+    MrzAndLocate = "MrzAndLocate",
+    MrzOrLocate = "MrzOrLocate",
+    Mrz = "Mrz",
+    Locate = "Locate",
+    Barcode = "Barcode",
+    MrzOrBarcode = "MrzOrBarcode",
+    BarcodeAndLocate = "BarcodeAndLocate"
+}
+
+declare interface IOptions {
+    color?: string;
+}
+
+export declare type License = {
+    license: {
+        errorCode: number;
+        message: string;
+        status: boolean;
+    };
+    scenario: Array<TScenarioParams>;
+};
+
+export declare type Locales = 'ru' | 'en' | 'de' | 'pl' | 'it' | 'hu' | 'zh' | 'sk' | 'uk' | 'fr' | 'es' | 'pt' | 'ar' | 'nl' | 'id' | 'vi' | 'ko' | 'ms' | 'ro' | 'el' | 'tr' | 'ja' | 'cs' | 'th' | 'hi' | 'bn' | 'he' | 'fi' | 'sv' | 'da' | 'hr' | 'no' | string;
+
+export declare const Logger: Logger_2;
+
+declare class Logger_2 {
+    private _levels;
+    private _transports;
+    private _logs;
+    private _prevTime;
+    logListener: ((log: string) => void) | null;
+    constructor();
+    create(lvl: string, options?: IOptions): (msg: string) => void;
+    saveLogs(): void;
+}
+
+export declare interface NewTransaction {
+    ContainerList: ContainerList;
+    TransactionInfo: {
+        ComputerName: string;
+        DateTime: string;
+        SystemInfo: string;
+        Tag: string;
+        TransactionID: string;
+    };
+    sessionLogFolder: string;
+}
+
+export declare interface PackageParams {
+    sizeBytes: number;
+    dataName: string;
+    metadata?: Record<string, any>;
+}
+
+export declare interface ProcessingRequest extends BaseRequest {
+    metadata?: Record<string, any>;
+    processParam: DocumentReaderProcessParam;
+    imagesList?: Array<DocumentReaderImage>;
+    imageInputParam?: ImageInputParamType;
+}
+
+declare type RecognizeListener = (data: Response_2) => void;
+
+export declare type Resolution = Partial<WidthAndHeight>;
+
+export declare enum ResponseCode {
+    EMPTY = -1,
+    ERROR = 0,
+    OK = 1,
+    TIMEOUT = 2
+}
+
+declare type ResponseListener = (currentPage: CurrentPage) => void;
+
+export declare interface StreamParams {
+    cameraMode: CameraFacingMode;
+    preferredCameraId: string;
+    resolution: Resolution;
+}
+
+declare type TInitializeListener = ({ isInitialized }: {
+    isInitialized: boolean;
+}) => void;
+
+declare type TPrepareListener = ({ isPrepared }: {
+    isPrepared: boolean;
+}) => void;
+
+declare type TProcessingListener = ({ isProcessing }: {
+    isProcessing: boolean;
+}) => void;
+
+export declare interface TransactionInfo {
+    tag: string;
+    transactionId: string;
+}
+
+export declare type TScenarioParams = {
+    name: string;
+    desc: string;
+    caption: string;
+    frameKWHDoublePageSpreadLandscape: string;
+    frameKWHDoublePageSpreadPortrait: string;
+    frameKWHLandscape: string;
+    frameKWHPortrait: string;
+    frameOrientation: number;
+    barcodeExt?: number;
+    faceExt?: number;
+    manualCrop?: number;
+    multiPageOff?: number;
+    seriesProcessMode?: number;
+    UVTorch?: number;
+};
+
+export declare interface VideoData {
+    data: Blob;
+    mimeType: string;
+}
+
+export declare interface VideoRecordSettings {
+    delay?: number;
+    duration?: number;
+}
+
+export declare interface WidthAndHeight {
+    width: number;
+    height: number;
+}
+
+export { }
+
+
+declare global {
+    interface HTMLElementEventMap {
+        'document-reader': CustomEvent<DocumentReaderDetailType>;
+        'camera-snapshot': CustomEvent<CameraSnapshotDetailType>;
+    }
+    interface Window {
+        RegulaDocumentSDK: DocumentReaderService;
+    }
+}
+