@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/src/Shared/Libs/http-client.ts

@@ -88,8 +88,8 @@ const request = async <TResponse, TBody>(
     // Wrap in try-catch to ensure analytics failures never mask HTTP errors
     try {
       const duration = Date.now() - startTime;
-      trackApiCall(url, duration, statusCode, success).catch(() => { });
-    } catch { }
+      trackApiCall(url, duration, statusCode, success).catch(() => {});
+    } catch {}
 
     if (response && !response.ok && responseJson) {
       const message = (responseJson as unknown as ErrorResponse).message;
@@ -117,7 +117,9 @@ const request = async <TResponse, TBody>(
         }
       };
 
-      const getSeverityFromStatus = (status: number): 'low' | 'medium' | 'high' | 'critical' => {
+      const getSeverityFromStatus = (
+        status: number
+      ): 'low' | 'medium' | 'high' | 'critical' => {
         if (status >= 500) return 'high';
         if (status === 401 || status === 403) return 'medium';
         if (status === 400 || status === 404) return 'low';
@@ -132,8 +134,8 @@ const request = async <TResponse, TBody>(
           message || 'API request failed',
           'http_client',
           getSeverityFromStatus(statusCode)
-        ).catch(() => { });
-      } catch { }
+        ).catch(() => {});
+      } catch {}
 
       if (response.status === 401) {
         throw new UnauthorizedError(message);
@@ -172,9 +174,11 @@ const request = async <TResponse, TBody>(
         const errorMessage =
           error instanceof Error ? error.message : 'Unknown error';
 
-        trackApiCall(url, duration, statusCode, false).catch(() => { });
-        trackError('NETWORK_ERROR', errorMessage, 'http_client', 'high').catch(() => { });
-      } catch { }
+        trackApiCall(url, duration, statusCode, false).catch(() => {});
+        trackError('NETWORK_ERROR', errorMessage, 'http_client', 'high').catch(
+          () => {}
+        );
+      } catch {}
     }
 
     throw error;

package/src/Shared/Libs/mrz.utils.ts

@@ -1,165 +1,6 @@
-import { parse } from 'mrz';
-
-/**
- * Fixes the raw text of an MRZ by removing spaces and « characters, and padding lines to the expected length.
- * @param rawText  The raw text to fix
- * @returns  The fixed text
- */
-const fixMRZ = (rawText: string) => {
-  if (!rawText) {
-    return rawText;
-  }
-
-  const FILLER_CHAR = '<';
-  const MRZ_FORMATS = [
-    { lines: 3, length: 30 }, // TD1
-    { lines: 2, length: 36 }, // TD2
-    { lines: 2, length: 44 }, // TD3
-  ];
-
-  const cleanedText = rawText
-    .replace(/«| /g, '') // Remove « characters and spaces
-    .replace(/<K+|r+K+|<r+K+/g, '') // Remove invalid patterns
-    .replace(/\bI<TUR([A-Z0-9]{3})0([A-Z0-9]{6})\b/g, 'I<TUR$1O$2'); // Fix document number if it contains '0' instead of 'O'
-
-  const lines = cleanedText
-    .split(/\n/)
-    .map((line) => line.trim())
-    .filter((line) => /<+/.test(line));
-
-  let detectedFormat = MRZ_FORMATS.find((format) => {
-    return lines.every((line) => line.length <= format.length);
-  });
-
-  if (!detectedFormat) {
-    return rawText;
-  }
-
-  const fixedLines = lines.map((line) => {
-    if (/<+/.test(line) && line.length < detectedFormat.length) {
-      return line.padEnd(detectedFormat.length, FILLER_CHAR);
-    }
-    return line;
-  });
-
-  return fixedLines.join('\n');
-};
-
-const MRZ_REGEX =
-  /^(?:[A-Z0-9<]{44}\n[A-Z0-9<]{44}|[A-Z0-9<]{30}\n[A-Z0-9<]{30}\n[A-Z0-9<]{30}|[A-Z0-9<]{36}\n[A-Z0-9<]{36})$/im;
-
-const getMRZText = (fixedText: string) => {
-  if (MRZ_REGEX.test(fixedText)) {
-    return fixedText.match(MRZ_REGEX)![0];
-  }
-  return null;
-};
-
-/**
- * Apply common OCR corrections for MRZ text
- * Common confusions: 0/O, 1/I, 8/B, 5/S, 2/Z
- */
-const applyOCRCorrections = (mrzText: string): string[] => {
-  const corrections: string[] = [];
-
-  // Common OCR substitutions to try
-  // In MRZ: letters should be in name fields, numbers in date/checksum fields
-  const substitutions = [
-    // Try replacing O with 0 in numeric positions (dates, checksums)
-    { from: /O/g, to: '0' },
-    // Try replacing 0 with O in alphabetic positions (names, country codes)
-    { from: /0/g, to: 'O' },
-    // I and 1 confusion
-    { from: /I(?=\d)/g, to: '1' }, // I followed by digit -> likely 1
-    { from: /1(?=[A-Z])/g, to: 'I' }, // 1 followed by letter -> likely I
-    // B and 8 confusion
-    { from: /B(?=\d)/g, to: '8' },
-    { from: /8(?=[A-Z])/g, to: 'B' },
-    // S and 5 confusion
-    { from: /S(?=\d)/g, to: '5' },
-    { from: /5(?=[A-Z])/g, to: 'S' },
-    // Z and 2 confusion
-    { from: /Z(?=\d)/g, to: '2' },
-    { from: /2(?=[A-Z])/g, to: 'Z' },
-  ];
-
-  for (const sub of substitutions) {
-    const corrected = mrzText.replace(sub.from, sub.to);
-    if (corrected !== mrzText) {
-      corrections.push(corrected);
-    }
-  }
-
-  return corrections;
-};
-
-const getMRZData = (ocrText: string) => {
-  const fixedText = fixMRZ(ocrText);
-  const mrzText = getMRZText(fixedText);
-
-  if (mrzText) {
-    // First attempt with original text
-    let parsedResult = parse(mrzText, { autocorrect: true });
-
-    // Check if parse is valid with all required fields
-    const isValidParse = (result: typeof parsedResult) => {
-      return result.valid &&
-        result.fields.firstName &&
-        result.fields.lastName &&
-        result.fields.birthDate &&
-        result.fields.expirationDate &&
-        result.fields.documentNumber &&
-        result.fields.issuingState;
-    };
-
-    if (isValidParse(parsedResult)) {
-      return {
-        mrzText,
-        parsedResult,
-      };
-    }
-
-    // If not valid, try OCR corrections
-    const corrections = applyOCRCorrections(mrzText);
-    for (const correctedMRZ of corrections) {
-      try {
-        const correctedResult = parse(correctedMRZ, { autocorrect: true });
-        if (isValidParse(correctedResult)) {
-          return {
-            mrzText: correctedMRZ,
-            parsedResult: correctedResult,
-          };
-        }
-      } catch (e) {
-        // Continue trying other corrections
-      }
-    }
-
-    // Return original result even if not fully valid (for partial matches)
-    if (
-      parsedResult.fields.firstName &&
-      parsedResult.fields.lastName &&
-      parsedResult.fields.birthDate &&
-      parsedResult.fields.expirationDate &&
-      parsedResult.fields.documentNumber &&
-      parsedResult.fields.issuingState
-    ) {
-      return {
-        mrzText,
-        parsedResult,
-      };
-    }
-  }
-
-  return {
-    mrzText: null,
-    parsedResult: null,
-  };
-};
-
 /**
  * Converts an MRZ date string to an ISO date string.
- * @param mrzDate  The MRZ date string to convert
+ * @param mrzDate  The MRZ date string to convert (YYMMDD format)
  * @returns  The ISO date string, or null if the input is invalid
  */
 const convertMRZDateToISODate = (mrzDate?: string | null) => {
@@ -167,12 +8,10 @@ const convertMRZDateToISODate = (mrzDate?: string | null) => {
     return null;
   }
 
-  // Extract year, month, and day from the MRZ date string
   let year = parseInt(mrzDate.slice(0, 2), 10);
   let month = parseInt(mrzDate.slice(2, 4), 10) - 1;
   let day = parseInt(mrzDate.slice(4, 6), 10);
 
-  // Handle century assumption (usually 1900 or 2000)
   year += year < 50 ? 2000 : 1900;
 
   const date = new Date(Date.UTC(year, month, day));
@@ -181,6 +20,5 @@ const convertMRZDateToISODate = (mrzDate?: string | null) => {
 };
 
 export default {
-  getMRZData,
   convertMRZDateToISODate,
 };

package/src/Shared/Libs/native-device-info.utils.ts

@@ -3,13 +3,19 @@ import DeviceInfo from 'react-native-device-info';
 
 export const NativeDeviceInfo = {
   generateHumanReadableIdentifier: async (): Promise<string> => {
-    const brand = DeviceInfo.getBrand();
-    const model = DeviceInfo.getModel();
-    const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
-    const systemVersion = DeviceInfo.getSystemVersion();
-    const uniqueId = await DeviceInfo.getUniqueId();
+    try {
+      const brand = await DeviceInfo.getBrand();
+      const model = await DeviceInfo.getModel();
+      const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
+      const systemVersion = await DeviceInfo.getSystemVersion();
+      const uniqueId = await DeviceInfo.getUniqueId();
 
-    return `${brand} ${model} (${systemName} ${systemVersion}) - ${uniqueId}`;
+      return `${brand} ${model} (${systemName} ${systemVersion}) - ${uniqueId}`;
+    } catch (error) {
+      console.warn('[DeviceInfo] Failed to get device info:', error);
+      const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
+      return `Unknown Device (${systemName}) - ${Date.now()}`;
+    }
   },
 };
 

package/src/Shared/Libs/tts.utils.ts

@@ -2,28 +2,64 @@ import i18n from '../../Translation';
 import Tts from 'react-native-tts';
 import debounce from './debounce.utils';
 
+let isSpeaking = false;
+let lastSpokenMessage = '';
+let lastSpeakTime = 0;
+const MIN_SPEAK_INTERVAL = 3000; // Minimum 3 seconds between messages
+
 Tts.addEventListener('tts-start', (_event) => {
-  // console.log('TTS started', event);
+  isSpeaking = true;
 });
 
 Tts.addEventListener('tts-finish', (_event) => {
-  // console.log('TTS finished', event);
+  isSpeaking = false;
 });
 
 Tts.addEventListener('tts-cancel', (_event) => {
-  // console.log('TTS cancelled', event);
+  isSpeaking = false;
 });
 
-const speak = async (text: string) => {
+const speak = async (text: string, bypassInterval: boolean = false) => {
+  const now = Date.now();
+
+  // Prevent duplicate message
+  if (text === lastSpokenMessage) {
+    return;
+  }
+
+  // Enforce minimum interval between different messages (unless bypassed)
+  if (!bypassInterval && now - lastSpeakTime < MIN_SPEAK_INTERVAL) {
+    return;
+  }
+
+  // When bypassing interval (e.g., liveness instructions), interrupt current speech
+  // to ensure new instruction is spoken immediately
+  if (bypassInterval && isSpeaking) {
+    await Tts.stop();
+    isSpeaking = false;
+  }
+
+  // Wait for any ongoing speech to finish (unless we just interrupted it)
+  if (isSpeaking) {
+    return;
+  }
+
   await Tts.setDefaultLanguage(i18n.language);
   await Tts.stop();
   Tts.speak(text);
+  lastSpokenMessage = text;
+  lastSpeakTime = now;
 };
 
-const speakWithDebounce = debounce(speak, 500);
+const speakWithDebounce = debounce(speak, 1500);
 
 const stopSpeaking = async () => {
   await Tts.stop();
+  isSpeaking = false;
+};
+
+const resetLastMessage = () => {
+  lastSpokenMessage = '';
 };
 
 const initializeTTS = () => {
@@ -37,4 +73,10 @@ const initializeTTS = () => {
   );
 };
 
-export { speak, speakWithDebounce, stopSpeaking, initializeTTS };
+export {
+  speak,
+  speakWithDebounce,
+  stopSpeaking,
+  resetLastMessage,
+  initializeTTS,
+};

package/src/Shared/Services/AnalyticsService.ts

@@ -13,6 +13,7 @@ import {
   AnalyticsEventCategory,
   AnalyticsEventName,
 } from '../Types/analytics.types';
+import { debugLog, debugWarn } from '../Libs/debug.utils';
 import type {
   AnalyticsConfig,
   AnalyticsEvent,
@@ -63,7 +64,9 @@ class AnalyticsService implements IAnalyticsService {
 
     // Validate required verificationSessionId
     if (!config.verificationSessionId) {
-      throw new Error('Analytics initialization failed: verificationSessionId is required (must be verification session ID from backend)');
+      throw new Error(
+        'Analytics initialization failed: verificationSessionId is required (must be verification session ID from backend)'
+      );
     }
 
     // Merge with defaults
@@ -114,13 +117,18 @@ class AnalyticsService implements IAnalyticsService {
         if (Array.isArray(persistedQueue) && persistedQueue.length > 0) {
           // Merge with existing queue, prioritizing persisted events
           this.queue = [...persistedQueue, ...this.queue];
-          if (__DEV__) console.log(`[Analytics] Loaded ${persistedQueue.length} events from disk`);
+          if (__DEV__)
+            debugLog(
+              'AnalyticsService',
+              `[Analytics] Loaded ${persistedQueue.length} events from disk`
+            );
         }
         // Clear the file after loading to prevent duplicate loads
         await RNFS.unlink(this.QUEUE_FILE_PATH);
       }
     } catch (error) {
-      if (__DEV__) console.warn('[Analytics] Failed to load persisted queue:', error);
+      if (__DEV__)
+        debugWarn('[Analytics] Failed to load persisted queue:', error);
     }
   }
 
@@ -135,9 +143,13 @@ class AnalyticsService implements IAnalyticsService {
         }
         return;
       }
-      await RNFS.writeFile(this.QUEUE_FILE_PATH, JSON.stringify(this.queue), 'utf8');
+      await RNFS.writeFile(
+        this.QUEUE_FILE_PATH,
+        JSON.stringify(this.queue),
+        'utf8'
+      );
     } catch (error) {
-      if (__DEV__) console.warn('[Analytics] Failed to persist queue:', error);
+      if (__DEV__) debugWarn('[Analytics] Failed to persist queue:', error);
     }
   }
 
@@ -192,7 +204,11 @@ class AnalyticsService implements IAnalyticsService {
     if (this.queue.length > this.MAX_QUEUE_SIZE) {
       const dropped = this.queue.length - this.MAX_QUEUE_SIZE;
       this.queue = this.queue.slice(dropped);
-      if (__DEV__) console.warn(`[Analytics] Queue overflow, dropped ${dropped} oldest events`);
+      if (__DEV__)
+        debugWarn(
+          'AnalyticsService',
+          `[Analytics] Queue overflow, dropped ${dropped} oldest events`
+        );
     }
 
     // Flush immediately for critical events or if batch size reached
@@ -237,7 +253,7 @@ class AnalyticsService implements IAnalyticsService {
     // Take a batch, but don't remove from queue yet until success
     const batchSize = Math.min(this.queue.length, this.BATCH_SIZE);
     const batch = this.queue.slice(0, batchSize);
-    
+
     // Double-check batch has items (defensive programming)
     if (batch.length === 0) {
       this.isFlushing = false;
@@ -246,16 +262,21 @@ class AnalyticsService implements IAnalyticsService {
 
     try {
       await this.sendBatchWithRetry(batch);
-      
+
       // Remove sent events
       this.queue = this.queue.slice(batchSize);
-      
+
       // Update persistence
       await this.persistQueue();
     } catch (error) {
       // On failure, we keep events in the queue
-      if (__DEV__) console.warn('[Analytics] Failed to flush batch, keeping events:', error);
-      
+      if (__DEV__)
+        debugWarn(
+          'AnalyticsService',
+          '[Analytics] Failed to flush batch, keeping events:',
+          error
+        );
+
       // Ensure they are persisted
       await this.persistQueue();
     } finally {
@@ -266,7 +287,11 @@ class AnalyticsService implements IAnalyticsService {
   /**
    * Send batch with retry logic (exponential backoff: 1s, 2s, 4s)
    */
-  private async sendBatchWithRetry(events: AnalyticsEvent[], maxRetries = 3, attempt = 1): Promise<void> {
+  private async sendBatchWithRetry(
+    events: AnalyticsEvent[],
+    maxRetries = 3,
+    attempt = 1
+  ): Promise<void> {
     if (!this.config || events.length === 0) return;
 
     try {
@@ -285,28 +310,37 @@ class AnalyticsService implements IAnalyticsService {
         if (attempt <= maxRetries && response.status >= 500) {
           // Retry on server errors with exponential backoff
           const delay = Math.pow(2, attempt - 1) * 1000; // 1s, 2s, 4s
-          await new Promise(resolve => setTimeout(resolve, delay));
+          await new Promise((resolve) => setTimeout(resolve, delay));
           return this.sendBatchWithRetry(events, maxRetries, attempt + 1);
         }
         // For 429 (Too Many Requests), throw to retry
         if (response.status === 429) {
           throw new Error('Rate limit exceeded');
         }
-        
+
         // For other 4xx errors (Bad Request, Unauthorized, etc.), do NOT retry.
         // We return successfully so the bad events are removed from the queue.
         if (response.status >= 400 && response.status < 500) {
-          if (__DEV__) console.warn(`[Analytics] Dropping batch due to ${response.status} error`);
+          if (__DEV__)
+            debugWarn(
+              'AnalyticsService',
+              `[Analytics] Dropping batch due to ${response.status} error`
+            );
           return;
         }
-        
-        if (__DEV__) console.warn('[Analytics] Failed to send batch:', response.status);
+
+        if (__DEV__)
+          debugWarn(
+            'AnalyticsService',
+            '[Analytics] Failed to send batch:',
+            response.status
+          );
       }
     } catch (error) {
       if (attempt <= maxRetries) {
         // Retry on network errors with exponential backoff
         const delay = Math.pow(2, attempt - 1) * 1000;
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await new Promise((resolve) => setTimeout(resolve, delay));
         return this.sendBatchWithRetry(events, maxRetries, attempt + 1);
       }
       throw error;
@@ -319,15 +353,15 @@ class AnalyticsService implements IAnalyticsService {
   async clear(): Promise<void> {
     // Flush any pending events before clearing
     await this.flush();
-    
+
     this.stopFlushTimer();
-    
+
     // Remove AppState listener
     if (this.appStateSubscription) {
       this.appStateSubscription.remove();
       this.appStateSubscription = null;
     }
-    
+
     this.queue = [];
     this.sessionId = null;
     this.deviceInfo = null;
@@ -358,7 +392,12 @@ class AnalyticsService implements IAnalyticsService {
         screenResolution: `${DeviceInfo.getDeviceType()}`,
       };
     } catch (error) {
-      if (__DEV__) console.warn('[Analytics] Error collecting device info:', error);
+      if (__DEV__)
+        debugWarn(
+          'AnalyticsService',
+          '[Analytics] Error collecting device info:',
+          error
+        );
       // Fallback device info
       this.deviceInfo = {
         platform: 'android',
@@ -423,13 +462,19 @@ class AnalyticsService implements IAnalyticsService {
         if (lowerKey === forbidden) return true;
 
         // Check if forbidden word appears at start followed by non-letter
-        if (lowerKey.startsWith(forbidden) && lowerKey.length > forbidden.length) {
+        if (
+          lowerKey.startsWith(forbidden) &&
+          lowerKey.length > forbidden.length
+        ) {
           const nextChar = lowerKey[forbidden.length];
           if (!/[a-z]/.test(nextChar)) return true;
         }
 
         // Check if forbidden word appears at end preceded by non-letter
-        if (lowerKey.endsWith(forbidden) && lowerKey.length > forbidden.length) {
+        if (
+          lowerKey.endsWith(forbidden) &&
+          lowerKey.length > forbidden.length
+        ) {
           const prevChar = lowerKey[lowerKey.length - forbidden.length - 1];
           if (!/[a-z]/.test(prevChar)) return true;
         }

package/src/Shared/Types/identificationInfo.ts

@@ -1,4 +1,4 @@
-import type { FieldRecords } from 'mrz';
+import type { MRZFields } from './mrzFields';
 import type { LivenessInstructionType } from './livenessIntructionType';
 
 export interface IdentificationInfo {
@@ -24,7 +24,7 @@ export interface ScannedIdentityDocument {
   faceImageMimeType?: string;
   barcodeValue?: string;
   mrzText?: string;
-  mrzFields?: FieldRecords;
+  mrzFields?: MRZFields;
 }
 
 export interface LivenessDetection {

package/src/Shared/Types/mrzFields.ts

@@ -0,0 +1,29 @@
+/**
+ * MRZ Field Names - ICAO 9303 Standard Machine Readable Zone Fields
+ * Local type definitions to replace dependency on 'mrz' package
+ */
+
+export type MRZFieldName =
+  | 'documentCode'
+  | 'issuingState'
+  | 'documentNumber'
+  | 'documentNumberCheckDigit'
+  | 'nationality'
+  | 'lastName'
+  | 'firstName'
+  | 'sex'
+  | 'birthDate'
+  | 'birthDateCheckDigit'
+  | 'expirationDate'
+  | 'expirationDateCheckDigit'
+  | 'personalNumber'
+  | 'personalNumberCheckDigit'
+  | 'compositeCheckDigit'
+  | 'optional1'
+  | 'optional2';
+
+/**
+ * MRZ Fields - Parsed data from Machine Readable Zone
+ * Compatible with native module output
+ */
+export type MRZFields = Partial<Record<MRZFieldName, string | null>>;