@trulioo/docv-capture-web 2.13.0

package/LICENSE.md

@@ -0,0 +1,13 @@
+BY DOWNLOADING, INSTALLING, ACCESSING, OR OTHERWISE USING THE IMAGE CAPTURE SDK (DEFINED BELOW) PROVIDED OR MADE AVAILABLE BY TRULIOO INFORMATION SERVICES INC. (“**us**,” “**we**,” or “**our**”), YOU HEREBY AGREE TO BE BOUND BY THE TERMS AND CONDITIONS SET FORTH BELOW (“**Terms**”). IF YOU DO NOT AGREE TO THESE TERMS, THEN YOU DO NOT HAVE OUR PERMISSION TO USE THE IMAGE CAPTURE SDK. THESE TERMS DO NOT GRANT YOU OR ANY USER OF YOUR APPLICATION (AS DEFINED BELOW) THE RIGHT TO ACCESS OR USE ANY OF OUR OTHER PRODUCTS AND SERVICES (“**Services**”), AND ANY ACCESS TO OR USE OF THE SERVICES IS SUBJECT TO THE CUSTOMER AGREEMENT ENTERED INTO BETWEEN YOU AND US (IF ANY) GOVERNING SUCH ACCESS AND USE (“**Customer Agreement**”). IF THE IMAGE CAPTURE SDK IS BEING USED ON BEHALF OF A COMPANY, ORGANIZATION, OR OTHER ENTITY, THEN ALL REFERENCES TO “YOU,” OR “YOUR” REFER TO SUCH ENTITY AND ITS AFFILIATES, AND THE INDIVIDUAL AGREEING TO THESE TERMS ON YOUR BEHALF REPRESENTS AND WARRANTS THAT THEY HAVE AUTHORITY TO BIND YOU TO THESE TERMS.
+
+1. <u>License; License Keys</u>. Subject to your compliance with these Terms, we hereby grant you a limited, non-exclusive, non-sublicensable, non-transferable, royalty-free, fully paid-up license, exercisable by and through your employees and contractors, to internally use and reproduce a reasonable number of copies of the software development kit (including any portion thereof) provided or made available by us to you under these Terms (“**Image Capture SDK**”) for the sole purpose of your internal development and testing of a software application developed by you or on your behalf that interoperates with Services (“**Application**”). Any use of the Image Capture SDK in a production format of your Application, for commercial purposes, or for any other purpose not expressly permitted by this Section 1 requires a license key provided by us to you pursuant to the Customer Agreement (“**License Key(s)**”). You hereby acknowledge and agree that: (a) the Image Capture SDK, the License Keys, and any know-how and trade secrets relating thereto are our sole and exclusive property and are confidential and proprietary to us; and (b) you will protect each of them using the same degree of care, but no less than a reasonable degree of care, as you use to protect your own confidential information.       
+
+2. <u>Restrictions</u>. Except to the extent otherwise permitted under these Terms or under applicable law, you will not, nor will you permit any third party to: (a) implement the Image Capture SDK in any software other than your Application or for any purpose other than its interoperation with the Services; (b) modify, translate, or create a derivative work of any portion of the Image Capture SDK; (c) sell, lease, loan, provide, distribute, disclose, expose, or otherwise transfer any portion of the Image Capture SDK (including any License Keys) to any third party (except for the limited right to distribute, in object code format, any source code (modified or unmodified) or object code provided with the Image Capture SDK solely as integrated components of your Application); (d) reverse engineer, disassemble, decompile, or otherwise attempt to gain access to the source code of the Services or the Image Capture SDK; (e) remove, alter, or obscure any copyright notices or other proprietary rights notices displayed on any portion of the Image Capture SDK; (f) use the Image Capture SDK or the License Keys to develop any software (including your Application) or other technology that (1) can be used with any service or product other than the Services, or (2) is competitive, directly or indirectly, with the Services; (g) interfere with the normal operation and security of the Image Capture SDK or the Services; (h) release or commercially distribute to third parties an Application in production format that is (1) not fully compatible with the Image Capture SDK and the Services, or (2) integrated or interoperable with any application programming interface not provided with the Image Capture SDK; or (i) circumvent or disable any technological, usage, or security features, restrictions, or limitations of any portion of the Image Capture SDK (including any License Keys).   
+
+3. <u>Other Terms</u>. The Image Capture SDK is licensed, not sold, to you.  All rights not expressly granted herein are reserved by us.  No additional rights whatsoever are granted to you by implication, estoppel or otherwise. The Image Capture SDK may incorporate third-party open-source software (“OSS”), as specified by us in the Image Capture SDK documentation or upon your prior written request, and any use of OSS on a stand-alone basis will be subject to the terms of the applicable OSS license and not these Terms. We reserve the right to modify or discontinue our provision of all or any portion of the Image Capture SDK at any time, temporarily or permanently, without notice to you. These Terms and the rights and licenses granted hereunder: (a) can be terminated by us at any time for any reason or for no reason at all, without notice to you; and (b) will automatically terminate if you breach any provision of these Terms. Upon any termination of these Terms, you must immediately cease all use of the Image Capture SDK and destroy all copies of the Image Capture SDK in your control or possession. If you have entered into a Customer Agreement with us or have otherwise agreed to other policies, guidelines, or terms and conditions (click-through, click-wrap, or otherwise) with us, they may contain additional rights, restrictions, and obligations relating to your access to and use of the Image Capture SDK that are not expressly set forth herein, and you are responsible for complying with them.  
+
+4. <u>Disclaimer</u>. THE IMAGE CAPTURE SDK AND ALL INTELLECTUAL PROPERTY MADE AVAILABLE OR LICENSED BY US UNDER THESE TERMS ARE PROVIDED “AS IS” WITHOUT ANY REPRESENTATION OR WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY, NON INFRINGEMENT, QUALITY, ACCURACY, AND FITNESS FOR A PARTICULAR PURPOSE.  ANY USE OF THE IMAGE CAPTURE SDK IS AT YOUR OWN RISK.
+
+5. <u>Limitation of Liability</u>. TO THE FULLEST EXTENT PERMITTED BY LAW, IN NO EVENT WILL WE, UNDER THESE TERMS, HAVE ANY (a) LIABILITY TO YOU OR TO ANY THIRD PARTY HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE), or (b) OBLIGATION TO INDEMNIFY, DEFEND, OR HOLD YOU OR ANY THIRD PARTY HARMLESS. TO THE EXTENT THAT A COURT HOLDS THAT THESE TERMS ARE INVALID OR UNENFORCEABLE AS A RESULT OF OUR DISCLAIMING ALL LIABILITY AND DAMAGES UNDER THESE TERMS PURSUANT TO THIS SECTION 5, THEN, TO THE FULLEST EXTENT PERMITTED BY LAW, OUR TOTAL LIABILITY TO YOU HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) WILL NOT EXCEED $50.00 (USD).   
+
+6. <u>Miscellaneous</u>. These Terms are governed by the laws of British Columbia, Canada without regard to conflict of law principles. You may not assign or transfer these Terms or your rights hereunder, in whole or in part, by operation of law, change of control, or otherwise, without our prior written consent. Any attempted assignment by you in violation of this Section will be null and void. If any part of these Terms is held to be invalid or unenforceable, then the unenforceable part will be given effect to the greatest extent possible, and the remaining parts will remain in full force and effect.

package/README.md

@@ -0,0 +1,155 @@
+# @trulioo/docv-capture-web
+
+Trulioo DocVCapture Web SDK
+
+<hr />
+
+## Document Capture and Verification Flow Overview
+
+### Starting a new document verification transaction
+
+Create an instance of `TruliooCapture` and call the `initialize` function using the shortcode obtained from the Trulioo API endpoint: `/customer/handoff`.
+This will create a new document verification transaction with a unique Transaction ID.
+
+```javascript showLineNumbers
+const shortCode = "generatedFromTruliooAPI"
+
+const truliooCapture = new TruliooCapture()
+
+truliooCapture.initialize(shortCode).then((transactionId) => {
+    console.log(`Success initialize with transaction ID: ${transactionId}`)
+}).catch(error => {
+    console.log(`Error on initialize: ${error}`)
+})
+
+```
+
+### Creating and rendering a camera component
+
+Using the same created instance of `TruliooCapture`, we can get a camera component to be rendered later by calling the `getCameraComponent` function.
+We can specify the camera detection type by providing a `ITruliooCameraConfig` with the desired `DetectionType`.
+
+```javascript showLineNumbers
+
+// Will get a document detection type camera by default.
+const documentCamera = truliooCapture.getCameraComponent()
+
+
+// To get a selfie detection type camera.
+const selfieCamera = truliooCaptureSdkInstance.getCameraComponent({
+  detectionType: DetectionType.BIOMETRIC_SELFIE,
+})
+```
+
+To render the camera component on the screen, we just need to call the `renderCamera` function. This will render a full screen camera on the screen by attaching
+a video element to the parent element based on the provided element id. We can also include a callback function that will be called by the SDK when the camera is successfully loaded.
+The `onCaptureRegionChange` callback function is provided, which will return the current capture frame coordinates location (the location on the camera screen where the document/face should be located to do a capture).
+We can utilize this coordinate information to render custom UI overlay.
+
+```javascript showLineNumbers
+documentCamera.renderCamera("parent-element-id", (cameraLoadSuccess) => {
+  if (cameraLoadSuccess) {
+    console.log("Camera loaded successfully!")
+  } else {
+    console.log("Failed to load camera.")
+  }
+}, {
+  onCaptureRegionChange: (captureRegion) => {
+    // Utilize the given captureRegion data to render custom UI.
+  }
+})
+```
+
+To remove/unrender the current camera on the screen, call the `removeCamera` function.
+
+```javascript showLineNumbers
+documentCamera.removeCamera()
+```
+
+### Starting the document capture flow
+
+
+Once the camera component is loaded and ready. We can start the document capture experience by calling `startFeedback` from previously created `TruliooCapture` instance.
+
+
+To do an auto capture experience (a good document/selfie image criteria decided entirely by SDK), we can simply call `startFeedback` by just providing the camera id that refers to the
+currently active/rendered camera component. The promise will only resolve when the SDK manage to capture a good image that is presented in front of the camera capture frame.
+
+```javascript showLineNumbers
+truliooCapture.startFeedback(documentCamera.id).then((result: ITruliooCaptureResponse) => {
+    console.log(`Succesfully captured a good image: ${result}`)
+})
+```
+
+We can also stop the feedback by calling the `stopFeedback` function. This will stop any ongoing feedback from the camera component.
+
+```javascript showLineNumbers
+truliooCapture.stopFeedback(documentCamera.id)
+
+```
+
+
+The SDK also provides the `onFeedbackState` function that we can listen to for the ongoing capture state updates that is started by the `startFeedback` function.
+This allows us to add any logic needed or render any necessary custom UI needed based on the current capture state.
+It is recommended to call the `onFeedbackState` function and start listening to the feedback state before calling the `startFeedback` function.
+
+```javascript showLineNumbers
+truliooCapture.onFeedbackState(
+    (feedbackState: FeedbackState) => {
+        switch (feedbackState) {
+            case FeedbackState.NONE:
+                // Nothing happened yet/no document detected at this point.
+                break
+            case FeedbackState.CAPTURING:
+                // Currently in the middle of capturing a document.
+                break
+            case FeedbackState.BLUR:
+                // The detected document is blurry. Show a blur UI feedback to user.
+                break
+            case FeedbackState.SUCCESS:
+                // Manage to captured a document.
+                break
+            default:
+                break
+        }
+    },
+)
+```
+
+Note that the above flow is the same for the selfie capture type too.
+
+
+### Analysing the captured image result through post capture verify feedback
+
+
+Once we have the resulting `ITruliooCaptureResponse` image data, we are able to get a post capture feedback by simply calling the `verifyImage` function that is
+part of the response data. This will give use more information regarding the captured image and let us decide whether we should submit the captured image for
+verification by calling the `acceptImage` function.
+
+
+
+```javascript showLineNumbers
+// As an example, we will submit the captured image for document verification if the post capture feedback returns a CAN_BE_PROCESSED status.
+result.verifyImage().then((verifyFeedback: ITruliooVerifyResponse) => {
+    if (verifyFeedback.verificationStatus == VerificationStatus.CAN_BE_PROCESSED) {
+        // Note that the acceptImage can be called outside of the verifyImage function.
+        result.acceptImage().then((status: boolean) => {
+            console.log("Successfully submitted the image")
+        })
+    } else {
+        // Do something else. Ex. notify the user about the not accepted image and retake a new image.
+    }
+})
+```
+
+
+### Finalize the document verification transaction
+
+Once we submitted all the necessary image for the transaction, we can finalize the transaction by calling the `submitTransaction` function.
+
+
+```javascript showLineNumbers
+truliooCapture.submitTransaction().then((status: Boolean) => {
+    console.log("Transaction Successfully submitted.")
+})
+```

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@trulioo/docv-capture-web",
+  "version": "2.13.0",
+  "main": "trulioo-docv-capture-web.js",
+  "types": "trulioo-docv-capture-web.d.ts",
+  "devDependencies": {
+    "webpack": "5.82.0",
+    "webpack-cli": "5.1.0",
+    "source-map-loader": "4.0.1",
+    "typescript": "5.0.4",
+    "webpack-dev-server": "4.15.0",
+    "hash.js": "1.1.7",
+    "lottie-web": "5.12.2",
+    "intl-tel-input": "20.3.0",
+    "@connectrpc/connect": "1.4.0",
+    "@connectrpc/connect-web": "1.4.0",
+    "@bufbuild/protobuf": "1.10.0",
+    "format-util": "^1.0.5",
+    "node-fetch": "2.6.7",
+    "abort-controller": "3.0.0",
+    "ws": "8.5.0",
+    "@js-joda/core": "3.2.0"
+  },
+  "dependencies": {},
+  "peerDependencies": {},
+  "optionalDependencies": {},
+  "bundledDependencies": [],
+  "license": "SEE LICENSE IN LICENSE.md"
+}

package/trulioo-docv-capture-web.d.ts

@@ -0,0 +1,208 @@
+type Nullable<T> = T | null | undefined
+export declare namespace com.trulioo.docv.core.workflow {
+    abstract class Sequence {
+        private constructor();
+        static get WELCOME(): com.trulioo.docv.core.workflow.Sequence & {
+            get name(): "WELCOME";
+            get ordinal(): 0;
+        };
+        static get USER_CONSENT(): com.trulioo.docv.core.workflow.Sequence & {
+            get name(): "USER_CONSENT";
+            get ordinal(): 1;
+        };
+        static get CAPTURE_DOCUMENT(): com.trulioo.docv.core.workflow.Sequence & {
+            get name(): "CAPTURE_DOCUMENT";
+            get ordinal(): 2;
+        };
+        static get CAPTURE_FACE(): com.trulioo.docv.core.workflow.Sequence & {
+            get name(): "CAPTURE_FACE";
+            get ordinal(): 3;
+        };
+        static get COMPLETE(): com.trulioo.docv.core.workflow.Sequence & {
+            get name(): "COMPLETE";
+            get ordinal(): 4;
+        };
+        static values(): Array<com.trulioo.docv.core.workflow.Sequence>;
+        static valueOf(value: string): com.trulioo.docv.core.workflow.Sequence;
+        get name(): "WELCOME" | "USER_CONSENT" | "CAPTURE_DOCUMENT" | "CAPTURE_FACE" | "COMPLETE";
+        get ordinal(): 0 | 1 | 2 | 3 | 4;
+    }
+}
+export declare namespace com.trulioo.docv.core.workflow {
+    class WorkflowTheme {
+        constructor(logoSource?: Nullable<string>, primaryButtonColor?: Nullable<string>, primaryButtonTextColor?: Nullable<string>);
+        get logoSource(): Nullable<string>;
+        get primaryButtonColor(): Nullable<string>;
+        get primaryButtonTextColor(): Nullable<string>;
+        copy(logoSource?: Nullable<string>, primaryButtonColor?: Nullable<string>, primaryButtonTextColor?: Nullable<string>): com.trulioo.docv.core.workflow.WorkflowTheme;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare class TruliooCamera /* extends capture.Camera */ {
+    constructor(cameraId: string, cameraDetectionType: DetectionType);
+    get id(): string;
+    get detectionType(): DetectionType;
+    removeCamera(): void;
+    renderCamera(parentElementId: string, onCameraLoaded?: (p0: boolean) => void, cameraProps?: Nullable<CameraProps>): void;
+}
+export declare class CameraProps {
+    constructor(backgroundColor: Nullable<string>, onCaptureRegionChange: Nullable<(p0: CaptureRegion) => void>);
+    get backgroundColor(): Nullable<string>;
+    get onCaptureRegionChange(): Nullable<(p0: CaptureRegion) => void>;
+    copy(backgroundColor?: Nullable<string>, onCaptureRegionChange?: Nullable<(p0: CaptureRegion) => void>): CameraProps;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare interface CaptureRegion {
+    readonly bottomRight: PointCoordinates;
+    readonly center: PointCoordinates;
+    readonly selfieRadius: number;
+    readonly topLeft: PointCoordinates;
+    readonly __doNotUseOrImplementIt: {
+        readonly CaptureRegion: unique symbol;
+    };
+}
+export declare interface PointCoordinates {
+    readonly x: number;
+    readonly y: number;
+    readonly __doNotUseOrImplementIt: {
+        readonly PointCoordinates: unique symbol;
+    };
+}
+export declare class TruliooCapture {
+    constructor();
+    initialize(shortCode: string, previewMode?: boolean): Promise<string>;
+    getCameraComponent(config?: Nullable<TruliooCameraConfig>): TruliooCamera;
+    startFeedback(cameraId: string, imageFeedback?: Nullable<(p0: TruliooImageFeedback) => void>): Promise<TruliooCaptureResponse>;
+    stopFeedback(cameraId: string): Promise<boolean>;
+    onFeedbackState(feedback: (p0: TruliooFeedbackState) => void): void;
+    captureLatestFrame(): Promise<TruliooCaptureResponse>;
+    submitTransaction(): Promise<boolean>;
+}
+export declare interface TruliooCameraConfig {
+    readonly detectionType: DetectionType;
+    readonly __doNotUseOrImplementIt: {
+        readonly TruliooCameraConfig: unique symbol;
+    };
+}
+export declare abstract class DetectionType {
+    private constructor();
+    static get DOCUMENT(): DetectionType & {
+        get name(): "DOCUMENT";
+        get ordinal(): 0;
+    };
+    static get PASSPORT(): DetectionType & {
+        get name(): "PASSPORT";
+        get ordinal(): 1;
+    };
+    static get BIOMETRIC_SELFIE(): DetectionType & {
+        get name(): "BIOMETRIC_SELFIE";
+        get ordinal(): 2;
+    };
+    static get NO_DETECTION(): DetectionType & {
+        get name(): "NO_DETECTION";
+        get ordinal(): 3;
+    };
+    static values(): Array<DetectionType>;
+    static valueOf(value: string): DetectionType;
+    get name(): "DOCUMENT" | "PASSPORT" | "BIOMETRIC_SELFIE" | "NO_DETECTION";
+    get ordinal(): 0 | 1 | 2 | 3;
+}
+export declare interface TruliooImageFeedback {
+    readonly imageId: string;
+    readonly detectionType: DetectionType;
+    readonly hasAcceptableQuality: boolean;
+    readonly hasBlur: boolean;
+    readonly hasDetection: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly TruliooImageFeedback: unique symbol;
+    };
+}
+export declare interface TruliooCaptureResponse extends TruliooImageFeedback {
+    readonly acceptImage: () => Promise<boolean>;
+    readonly requiresBackCapture: boolean;
+    readonly tooClose: boolean;
+    readonly tooFar: boolean;
+    readonly verifyImage: () => Promise<TruliooVerifyFeedback>;
+    readonly imageId: string;
+    readonly detectionType: DetectionType;
+    readonly hasAcceptableQuality: boolean;
+    readonly hasBlur: boolean;
+    readonly hasDetection: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly TruliooCaptureResponse: unique symbol;
+    } & TruliooImageFeedback["__doNotUseOrImplementIt"];
+}
+export declare interface TruliooVerifyFeedback {
+    readonly isVerifyAttemptAvailable: boolean;
+    readonly verificationStatus: VerificationStatus;
+    readonly __doNotUseOrImplementIt: {
+        readonly TruliooVerifyFeedback: unique symbol;
+    };
+}
+export declare abstract class VerificationStatus {
+    private constructor();
+    static get CAN_BE_PROCESSED(): VerificationStatus & {
+        get name(): "CAN_BE_PROCESSED";
+        get ordinal(): 0;
+    };
+    static get CANNOT_BE_CLASSIFIED(): VerificationStatus & {
+        get name(): "CANNOT_BE_CLASSIFIED";
+        get ordinal(): 1;
+    };
+    static get UNSUPPORTED_DOCUMENT(): VerificationStatus & {
+        get name(): "UNSUPPORTED_DOCUMENT";
+        get ordinal(): 2;
+    };
+    static get EXPIRED_DOCUMENT(): VerificationStatus & {
+        get name(): "EXPIRED_DOCUMENT";
+        get ordinal(): 3;
+    };
+    static get ERROR(): VerificationStatus & {
+        get name(): "ERROR";
+        get ordinal(): 4;
+    };
+    static values(): Array<VerificationStatus>;
+    static valueOf(value: string): VerificationStatus;
+    get name(): "CAN_BE_PROCESSED" | "CANNOT_BE_CLASSIFIED" | "UNSUPPORTED_DOCUMENT" | "EXPIRED_DOCUMENT" | "ERROR";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+}
+export declare abstract class TruliooFeedbackState {
+    private constructor();
+    static get NONE(): TruliooFeedbackState & {
+        get name(): "NONE";
+        get ordinal(): 0;
+    };
+    static get CAPTURING(): TruliooFeedbackState & {
+        get name(): "CAPTURING";
+        get ordinal(): 1;
+    };
+    static get BLUR(): TruliooFeedbackState & {
+        get name(): "BLUR";
+        get ordinal(): 2;
+    };
+    static get SUCCESS(): TruliooFeedbackState & {
+        get name(): "SUCCESS";
+        get ordinal(): 3;
+    };
+    static get ERROR(): TruliooFeedbackState & {
+        get name(): "ERROR";
+        get ordinal(): 4;
+    };
+    static get TOO_CLOSE(): TruliooFeedbackState & {
+        get name(): "TOO_CLOSE";
+        get ordinal(): 5;
+    };
+    static get TOO_FAR(): TruliooFeedbackState & {
+        get name(): "TOO_FAR";
+        get ordinal(): 6;
+    };
+    static values(): Array<TruliooFeedbackState>;
+    static valueOf(value: string): TruliooFeedbackState;
+    get name(): "NONE" | "CAPTURING" | "BLUR" | "SUCCESS" | "ERROR" | "TOO_CLOSE" | "TOO_FAR";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}
+export as namespace trulioo_docv_capture_web;