@regulaforensics/idv-capture-web 3.1.238-rc → 3.2.1-nightly

package/README.md

@@ -17,7 +17,7 @@
 
 The available component is `<idv-flow>`.
 
-The component is based on WebAssembly (compiled from our core C++ code and wrapped with JavaScript). The same code is used across all SDK packages, ensuring consistency between platforms.
+The component designed to play the idv workflow of the platform , collect data from users , and send data to the platform .
 
 ## Before You Start
 

package/dist/index.d.ts

@@ -1,9 +1,20 @@
+import { CSSResult } from 'lit';
+import { LitElement } from 'lit';
+import { nothing } from 'lit';
+import { TemplateResult } from 'lit-html';
+
 export declare type ApiKeyConnectionConfig = {
     baseUrl: string;
     apiKey: string;
     ttl?: number;
 };
 
+declare type AuthTokenStoreData = {
+    apiKey: string;
+    authToken: string;
+    tokenExpiresAt: number;
+};
+
 declare class BaseConfigureError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -16,6 +27,18 @@ declare class BaseConfigureError extends BaseError {
     });
 }
 
+declare class BaseConnectionError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: ConnectionError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
 declare class BaseDeinitializationError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -28,7 +51,7 @@ declare class BaseDeinitializationError extends BaseError {
     });
 }
 
-declare class BaseError {
+export declare class BaseError {
     errorCode: number | string;
     errorCodeKey: string;
     message?: string;
@@ -68,6 +91,11 @@ declare class BaseInitializationError extends BaseError {
     });
 }
 
+export declare abstract class BaseModule<TModuleProps = unknown, TModulesConfig = unknown> extends HTMLElement {
+    abstract props: IdvModuleProps<TModuleProps, TModulesConfig> | null;
+    abstract setProps(config: IdvModuleProps<TModuleProps, TModulesConfig>): void;
+}
+
 declare class BasePrepareWorkflowError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -115,17 +143,51 @@ declare enum ConfigureError {
     SCENARIO_IN_PROGRESS = 3
 }
 
+declare type ConnectionByApiKeyConfigCore = {
+    host: string;
+    isSecure?: boolean;
+    port?: number;
+    apiKey: string;
+    authToken?: string;
+    tokenExpiresAt?: number;
+    deviceDescriptor: {
+        ttl: number;
+    };
+};
+
+declare type ConnectionConfigCore = {
+    host: string;
+    isSecure?: boolean;
+    password: string;
+    port?: number;
+    userName: string;
+};
+
 export declare enum ConnectionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1
 }
 
+declare type ContinueSessionResults = SessionData | WorkflowResult | {
+    error?: BaseWorkflowError;
+};
+
 export declare type CredentialConnectionConfig = {
     baseUrl: string;
     password: string;
     userName: string;
 };
 
+declare type CurrentScreenConfig = {
+    templateId: string;
+    templateLayout?: Record<string, unknown>;
+    dataSource: Record<string, unknown> | null;
+    properties?: SessionPropertiesItem[];
+    sessionId?: string;
+    serviceToken?: string;
+    locale?: string;
+} & Record<string, any>;
+
 export declare enum DeinitializationError {
     INITIALIZATION_REQUIRED = 0,
     SCENARIO_IN_PROGRESS = 3
@@ -135,6 +197,90 @@ export declare type DeinitializeCompletion = {
     error?: BaseDeinitializationError;
 };
 
+declare type FetchErrorResult = {
+    code: FetchResultCode.HTTP_ISSUE | FetchResultCode.PROVIDER_ERROR | FetchResultCode.DECODING_FAILED;
+    data: FetchState;
+};
+
+declare enum FetchResultCode {
+    SUCCESS = 0,
+    HTTP_ISSUE = 4,
+    PROVIDER_ERROR = 5,
+    DECODING_FAILED = 6
+}
+
+declare type FetchState = {
+    httpCode: number;
+    method: string;
+    url: string;
+    what?: string;
+};
+
+declare type GeoCoords = {
+    lat: number;
+    lon: number;
+};
+
+declare type GetSessionStateNextStepConditionResult = {
+    data?: SessionData;
+    error?: BaseWorkflowError;
+    shouldRetry?: boolean;
+};
+
+declare type IdvBusinessLogicControllerProps = {
+    connectByUserPass: (config: ConnectionConfigCore) => Promise<{
+        error?: BaseConnectionError;
+    }>;
+    connectByApiKey: (config: ConnectionByApiKeyConfigCore) => Promise<{
+        error?: BaseTokenInitializationError;
+        workflows?: string[];
+        authToken?: string;
+    }>;
+    connectByUrl: (urlWithToken: string) => Promise<{
+        error?: BaseTokenInitializationError;
+        workflows: string[];
+    }>;
+    workflowSessionCompletion: (data: WorkflowCompletion) => void;
+    setWorkflowSessionCompletion: (fn: (data: WorkflowCompletion) => void) => void;
+    loadModules: (modulesFromProps: any[]) => Promise<{
+        error?: BaseInitializationError;
+    }>;
+    setProcessingTemplate: (workflowSteps: any[]) => void;
+    isProcessing: boolean;
+    setIsProcessing: (isProcessing: boolean) => void;
+    _pushStep: (stepId: string, data: Record<string, any>, type?: PerformType) => Promise<{
+        error?: BaseWorkflowError;
+    }>;
+    _waitingForNextStep: () => Promise<{
+        sessionData: SessionData;
+        error?: undefined;
+    } | {
+        error: BaseWorkflowError;
+        sessionData?: undefined;
+    }>;
+    _stepSocketListenerWhenStepIsRunning: (isStepRunning: boolean) => void;
+    _getSessionStateNextStepConditionResult: () => Promise<GetSessionStateNextStepConditionResult>;
+    _findStepById: (stepId: string) => WorkflowStep | null;
+    pushStepWaitNextStepAndSet: (data: Record<string, any>, type?: PerformType) => void;
+    setNextStep: (props: {
+        workflow: Workflow;
+        properties: SessionPropertiesItem[];
+        nextStepId: string;
+        locale: string;
+    }) => void;
+    onChangeScreen: (stepId: string | null) => void;
+    deinitializationIdv: () => Promise<{
+        error?: any;
+    }>;
+    fetchService: IdvFetchService | null;
+    setAndInitFetchService: () => Promise<void>;
+    isFinalWaitingUi: boolean;
+    setFinalWaitingUi: (isWaitingUi: boolean) => void;
+    setFinalStepAndStopProcess: (stepId?: string) => void;
+    resetSession: () => void;
+    resetFetchService: () => void;
+};
+
 export declare type IdvEventTypes = (typeof IdvEventTypesEnum)[keyof typeof IdvEventTypesEnum];
 
 export declare const IdvEventTypesEnum: {
@@ -142,6 +288,151 @@ export declare const IdvEventTypesEnum: {
     readonly ERROR: "ERROR";
 };
 
+declare class IdvFetchService {
+    private _connectionTokenExpirationBufferMs;
+    private _origin;
+    private _locale;
+    private _workflowId;
+    private _session;
+    private _apiKeyAuthToken;
+    private _connectionToken;
+    private _connect;
+    private _getErrorTextFromError;
+    private _setApiKeyAuthToken;
+    private _setConnectionToken;
+    private _getOriginFromConfig;
+    private _getOriginFromUrl;
+    private _getExpiresAtFromTtl;
+    private _getAuthorizationHeaderFromConnectionToken;
+    private _getAuthorizationHeaderFromBasicToken;
+    private _getAuthorizationHeaderFromAuthToken;
+    private _getApiKeyAuthTokenFromLs;
+    private _getApiKeyAuthTokenFromHeader;
+    _getValidApiKeyAuthToken(config: {
+        apiKey: string;
+        deviceDescriptor: {
+            ttl: number;
+        };
+    }, isFromSession: boolean): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            token: string;
+            expiresAt: number;
+        };
+    } | FetchErrorResult>;
+    private _getAuthorizationSearchParam;
+    private _getResponseTextFromBadResponse;
+    private _fetchPing;
+    private _fetchMe;
+    private _fetchConnection;
+    private _fetchEphemeral;
+    private _fetchSessionByWorkflowId;
+    private _fetchSessionState;
+    private _fetchWorkflows;
+    private _fetchWorkflow;
+    private _fetchStep;
+    private _fetchSessionLogs;
+    connectByUserPass(config: ConnectionConfigCore): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    connectByApiKey(config: ConnectionByApiKeyConfigCore, isFromSession: boolean): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            authToken: string;
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    connectByUrl(urlWithToken: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    getConnectionToken(isFromSession: boolean): Promise<string>;
+    startSession({ workflowId, locale, metadata, location, }: {
+        workflowId: string;
+        locale: string;
+        metadata?: Record<string, unknown>;
+        location?: GeoCoords | null;
+    }): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    continueSession(sessionId: string, locale: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    listWorkflows(params?: {
+        limit: number;
+        skip: number;
+    }): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            count: number;
+            items: Workflow[];
+        };
+    } | FetchErrorResult>;
+    getWorkflow(workflowId: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: Workflow;
+    } | FetchErrorResult>;
+    pushData(stepId: string, data: any, type?: PerformType): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: Record<string, unknown>;
+    } | FetchErrorResult>;
+    getSessionState(): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    pushSessionLogs(pushSessionLogsParams: PushSessionLogsParams): Promise<Record<string, unknown>>;
+}
+
+declare type IdvIntegrationControllerProps = {
+    _isInitialized: boolean;
+    _isConnectedToPlatform: boolean;
+    _initializationInProgress: boolean;
+    _sessionIdFromUrl: null | string;
+    _ttl: number;
+    _continueSession: (locale: string, forceSessionId: string | null) => Promise<ContinueSessionResults>;
+    _checkIsSessionDataValid: (sessionData: SessionData | {
+        httpCode: number;
+        method: string;
+        url: string;
+        what?: string;
+    }) => SessionData | {
+        error?: BaseWorkflowError;
+    };
+    _checkAndSetApiTokenToLs: (sessionId: string) => void;
+    _runSocketConnection: (token: string) => Promise<{
+        error?: BaseWorkflowError;
+    }>;
+    initialize: (config: InitConfig) => Promise<{
+        error?: BaseInitializationError;
+    }>;
+    configureByUserPass: (config: CredentialConnectionConfig) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    configureWithUrl: (urlWithToken: string) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    configureByApiKey: (config: ApiKeyConnectionConfig) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    getWorkflows: (params?: WorkflowListRequest) => Promise<WorkflowListCompletion>;
+    prepareWorkflowAndPrepareUi: (workflowId: string) => Promise<PrepareWorkflowCompletion>;
+    startNewSession: (params: {
+        completion: (data: WorkflowCompletion) => void;
+        locale: string;
+        metadata?: Record<string, unknown>;
+        location?: GeoCoords | null;
+    }) => Promise<WorkflowCompletion>;
+    playWorkflow: () => void;
+    deinitialize: () => Promise<DeinitializeCompletion>;
+};
+
 export declare class IdvIntegrationService {
     /** main commands */
     initialize(config: InitConfig): Promise<{
@@ -167,6 +458,23 @@ export declare type IdvMessageEvent = {
     message?: IdvServiceMessages;
 };
 
+export declare type IdvModuleProps<TModuleProps, TModulesConfig> = {
+    isProcessing?: (isProcessing: boolean) => void;
+    moduleProps: TModuleProps;
+    modulesConfig?: TModulesConfig;
+    perform: (data: any, type?: PerformType) => void;
+    idvEventListener: (module: string, data: any) => void;
+};
+
+export declare interface IdvModuleStaticMethods {
+    displayName: string;
+    isReady(): boolean;
+    getSupportedTemplates(): string[];
+    initialize(modulesConfig: Record<string, unknown>): void;
+    deinitialize(): void;
+    getIdentifier(): string;
+}
+
 export declare enum IdvServiceMessages {
     DID_START_SESSION = "DID_START_SESSION",
     DID_END_SESSION = "DID_END_SESSION",
@@ -174,15 +482,80 @@ export declare enum IdvServiceMessages {
     DID_CONTINUE_REMOTE_SESSION = "DID_CONTINUE_REMOTE_SESSION"
 }
 
-export declare class IdvWebComponent extends HTMLElement {
-    private _root;
-    private _mounted;
-    constructor();
-    static get observedAttributes(): Array<string>;
+declare type IdvStoreProps = {
+    sessionRestoreMode: boolean;
+    setSessionRestoreMode: (isEnabled: boolean) => void;
+    currentSessionData: {
+        sessionId: string;
+        workflowId: string;
+    } | null;
+    setCurrentSessionDataLsAndStore: (data: {
+        sessionId: string;
+        workflowId: string;
+    }) => void;
+    removeCurrentSessionDataLsAndStore: () => void;
+    getCurrentSessionDataLs: () => {
+        sessionId: string;
+        workflowId: string;
+        apiKey?: string;
+    } | null;
+    getCurrentSessionId: () => string | null;
+    modulesConfig: Record<string, any>;
+    layout: Record<string, any> | null;
+    sessionProperties: SessionPropertiesItem[];
+    setSessionProperties: (properties: SessionPropertiesItem[]) => void;
+    setLayout: (layout: Record<string, any>) => void;
+    workflow: Workflow | null;
+    setWorkflow: (workflow: Workflow) => void;
+    currentStepId: string | null;
+    setCurrentStepId: (stepId: string) => void;
+    listener: (message: IdvMessageEvent) => void | null;
+    setListener: (callback: (message: IdvMessageEvent) => void) => void;
+    workflowId: string | null;
+    setWorkflowId: (id: string) => void;
+    nonce?: string;
+    setNonce: (id: string) => void;
+    getNonce: () => string | undefined;
+    currentScreenConfig: CurrentScreenConfig | null;
+    externalModules: LoadedModule[] | [];
+    processingTransformedTemplate: WorkflowStepClientGui | null;
+    serviceToken?: string;
+    apiKeyAuthTokenCollection: AuthTokenStoreData | Record<string, unknown>;
+    setApiKeyAuthTokenCollection: (apiKey: string, authToken: string, tokenExpiresAt: number) => void;
+    setServiceSessionToken: (token: string) => void;
+    resetProps: () => void;
+    startConfig: StartConfig;
+    setStartConfig: (startConfig: StartConfig) => void;
+    locale: string;
+    setLocale: (locale: string) => void;
+    trackLocation: boolean;
+    setTrackLocation: (trackLocation: boolean) => void;
+};
+
+export declare class IdvWebComponent extends LitElement {
+    private _currentProgressElement;
+    private _currentScreenElement;
+    private _currentScreenModuleId;
+    private _currentScreenConfig;
+    private orientation;
+    private unsubscribeFromStore?;
+    static styles: CSSResult[];
+    store: IdvStoreProps & IdvIntegrationControllerProps & IdvBusinessLogicControllerProps;
+    currentScreenConfig: CurrentScreenConfig | null;
+    processingScreenFromWorkflow: WorkflowStepClientGui | null;
+    isProcessing: boolean;
+    loadedModules: [] | LoadedModule[];
+    modulesConfig: Record<string, any>;
     connectedCallback(): void;
+    _listenerFromModule: (module: string, data: any) => void;
+    _isProcessingCallback: (isProcessing: boolean) => void;
+    _performFromModule: (data: any, type?: PerformType) => void;
+    _processingScreen(): HTMLElement | TemplateResult<1>;
+    private _isTheSameModuleAndScreen;
+    _currentScreen(): HTMLElement | typeof nothing;
     get version(): string;
-    private render;
     disconnectedCallback(): void;
+    render(): TemplateResult<1> | null;
 }
 
 export declare type InitConfig = {
@@ -205,6 +578,21 @@ export declare enum InitializeError {
     INITIALIZATION_IN_PROGRESS = 2
 }
 
+declare type LoadedModule = {
+    id: string;
+    supportedTemplates: string[];
+    component: any;
+};
+
+export declare type ModuleClass<TModuleProps = unknown, TModulesConfig = unknown> = IdvModuleStaticMethods & (new (...args: any[]) => BaseModule<TModuleProps, TModulesConfig>);
+
+declare type PerformType = (typeof performType)[keyof typeof performType] | undefined;
+
+declare const performType: {
+    readonly FORM: "form";
+    readonly DATA: "data";
+};
+
 export declare type PrepareWorkflowCompletion = {
     workflow?: Workflow;
     error?: BasePrepareWorkflowError;
@@ -218,6 +606,25 @@ export declare enum PrepareWorkflowError {
     SCENARIO_IN_PROGRESS = 4
 }
 
+declare type PushSessionLogsParams = {
+    body: {
+        log: string;
+        errorCode?: string;
+        deviceInfo?: Record<string, string>;
+    };
+};
+
+export declare function registerModule<TModuleProps = unknown, TModulesConfig = unknown>(name: string, ModuleClass: ModuleClass<TModuleProps, TModulesConfig>): void;
+
+declare type SessionData = {
+    id: string;
+    currentStep: string;
+    workflow: Workflow;
+    properties: SessionPropertiesItem[];
+    isProcessingFiles: boolean;
+    locale: string;
+};
+
 export declare enum SessionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1,
@@ -227,6 +634,31 @@ export declare enum SessionError {
     NOT_DATA_TYPE = 5
 }
 
+/** sync with gui module */
+declare type SessionPropertiesItem = {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: unknown;
+    updatedBy: unknown;
+    action: unknown;
+    step: string;
+    name: string;
+    path: unknown;
+    string: string;
+    array?: string[];
+    integer: unknown;
+    decimal: unknown;
+    object: unknown;
+};
+
+declare type StartConfig = {
+    host?: string;
+    isSecure?: boolean;
+    apiKey?: string;
+    port?: number;
+};
+
 export declare enum StartSessionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1,
@@ -304,9 +736,11 @@ declare type WorkflowResult = {
 } & Record<string, any>;
 
 declare type WorkflowStep = {
+    type: string;
     id: string;
     name: string;
     final: boolean;
+    releaseClientApp: boolean;
     client?: Record<string, unknown> | WorkflowStepClientGui;
     dataSource: Record<string, unknown> | null;
 } & Record<string, any>;