@trustchex/react-native-sdk 1.374.0 → 1.409.0

package/lib/module/Shared/Components/IdentityDocumentCamera.types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/Shared/Components/IdentityDocumentCamera.utils.js

@@ -0,0 +1,273 @@
+"use strict";
+
+import { Dimensions } from 'react-native';
+import { SIGNATURE_REGEX, PASSPORT_MRZ_PATTERN } from "./IdentityDocumentCamera.constants.js";
+import { debugLog, isDebugEnabled } from "../Libs/debug.utils.js";
+
+/**
+ * Frame-to-screen coordinate transform using FILL_CENTER scaling
+ */
+export function getFrameToScreenTransform(frameWidth, frameHeight) {
+  const screen = Dimensions.get('window');
+  const frameAspect = frameWidth / frameHeight;
+  const screenAspect = screen.width / screen.height;
+  let scale;
+  let offsetX = 0;
+  let offsetY = 0;
+  if (frameAspect > screenAspect) {
+    scale = screen.height / frameHeight;
+    offsetX = (frameWidth * scale - screen.width) / 2;
+  } else {
+    scale = screen.width / frameWidth;
+    offsetY = (frameHeight * scale - screen.height) / 2;
+  }
+  return {
+    scale,
+    offsetX,
+    offsetY,
+    screen
+  };
+}
+
+/**
+ * Compute scan area bounds in frame coordinates
+ */
+export function getScanAreaBounds(frameWidth, frameHeight) {
+  const {
+    scale,
+    offsetX,
+    offsetY,
+    screen
+  } = getFrameToScreenTransform(frameWidth, frameHeight);
+  const scanLeft = (screen.width * 0.05 + offsetX) / scale;
+  const scanTop = (screen.height * 0.36 + offsetY) / scale;
+  const scanRight = (screen.width * 0.95 + offsetX) / scale;
+  const scanBottom = (screen.height * 0.64 + offsetY) / scale;
+  const isInsideScan = (x, y, w, h) => x >= scanLeft && y >= scanTop && x + w <= scanRight && y + h <= scanBottom;
+  return {
+    scanLeft,
+    scanTop,
+    scanRight,
+    scanBottom,
+    isInsideScan
+  };
+}
+
+/**
+ * Transform frame-space bounds to screen-space bounds
+ */
+export function transformBoundsToScreen(bounds, scale, offsetX, offsetY) {
+  return {
+    x: bounds.x * scale - offsetX,
+    y: bounds.y * scale - offsetY,
+    width: bounds.width * scale,
+    height: bounds.height * scale
+  };
+}
+
+/**
+ * Unified status message logic used by both voice guidance and render text.
+ * Returns the appropriate i18n key arguments for the current scan state.
+ */
+export function getStatusMessage(nextStep, status, detectedDocumentType, isBrightnessLow, isFrameBlurry, allElementsDetected, elementsOutsideScanArea, t) {
+  if (nextStep === 'COMPLETED') {
+    return t('identityDocumentCamera.scanCompleted');
+  }
+  if (status === 'INCORRECT') {
+    if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+      return t('identityDocumentCamera.alignIDFront');
+    }
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.alignIDBack');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignIDFront');
+    }
+    return t('identityDocumentCamera.alignPhotoSide');
+  }
+  if (isBrightnessLow) {
+    return t('identityDocumentCamera.lowBrightness');
+  }
+  if (isFrameBlurry) {
+    return t('identityDocumentCamera.avoidBlur');
+  }
+  if (status === 'SCANNING' && allElementsDetected && elementsOutsideScanArea.length === 0) {
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.idCardBackDetected');
+    }
+    if (detectedDocumentType === 'PASSPORT') {
+      return t('identityDocumentCamera.passportDetected');
+    }
+    if (detectedDocumentType === 'ID_FRONT') {
+      return t('identityDocumentCamera.idCardFrontDetected');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignHologram');
+    }
+    return t('identityDocumentCamera.readingDocument');
+  }
+  if (elementsOutsideScanArea.length > 0) {
+    return t('identityDocumentCamera.centerDocument');
+  }
+  if ((status === 'SCANNING' || status === 'SEARCHING') && !allElementsDetected) {
+    if (nextStep === 'SCAN_ID_BACK') {
+      return t('identityDocumentCamera.alignIDBack');
+    }
+    if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+      if (detectedDocumentType === 'PASSPORT') {
+        return t('identityDocumentCamera.alignPassport');
+      }
+      if (detectedDocumentType === 'ID_FRONT') {
+        return t('identityDocumentCamera.alignIDFront');
+      }
+      return t('identityDocumentCamera.alignPhotoSide');
+    }
+    if (nextStep === 'SCAN_HOLOGRAM') {
+      return t('identityDocumentCamera.alignHologram');
+    }
+    return t('identityDocumentCamera.readingDocument');
+  }
+
+  // Default fallback
+  if (nextStep === 'SCAN_ID_FRONT_OR_PASSPORT') {
+    return status === 'SCANNING' ? t('identityDocumentCamera.readingDocument') : t('identityDocumentCamera.alignPhotoSide');
+  }
+  if (nextStep === 'SCAN_HOLOGRAM') {
+    return t('identityDocumentCamera.alignHologram');
+  }
+  if (nextStep === 'SCAN_ID_BACK') {
+    return status === 'SCANNING' ? t('identityDocumentCamera.readingDocument') : t('identityDocumentCamera.alignIDBackSide');
+  }
+  return '';
+}
+
+/**
+ * Calculate angle from two points in degrees
+ */
+export function angleBetweenPoints(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.atan2(dy, dx) * (180 / Math.PI);
+}
+
+/**
+ * Calculate distance between two points
+ */
+export function distanceBetweenPoints(p1, p2) {
+  const dx = p2.x - p1.x;
+  const dy = p2.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ * Detect document type based on faces, OCR text, and MRZ fields
+ */
+export function detectDocumentType(faces, ocrText, mrzFields, frameWidth, mrzText) {
+  // Relaxed signature detection: matches signature/imza variants and OCR errors
+  const hasSignatureMatch = SIGNATURE_REGEX.test(ocrText);
+  if (isDebugEnabled()) {
+    debugLog('IdentityDocumentCamera.utils', '[DocType] Detection', {
+      faces: faces.length,
+      hasMRZ: !!mrzFields,
+      hasMRZText: !!mrzText,
+      textLength: ocrText?.length,
+      hasSignature: hasSignatureMatch
+    });
+  }
+
+  // ID Back: no face + ID MRZ
+  if (faces.length === 0 && mrzFields?.documentCode === 'I') {
+    return 'ID_BACK';
+  }
+
+  // Passport: face + passport MRZ
+  if (faces.length > 0 && mrzFields?.documentCode === 'P') {
+    return 'PASSPORT';
+  }
+
+  // Check for PASSPORT MRZ pattern BEFORE classifying as ID_FRONT
+  // Both passports and ID cards have face + signature, so we MUST check MRZ first
+  // Check BOTH parsed mrzText AND raw ocrText — MRZ parsing can fail while
+  // the raw OCR still contains P<TUR/P<USA pattern
+  const hasPassportMRZPattern = mrzText && mrzText.length > 20 && PASSPORT_MRZ_PATTERN.test(mrzText) || PASSPORT_MRZ_PATTERN.test(ocrText);
+  if (hasPassportMRZPattern) {
+    // Passport MRZ pattern detected (P<TUR, P<USA, etc.)
+    // Even if not fully parsed, this is definitely a passport, not ID card
+    return 'PASSPORT';
+  }
+
+  // ID Front: face detected
+  // CRITICAL: Only classify as ID_FRONT when we're confident it's NOT a passport
+  // This means we must have either:
+  // 1. MRZ code 'I' (definitive ID card), OR
+  // 2. Face + signature but NO passport MRZ pattern visible
+  if (faces.length > 0 && ocrText?.length >= 5) {
+    // Filter to card-sized faces only (min 5% of frame width to exclude tiny background faces)
+    const cardSizedFaces = frameWidth ? faces.filter(face => face.bounds.width >= frameWidth * 0.05 && face.bounds.height >= frameWidth * 0.05) : faces;
+    if (cardSizedFaces.length > 0) {
+      // If we have MRZ code 'I', it's definitely an ID card
+      if (mrzFields?.documentCode === 'I') {
+        return 'ID_FRONT';
+      }
+
+      // If signature present and NO passport MRZ pattern, likely ID_FRONT
+      // But we can't be 100% sure yet - passport MRZ might appear in next frames
+      const hasSignature = hasSignatureMatch;
+      if (hasSignature && !hasPassportMRZPattern) {
+        return 'ID_FRONT';
+      }
+    }
+  }
+  return 'UNKNOWN';
+}
+
+/**
+ * Determine the document type to set based on current frame analysis
+ * Handles correction of misdetections and passport pattern checking
+ */
+export function determineDocumentTypeToSet(documentType, cardSizedFaces, parsedMRZFields, mrzText) {
+  // CRITICAL: Passport MRZ always takes precedence over other detections
+  const hasPassportMRZ = mrzText && mrzText.length > 20 && PASSPORT_MRZ_PATTERN.test(mrzText) || parsedMRZFields?.documentCode === 'P';
+  if (hasPassportMRZ) {
+    return 'PASSPORT';
+  }
+
+  // After passport MRZ check, accept the detected type directly
+  if (documentType === 'PASSPORT') return 'PASSPORT';
+  if (documentType === 'ID_FRONT') return 'ID_FRONT';
+  return 'UNKNOWN';
+}
+
+/**
+ * Compare MRZ field values (ignore raw text variations)
+ */
+export function areMRZFieldsEqual(fields1, fields2) {
+  if (!fields1 || !fields2) return false;
+  // Compare critical fields that define document identity
+  return fields1.documentNumber === fields2.documentNumber && fields1.birthDate === fields2.birthDate && fields1.expirationDate === fields2.expirationDate && fields1.firstName === fields2.firstName && fields1.lastName === fields2.lastName && fields1.issuingState === fields2.issuingState;
+}
+
+/**
+ * Check if all required MRZ fields are present
+ */
+export function hasRequiredMRZFields(fields) {
+  return !!fields?.firstName && !!fields?.lastName && !!fields?.documentNumber && !!fields?.birthDate;
+}
+
+/**
+ * Validate if face position has changed within acceptable tolerance
+ * Returns true if position is valid (within tolerance)
+ */
+export function validateFacePosition(currentBounds, referenceBounds, isHologramStep) {
+  const xDiff = Math.abs(currentBounds.x - referenceBounds.x);
+  const yDiff = Math.abs(currentBounds.y - referenceBounds.y);
+  const widthDiff = Math.abs(currentBounds.width - referenceBounds.width);
+  const heightDiff = Math.abs(currentBounds.height - referenceBounds.height);
+
+  // Use looser tolerance during hologram step since flash toggling causes position jitter
+  const tolerance = isHologramStep ? 0.5 : 0.2;
+  const xTolerance = referenceBounds.width * tolerance;
+  const yTolerance = referenceBounds.height * tolerance;
+  const sizeTolerance = referenceBounds.width * tolerance;
+  return xDiff <= xTolerance && yDiff <= yTolerance && widthDiff <= sizeTolerance && heightDiff <= sizeTolerance;
+}

package/lib/module/Shared/Components/NavigationManager.js

@@ -29,7 +29,8 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
       CONTRACT_ACCEPTANCE: 'ContractAcceptanceScreen',
       IDENTITY_DOCUMENT_SCAN: 'IdentityDocumentScanningScreen',
       IDENTITY_DOCUMENT_EID_SCAN: 'IdentityDocumentEIDScanningScreen',
-      LIVENESS_CHECK: 'LivenessDetectionScreen'
+      LIVENESS_CHECK: 'LivenessDetectionScreen',
+      VIDEO_CALL: 'VideoCallScreen'
     },
     RESULT: 'ResultScreen'
   };
@@ -69,6 +70,9 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
     if (nextStep.type === 'LIVENESS_CHECK') {
       return routes.DYNAMIC_ROUTES.LIVENESS_CHECK;
     }
+    if (nextStep.type === 'VIDEO_CALL') {
+      return routes.DYNAMIC_ROUTES.VIDEO_CALL;
+    }
     return routes.VERIFICATION_SESSION_CHECK;
   }, [appContext, routes.VERIFICATION_SESSION_CHECK, routes.DYNAMIC_ROUTES.CONTRACT_ACCEPTANCE, routes.DYNAMIC_ROUTES.IDENTITY_DOCUMENT_EID_SCAN, routes.DYNAMIC_ROUTES.IDENTITY_DOCUMENT_SCAN, routes.DYNAMIC_ROUTES.LIVENESS_CHECK, routes.RESULT]);
   const goToNextRoute = useCallback(() => {
@@ -124,8 +128,15 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
           contractIds: [],
           deviceInfo: ''
         },
-        locale: appContext.locale || i18n.language
+        locale: appContext.locale || i18n.language,
+        // Explicitly reset collected data fields
+        scannedDocument: undefined,
+        livenessDetection: undefined,
+        authToken: undefined,
+        videoSessionId: undefined
       };
+
+      // Reset branding to defaults while preserving any custom values
       appContext.branding = {
         logoUrl: appContext.branding?.logoUrl || '',
         primaryColor: appContext.branding?.primaryColor || '#000000',
@@ -138,6 +149,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
         appContext.setIsDemoSession?.(false);
         analyticsService.setDemoSession(false);
       }
+      appContext.isTestVideoSession = false;
       navigation.dispatch(CommonActions.reset({
         index: 0,
         routes: [{
@@ -155,7 +167,7 @@ const NavigationManager = /*#__PURE__*/forwardRef(({
   usePreventRemove(true, ({
     data
   }) => {
-    if (data.action.type === 'RESET') {
+    if (data?.action?.type === 'RESET') {
       navigation.dispatch(data.action);
     }
   });

package/lib/module/Shared/Contexts/AppContext.js

@@ -23,6 +23,7 @@ export default /*#__PURE__*/createContext({
   workflowSteps: [],
   currentWorkflowStep: undefined,
   isDebugNavigated: false,
+  isTestVideoSession: false,
   onCompleted: undefined,
   onError: undefined,
   setSessionId: undefined,

package/lib/module/Shared/Libs/SignalingClient.js

@@ -0,0 +1,128 @@
+"use strict";
+
+import EventSource from 'react-native-sse';
+export class SignalingClient {
+  eventSource = null;
+  constructor(baseUrl, sessionId, onMessage, identificationId, onSessionEnded) {
+    this.baseUrl = baseUrl;
+    this.sessionId = sessionId;
+    this.onMessage = onMessage;
+    this.identificationId = identificationId;
+    this.onSessionEnded = onSessionEnded;
+  }
+  connect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+    }
+    const urlParams = new URLSearchParams();
+    if (this.identificationId) {
+      urlParams.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/signaling/stream?${urlParams.toString()}`;
+    console.log('[SignalingClient] Connecting to SSE:', url);
+    this.eventSource = new EventSource(url, {
+      pollingInterval: 0 // 0 means default/no polling if SSE is real
+    });
+    const listener = event => {
+      if (event.type === 'open') {
+        console.log('[SignalingClient] Connected');
+        this.onConnected?.();
+      } else if (event.type === 'error') {
+        console.error('[SignalingClient] Connection error:', JSON.stringify(event, null, 2));
+        this.onDisconnected?.();
+      } else if (event.type === 'message') {
+        try {
+          const data = JSON.parse(event.data || '{}');
+          if (['offer', 'answer', 'ice-candidate', 'command'].includes(data.type)) {
+            this.onMessage({
+              id: data.id,
+              type: data.type,
+              payload: data.payload,
+              createdAt: data.createdAt
+            });
+          }
+        } catch (e) {
+          console.error('[SignalingClient] Error parsing message:', e);
+        }
+      }
+    };
+    const customEventListener = event => {
+      try {
+        const data = JSON.parse(event.data || '{}');
+        const eventType = event.type;
+        if (['offer', 'answer', 'ice-candidate', 'command'].includes(eventType)) {
+          this.onMessage({
+            id: data.id,
+            type: eventType,
+            payload: data.payload,
+            createdAt: data.createdAt
+          });
+        }
+      } catch (e) {
+        console.error('[SignalingClient] Error parsing custom event:', e);
+      }
+    };
+
+    // Ping handler - server sends pings to keep connection alive
+    const pingListener = event => {
+      console.log('[SignalingClient] Received ping');
+      // Just acknowledge by doing nothing, server-side heartbeat keeps connection alive
+    };
+
+    // Session-ended event listener
+    const sessionEndedListener = event => {
+      try {
+        const data = JSON.parse(event.data || '{}');
+        console.log('[SignalingClient] Session ended:', data.state);
+        if (this.onSessionEnded) {
+          this.onSessionEnded(data.state);
+        }
+      } catch (e) {
+        console.error('[SignalingClient] Error parsing session-ended event:', e);
+      }
+    };
+    this.eventSource.addEventListener('open', listener);
+    this.eventSource.addEventListener('message', listener);
+    this.eventSource.addEventListener('error', listener);
+    this.eventSource.addEventListener('ping', pingListener);
+    this.eventSource.addEventListener('offer', customEventListener);
+    this.eventSource.addEventListener('answer', customEventListener);
+    this.eventSource.addEventListener('ice-candidate', customEventListener);
+    this.eventSource.addEventListener('command', customEventListener);
+    this.eventSource.addEventListener('session-ended', sessionEndedListener);
+  }
+  async send(type, payload) {
+    const urlParams = new URLSearchParams();
+    if (this.identificationId) {
+      urlParams.append('identificationId', this.identificationId);
+    }
+    const url = `${this.baseUrl}/api/app/mobile/video-sessions/${this.sessionId}/signaling?${urlParams.toString()}`;
+    try {
+      const body = {
+        type,
+        data: payload
+      };
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to send signaling message: ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error('[SignalingClient] Error sending message:', error);
+      throw error;
+    }
+  }
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.removeAllEventListeners();
+      this.eventSource.close();
+      this.eventSource = null;
+      this.onDisconnected?.();
+    }
+  }
+}

package/lib/module/Shared/Libs/analytics.utils.js

@@ -188,6 +188,10 @@ const STEP_EVENT_MAP = {
   liveness_check: {
     started: AnalyticsEventName.LIVENESS_CHECK_STARTED,
     completed: AnalyticsEventName.LIVENESS_CHECK_COMPLETED
+  },
+  video_call: {
+    started: AnalyticsEventName.VIDEO_CALL_STARTED,
+    completed: AnalyticsEventName.VIDEO_CALL_COMPLETED
   }
 };
 function getStepEventName(stepType, suffix) {

package/lib/module/Shared/Libs/deeplink.utils.js

@@ -12,7 +12,7 @@ const handleDeepLink = ({
   let baseUrl = '';
   let sessionId = '';
   for (let i = 0; i < segments.length; i++) {
-    if (segments[i] === 'verification-session') {
+    if (segments[i] === 'verification-session' || segments[i] === 'verification-sessions') {
       sessionId = segments[i + 1] ?? '';
       debugLog('handleDeepLink', 'Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
@@ -20,6 +20,14 @@ const handleDeepLink = ({
       debugLog('handleDeepLink', 'Found baseUrl:', baseUrl);
     }
   }
+
+  // If no app-url segment found, derive baseUrl from the URL itself
+  if (!baseUrl && sessionId) {
+    const match = url.match(/^(https?:\/\/[^/]+)/);
+    if (match) {
+      baseUrl = match[1];
+    }
+  }
   debugLog('handleDeepLink', 'Returning:', {
     baseUrl,
     sessionId

package/lib/module/Shared/Libs/http-client.js

@@ -47,6 +47,10 @@ const request = async (httpMethod, url, body, simulatedResponse) => {
   const startTime = Date.now();
   let statusCode = 0;
   let success = false;
+  console.log(`[HTTP] ${httpMethod} ${url}`);
+  if (body) {
+    console.log('[HTTP] Request body:', JSON.stringify(body).substring(0, 200) + '...');
+  }
   try {
     const response = await fetch(url, {
       method: httpMethod,
@@ -57,11 +61,16 @@ const request = async (httpMethod, url, body, simulatedResponse) => {
     });
     statusCode = response.status;
     success = response.ok;
+    console.log(`[HTTP] Response status: ${statusCode} ${response.ok ? '✓' : '✗'}`);
     let responseJson = null;
     try {
       responseJson = await response.json();
+      if (responseJson) {
+        console.log('[HTTP] Response body:', JSON.stringify(responseJson).substring(0, 200) + '...');
+      }
     } catch (error) {
       // Invalid JSON response
+      console.log('[HTTP] Response body: (non-JSON)');
     }
 
     // Track API call performance (non-blocking)

package/lib/module/Shared/Libs/promise.utils.js

@@ -2,16 +2,30 @@
 
 const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
   let retries = 0;
+  let lastError;
   let result;
   while (retries < maxRetries) {
     try {
+      if (retries > 0) {
+        console.log(`[Retry] Attempt ${retries + 1}/${maxRetries}...`);
+      }
       result = await fn();
+      if (retries > 0) {
+        console.log(`[Retry] ✓ Success on attempt ${retries + 1}`);
+      }
       return result;
     } catch (error) {
+      lastError = error;
       retries++;
-      await new Promise(resolve => setTimeout(resolve, delay * retries));
+      console.error(`[Retry] ✗ Attempt ${retries}/${maxRetries} failed:`, error instanceof Error ? error.message : error);
+      if (retries < maxRetries) {
+        const waitTime = delay * retries;
+        console.log(`[Retry] Waiting ${waitTime}ms before retry...`);
+        await new Promise(resolve => setTimeout(resolve, waitTime));
+      }
     }
   }
-  throw new Error('Max retries exceeded');
+  console.error('[Retry] ✗ All retries exhausted. Last error:', lastError);
+  throw new Error(`Max retries (${maxRetries}) exceeded. Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
 };
 export { runWithRetry };

package/lib/module/Shared/Libs/status-bar.utils.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { StatusBar } from 'react-native';
+import { useEffect } from 'react';
+
+/**
+ * Configure status bar for white background with dark content for better contrast
+ */
+export const configureStatusBarForWhiteBackground = () => {
+  StatusBar.setBarStyle('dark-content', true);
+  StatusBar.setBackgroundColor('#ffffff', true);
+};
+
+/**
+ * Hook to configure status bar for white background on mount
+ */
+export const useStatusBarWhiteBackground = () => {
+  useEffect(() => {
+    configureStatusBarForWhiteBackground();
+  }, []);
+};