react-native-unit-components 3.5.1 → 3.5.3

package/src/services/veryfiService.ts

@@ -1,5 +1,9 @@
 import { NativeEventEmitter } from 'react-native';
 import type { UNVeryfiCredentials } from '../types/shared/veryfi.types';
+import { labelSidesFromPages } from './veryfiService.utils';
+import type { UNVeryfiImage } from './veryfiService.utils';
+
+export type { UNVeryfiImage } from './veryfiService.utils';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let VeryfiLens: any = null;
@@ -14,16 +18,15 @@ export const isVeryfiAvailable = (): boolean => {
   return VeryfiLens != null;
 };
 
-export interface UNVeryfiImage {
-  base64Img: string;
-  isFront: boolean;
-}
-
 const CHECK_SETTINGS = {
   documentTypes: ['check'],
   checksBackIsOn: true,
+  checksBackIsRequired: true,
   blurDetectionIsOn: true,
   autoDocDetectionAndCropIsOn: true,
+  // Without this, a no-document capture is kept in the package and the user
+  // lands on the submit screen with an image that can only fail.
+  allowSubmitUndetectedDocsIsOn: false,
   dataExtractionEngine: true,
   returnStitchedPDF: true,
   originalImageMaxSizeInMB: 1.4,
@@ -38,6 +41,10 @@ const buildEndorsement = (bankName?: string): string => {
   return `Please make sure to sign the back and write “For mobile deposit ${bank ? `at ${bank}` : 'only'}”`;
 };
 
+// How long to hold delivery waiting for Veryfi's parsed result before falling
+// back to positional labeling.
+const VERDICT_WAIT_MS = 10000;
+
 export const configureAndShowVeryfiCamera = (
   credentials: UNVeryfiCredentials,
   bankName: string | undefined,
@@ -52,15 +59,48 @@ export const configureAndShowVeryfiCamera = (
   const emitter = new NativeEventEmitter(VeryfiLens.NativeModule);
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const subscriptions: any[] = [];
-  let delivered = false;
+  let capturing = false;
+  let dispatched = false;
+  let convertedImages: UNVeryfiImage[] | null = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let verdictPages: any = null;
+  let fallbackTimer: ReturnType<typeof setTimeout> | null = null;
 
   const cleanup = () => {
     subscriptions.forEach((sub) => sub.remove());
+    if (fallbackTimer != null) {
+      clearTimeout(fallbackTimer);
+      fallbackTimer = null;
+    }
+  };
+
+  const dispatchToWeb = (images: UNVeryfiImage[]) => {
+    if (dispatched) return;
+    dispatched = true;
+    cleanup();
+    onImages(images);
+  };
+
+  // Delivery is held briefly so Veryfi's parsed result — the authoritative
+  // source for which image is the front — can label the pair before the web
+  // renders it. The positional fallback covers slow or failed uploads;
+  // position is unreliable across Veryfi versions (the order reversed in
+  // Android lens 2.4.0.0), which is exactly why the verdict is preferred.
+  const dispatchWhenReady = () => {
+    if (dispatched || !convertedImages) return;
+    if (verdictPages) {
+      const labeled = labelSidesFromPages(convertedImages, verdictPages);
+      dispatchToWeb(labeled ?? convertedImages);
+      return;
+    }
+    if (fallbackTimer == null) {
+      fallbackTimer = setTimeout(() => dispatchToWeb(convertedImages as UNVeryfiImage[]), VERDICT_WAIT_MS);
+    }
   };
 
-  const deliverImages = (imagePaths: string[]) => {
-    if (delivered) return;
-    delivered = true;
+  const convertImages = (imagePaths: string[]) => {
+    if (capturing) return;
+    capturing = true;
 
     let converted = 0;
     const images: UNVeryfiImage[] = [];
@@ -72,10 +112,11 @@ export const configureAndShowVeryfiCamera = (
         () => {
           converted++;
           if (converted === imagePaths.length) {
-            cleanup();
             if (images.length > 0) {
-              onImages(images);
+              convertedImages = images;
+              dispatchWhenReady();
             } else {
+              cleanup();
               onError('Failed to convert check images');
             }
           }
@@ -88,8 +129,8 @@ export const configureAndShowVeryfiCamera = (
           });
           converted++;
           if (converted === imagePaths.length) {
-            cleanup();
-            onImages(images);
+            convertedImages = images;
+            dispatchWhenReady();
           }
         }
       );
@@ -103,14 +144,33 @@ export const configureAndShowVeryfiCamera = (
       if (event.status === 'inprogress' && event.msg === 'img_stitched_pdf_path') {
         const paths = event.img_original_paths || [];
         if (paths.length > 0) {
-          deliverImages(paths);
+          convertImages(paths);
         }
       }
     })
   );
 
-  // No onClose listener — if the user cancels, we simply don't dispatch
-  // unitVeryfiResponse, and the web SDK's polling handles the timeout.
+  subscriptions.push(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    emitter.addListener(VeryfiLens.Events.onVeryfiLensSuccess, (event: any) => {
+      verdictPages = event?.data?.meta?.pages ?? null;
+      dispatchWhenReady();
+    })
+  );
+
+  // User cancelled (X button) without submitting: the web side never resets its
+  // loading state on its own, so deliver an empty response to move it off the
+  // stuck Continue. Grace period covers a close event racing the stitched event.
+  subscriptions.push(
+    emitter.addListener(VeryfiLens.Events.onVeryfiLensClose, () => {
+      setTimeout(() => {
+        if (capturing || dispatched) return;
+        dispatched = true;
+        cleanup();
+        onImages([]);
+      }, 1500);
+    })
+  );
 
   subscriptions.push(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/services/veryfiService.utils.ts

@@ -0,0 +1,87 @@
+export interface UNVeryfiImage {
+  base64Img: string;
+  isFront: boolean;
+}
+
+const JPEG_SOF_MARKERS = [0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf];
+
+export const readJpegDimensions = (base64: string): { width: number; height: number } | null => {
+  try {
+    // SOF sits near the file start; a 4-aligned prefix keeps atob happy and cheap.
+    const prefix = base64.length > 786432 ? base64.slice(0, 786432) : base64;
+    const bytes = atob(prefix);
+    if (bytes.charCodeAt(0) !== 0xff || bytes.charCodeAt(1) !== 0xd8) return null;
+    let i = 2;
+    while (i + 9 < bytes.length) {
+      if (bytes.charCodeAt(i) !== 0xff) {
+        i++;
+        continue;
+      }
+      const marker = bytes.charCodeAt(i + 1);
+      if (marker === 0xff) {
+        i++;
+        continue;
+      }
+      if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd9)) {
+        i += 2;
+        continue;
+      }
+      if (JPEG_SOF_MARKERS.includes(marker)) {
+        return {
+          height: bytes.charCodeAt(i + 5) * 256 + bytes.charCodeAt(i + 6),
+          width: bytes.charCodeAt(i + 7) * 256 + bytes.charCodeAt(i + 8),
+        };
+      }
+      i += 2 + bytes.charCodeAt(i + 2) * 256 + bytes.charCodeAt(i + 3);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+// Veryfi's parsed result is the authority on which image is the front
+// (their meta.pages[].is_front); page order does not correspond to the
+// delivery array's order, so pages are matched to our images by exact
+// pixel dimensions. Returns null whenever the verdict is not unambiguous.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const labelSidesFromPages = (images: UNVeryfiImage[], pages: any): UNVeryfiImage[] | null => {
+  if (!Array.isArray(pages) || pages.length !== 2 || images.length !== 2) return null;
+
+  const fronts = pages.filter((p) => p && p.is_front === true);
+  const backs = pages.filter((p) => p && p.is_front === false);
+  const frontPage = fronts[0];
+  const backPage = backs[0];
+  if (fronts.length !== 1 || backs.length !== 1 || !frontPage || !backPage) return null;
+  if (typeof frontPage.width !== 'number' || typeof frontPage.height !== 'number') return null;
+
+  const dims: { width: number; height: number }[] = [];
+  for (const img of images) {
+    const d = readJpegDimensions(img.base64Img);
+    if (!d) return null;
+    dims.push(d);
+  }
+
+  // Veryfi may auto-rotate pages in the parsed result, so dimensions are
+  // compared as an unordered pair.
+  const sameDims = (d: { width: number; height: number }, w: number, h: number) =>
+    (d.width === w && d.height === h) || (d.width === h && d.height === w);
+
+  const matchesFront = dims.map((d) => sameDims(d, frontPage.width, frontPage.height));
+  if (matchesFront.filter(Boolean).length !== 1) return null;
+
+  const frontIdx = matchesFront.indexOf(true);
+  const backIdx = 1 - frontIdx;
+  const frontImage = images[frontIdx];
+  const backImage = images[backIdx];
+  const backDims = dims[backIdx];
+  if (!frontImage || !backImage || !backDims) return null;
+  if (typeof backPage.width === 'number' && typeof backPage.height === 'number') {
+    if (!sameDims(backDims, backPage.width, backPage.height)) return null;
+  }
+
+  return [
+    { base64Img: frontImage.base64Img, isFront: true },
+    { base64Img: backImage.base64Img, isFront: false },
+  ];
+};

package/src/types/shared/error.types.ts

@@ -2,6 +2,11 @@ export type UNComponentsError = {
   errors: UNComponentsErrorData[]
 }
 
+export type UNComponentsFlowError = {
+  title?: string,
+  message: string
+}
+
 export type UNComponentsErrorData = {
   status?: string,
   title: string,

package/src/unitComponentsSdkManager/UnitComponentsSdkManager.ts

@@ -27,7 +27,7 @@ export class UnitComponentsSDK {
   protected static fonts?: UNFonts;
   protected static signedNonce?: string;
   protected static pushProvisionModule?: typeof NativeModules;
-  protected static sdkVersion = '3.5.1';
+  protected static sdkVersion = '3.5.3';
   static iosFontBase64Map: Record<string, string> = {};
 
   public static init = async (
@@ -39,23 +39,23 @@ export class UnitComponentsSDK {
     securitySettings: UNComponentsSecuritySettings = UNComponentsSDKConstants.securitySettings
   ) => {
     try {
-      this.webVersioningStrategy = webVersioningStrategy;
-      this.ui = new UnitComponentsUiManager();
-      this.helpers = new UnitComponentsHelpersManager();
+      UnitComponentsSDK.webVersioningStrategy = webVersioningStrategy;
+      UnitComponentsSDK.ui = new UnitComponentsUiManager();
+      UnitComponentsSDK.helpers = new UnitComponentsHelpersManager();
 
       const isJailbroke = await UNSecurityManagerHelper.isDeviceJailbroke();
       if (isJailbroke) {
         throw Error('Device is jailbroke');
       }
-      this.env = env;
-      this.securitySettings = securitySettings;
-      this.fonts = fonts;
+      UnitComponentsSDK.env = env;
+      UnitComponentsSDK.securitySettings = securitySettings;
+      UnitComponentsSDK.fonts = fonts;
       if (Platform.OS === 'ios' && fonts) {
-        this.iosFontBase64Map = await loadIosFontBase64(fonts);
+        UnitComponentsSDK.iosFontBase64Map = await loadIosFontBase64(fonts);
       }
       store.dispatch(setTheme(theme));
       store.dispatch(setLanguage(language));
-      warnClientIfNeeded(this.webVersioningStrategy);
+      warnClientIfNeeded(UnitComponentsSDK.webVersioningStrategy);
       const shouldProtectFromSnapshot = securitySettings.snapshotProtectionStrategy != UNComponentsSnapshotProtectionStrategy.None;
       if (Platform.OS === 'ios') {
         UNSnapshotProtectionHelper.setIosSecurity(shouldProtectFromSnapshot, 'light');
@@ -67,45 +67,45 @@ export class UnitComponentsSDK {
   };
 
   public static isInitialized = () => {
-    return this.env != undefined;
+    return UnitComponentsSDK.env != undefined;
   };
 
   public static setPushProvisioningModule = (pushProvisionModule?: typeof NativeModules) => {
-    this.pushProvisionModule = pushProvisionModule;
+    UnitComponentsSDK.pushProvisionModule = pushProvisionModule;
   };
 
   public static getPushProvisionModule = () => {
-    return this.pushProvisionModule;
+    return UnitComponentsSDK.pushProvisionModule;
   };
 
   public static getSecuritySettings = () => {
-    return this.securitySettings;
+    return UnitComponentsSDK.securitySettings;
   };
 
   /**
    * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
    */
   public static setSignedNonce = (signedNonce: string) => {
-    this.signedNonce = signedNonce;
+    UnitComponentsSDK.signedNonce = signedNonce;
   };
 
   public static getEnv = () => {
-    return this.env;
+    return UnitComponentsSDK.env;
   };
 
   public static getWebVersioningStrategy = () => {
-    return this.webVersioningStrategy;
+    return UnitComponentsSDK.webVersioningStrategy;
   };
 
   public static getFonts = () => {
-    return this.fonts;
+    return UnitComponentsSDK.fonts;
   };
 
   /**
    * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
    */
   public static getSignedNonce = () => {
-    return this.signedNonce;
+    return UnitComponentsSDK.signedNonce;
   };
 
   public static setCustomerToken = (customerToken: string) => {
@@ -113,7 +113,7 @@ export class UnitComponentsSDK {
   };
 
   public static getSdkVersion = () => {
-    return this.sdkVersion;
+    return UnitComponentsSDK.sdkVersion;
   };
 
   public static setVeryfiCredentials = (credentials: UNVeryfiCredentials) => {