@trustchex/react-native-sdk 1.362.6 → 1.374.0

package/src/Shared/Components/QrCodeScannerCamera.tsx

@@ -20,7 +20,6 @@ import { useKeepAwake } from '../Libs/native-keep-awake.utils';
 import { useIsFocused } from '@react-navigation/native';
 import { useTranslation } from 'react-i18next';
 import { debugLog, logError } from '../Libs/debug.utils';
-import LottieView from 'lottie-react-native';
 import StyledButton from './StyledButton';
 import { useTheme } from '../Contexts/ThemeContext';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
@@ -193,14 +192,7 @@ const QrCodeScannerCamera = ({
       <View style={styles.leftZone} />
       <View style={styles.rightZone} />
       <View style={styles.bottomZone} />
-      <View style={styles.scanArea}>
-        <LottieView
-          source={require('../../Shared/Animations/scanning.json')}
-          style={styles.animation}
-          loop={true}
-          autoPlay
-        />
-      </View>
+      <View style={styles.scanArea} />
       {onClose && (
         <TouchableOpacity
           onPress={onClose}

package/src/Shared/Components/TrustchexCamera.tsx

@@ -102,6 +102,7 @@ interface TrustchexCameraProps {
   torchEnabled?: boolean;
   enableFrameProcessing?: boolean;
   targetFps?: number;
+  resolution?: string;
   // ML Kit detection modes — processing runs natively, results arrive in Frame
   enableFaceDetection?: boolean;
   enableTextRecognition?: boolean;

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

@@ -29,6 +29,9 @@ const fixMRZ = (rawText: string): string => {
   // Ensure uppercase immediately
   rawText = rawText.toUpperCase();
 
+  // Apply OCR-B specific corrections early
+  rawText = applyOCRBCorrections(rawText);
+
   const fillerChar = '<';
   const mrzFormats = [
     { lines: 3, length: 30 }, // TD1
@@ -44,9 +47,21 @@ const fixMRZ = (rawText: string): string => {
   cleanedText = cleanedText.replace(/^1</gm, 'I<');
   cleanedText = cleanedText.replace(/\n1</g, '\nI<');
 
+  // Fix lowercase letters that should be uppercase (common OCR error)
+  cleanedText = cleanedText
+    .split('\n')
+    .map((line) => {
+      // Only uppercase if line contains fillers (indicates MRZ line)
+      if (line.includes('<')) {
+        return line.toUpperCase();
+      }
+      return line;
+    })
+    .join('\n');
+
   // Conservative OCR error corrections - only fix clear filler character errors
   // Don't touch valid digit sequences!
-  
+
   // Pattern 1: TD1 Line 2 filler area - After TUR, convert all K to < before check digit
   // Structure: ...TUR<<<<<<<<<<<<8 (11 fillers + 1 check digit)
   // OCR often reads: TUR<<<KKKK<<8 or TURK<<KK<<<8
@@ -54,40 +69,62 @@ const fixMRZ = (rawText: string): string => {
     const fillerPart = match.substring(3, match.length - 1).replace(/K/g, '<');
     return 'TUR' + fillerPart + checkDigit;
   });
-  
+
   // Pattern 2: Convert K at the very end of a line before check digit
   // e.g., "<<<K8" → "<<<8" (K is misread <, 8 is check digit)
   cleanedText = cleanedText.replace(/K(\d)$/gm, '<$1');
-  
+
   // Pattern 3: Convert K when surrounded by fillers only
   // e.g., "<<K<<" → "<<<<<" (clearly a filler position)
   cleanedText = cleanedText.replace(/(<+)K(<+)/g, '$1<$2');
-  
+
   // Pattern 4: Fix trailing filler area corruption at line end
   // e.g., "TUR<<<<<KK" → "TUR<<<<<<<"  (only at end after clear filler sequence)
   cleanedText = cleanedText.replace(/(<{5,})[KGB]+$/gm, (match, fillers) => {
     return fillers.padEnd(match.length, '<');
   });
 
+  // Pattern 5: Fix common OCR misreadings in filler areas
+  // Convert non-alphanumeric chars in filler areas to '<' (but not digits/letters in content areas)
+  cleanedText = cleanedText
+    .split('\n')
+    .map((line) => {
+      // If line has fillers, likely MRZ - safe to convert uncommon chars near fillers
+      if (!line.includes('<')) return line;
+
+      // Replace '.' ',' '-' with fillers in MRZ lines (OCR noise)
+      line = line.replace(/[.,\-~`^]/g, '<');
+
+      // Replace lowercase o/i/l with uppercase or filler depending on context
+      line = line.replace(/o(?=[A-Z<]|[A-Z<]o)/g, 'O'); // lowercase o surrounded by uppercase
+      line = line.replace(/i(?=[A-Z<]|[A-Z<]i)/g, 'I'); // lowercase i surrounded by uppercase
+      line = line.replace(/l(?=[A-Z<0-9])/g, 'L'); // lowercase l before uppercase or digit
+      line = line.replace(/l$/g, '<'); // lowercase l at line end is filler
+
+      return line;
+    })
+    .join('\n');
+
   // Split into lines and filter for MRZ-like content
   // MRZ lines must start with I< or contain long sequences of < and alphanumeric chars
   const lines = cleanedText
     .split('\n')
-    .map(line => line.trim())
-    .filter(line => {
+    .map((line) => line.trim())
+    .filter((line) => {
       // Must contain filler characters
       if (!/<+/.test(line)) return false;
-      
+
       // Prioritize lines starting with I< (document code)
       if (line.startsWith('I<')) return true;
-      
+
       // Or lines with numbers and fillers (second line of TD1: birth date, expiry, etc.)
       if (/\d{5,}/.test(line) && /<{3,}/.test(line)) return true;
-      
+
       // Or lines that look like name fields (third line of TD1: surname, given names)
       // Accept shorter lines (min 10 chars) since OCR often truncates the third line
-      if (line.length >= 10 && /^[A-Z<]+$/.test(line) && /<{2,}/.test(line)) return true;
-      
+      if (line.length >= 10 && /^[A-Z<]+$/.test(line) && /<{2,}/.test(line))
+        return true;
+
       return false;
     });
 
@@ -100,7 +137,7 @@ const fixMRZ = (rawText: string): string => {
   for (const format of mrzFormats) {
     const expectedLen = format.length;
     // Check if all lines are within acceptable length
-    if (lines.every(line => line.length <= expectedLen + 5)) {
+    if (lines.every((line) => line.length <= expectedLen + 5)) {
       detectedFormat = format;
       break;
     }
@@ -141,20 +178,127 @@ const fixMRZ = (rawText: string): string => {
 
 const AMBIGUOUS_CHAR_MAP: Record<string, string[]> = {
   '0': ['O', 'Q', 'D'],
-  O: ['0', 'Q', 'D'],
-  Q: ['0', 'O', 'D'],
-  D: ['0', 'O', 'Q'],
+  'O': ['0', 'Q', 'D'],
+  'Q': ['0', 'O', 'D'],
+  'D': ['0', 'O', 'Q'],
   '1': ['I', 'L'],
-  I: ['1', 'L'],
-  L: ['1', 'I'],
+  'I': ['1', 'L'],
+  'L': ['1', 'I'],
   '2': ['Z'],
-  Z: ['2'],
+  'Z': ['2'],
   '5': ['S'],
-  S: ['5'],
+  'S': ['5'],
   '6': ['G'],
-  G: ['6'],
+  'G': ['6'],
   '8': ['B'],
-  B: ['8'],
+  'B': ['8'],
+  '9': ['g'],
+  'g': ['9'],
+  '4': ['A'],
+  'A': ['4'],
+};
+
+/**
+ * OCR-B specific character corrections (used for MRZ on passports/IDs)
+ * OCR-B is monospaced and has specific glyph patterns that differ from other fonts
+ * Common OCR-B misreadings in document scanning context
+ */
+const OCRB_SPECIFIC_MAP: Record<string, string> = {
+  // Glyph confusion in OCR-B (low contrast scanning)
+  Ø: '0', // Slashed zero sometimes appears as capital O with slash
+  ø: '0', // Lowercase variant
+  œ: 'O', // Ligature
+
+  // Common in monospace OCR
+  Ι: 'I', // Greek capital iota confused with I
+  ι: 'i', // Greek lowercase iota
+  l: 'I', // Lowercase L as I (common with serif OCR-B variants)
+};
+
+/**
+ * Validates OCR-B specific character patterns
+ * @param text Text to validate
+ * @returns True if text matches OCR-B patterns reasonably well
+ */
+const isValidOCRBPattern = (text: string): boolean => {
+  const lines = text.split('\n').filter((l) => l.trim());
+
+  // OCR-B MRZ validation
+  for (const line of lines) {
+    if (!/<+/.test(line)) continue; // Skip non-MRZ lines
+
+    // OCR-B characteristics check:
+    // 1. Monospaced - all lines should have similar length (±2 chars)
+    // 2. Specific filler pattern - at least 3 consecutive fillers
+    // 3. Mixed digits and letters - checkdigits, names, dates
+
+    const fillerGroups = (line.match(/<+/g) || []).length;
+    const letterDigitSegments = (line.match(/[A-Z0-9]+/g) || []).length;
+
+    // Valid OCR-B should have 2-4 filler groups and 2-4 alphanumeric segments
+    if (fillerGroups < 1 || letterDigitSegments < 1) return false;
+    if (fillerGroups > 6 || letterDigitSegments > 6) return false; // Too fragmented
+  }
+
+  return true;
+};
+
+/**
+ * Applies OCR-B specific corrections to raw OCR text
+ * @param text Raw OCR text
+ * @returns Text with OCR-B corrections applied
+ */
+const applyOCRBCorrections = (text: string): string => {
+  let corrected = text;
+
+  // Replace OCR-B specific misreadings
+  for (const [wrong, correct] of Object.entries(OCRB_SPECIFIC_MAP)) {
+    corrected = corrected.replace(new RegExp(wrong, 'g'), correct);
+  }
+
+  // Apply line-by-line OCR-B specific logic
+  corrected = corrected
+    .split('\n')
+    .map((line) => {
+      if (!line.includes('<')) return line; // Not an MRZ line
+
+      // In OCR-B MRZ, digit positions are strictly defined
+      // If we see obvious letter/digit confusion in digit areas, correct it
+
+      // Document number area: should be digits or fillers
+      // Pattern: after 2nd filler block, expect <8-9 digit chars> before next filler block
+      line = line.replace(
+        /([<]+)([A-Z])([0-9]{1,2})([<]+)/g,
+        (match, filler1, letter, digits, filler2) => {
+          // If single letter between fillers and digits, likely OCR error
+          if (letter === 'O') return `${filler1}0${digits}${filler2}`; // O -> 0
+          if (letter === 'I' || letter === 'L')
+            return `${filler1}1${digits}${filler2}`; // I/L -> 1
+          return match;
+        }
+      );
+
+      // Check digit areas (end of lines): should be single digit, not letter
+      line = line.replace(
+        /([<]+)([A-Z])(\d)?$/gm,
+        (match, fillers, letter, maybeDigit) => {
+          // If a letter appears before line end in check digit area, convert
+          if (letter === 'O') return `${fillers}0${maybeDigit || ''}`;
+          if (letter === 'I' || letter === 'L')
+            return `${fillers}1${maybeDigit || ''}`;
+          if (letter === 'S') return `${fillers}5${maybeDigit || ''}`;
+          if (letter === 'Z') return `${fillers}2${maybeDigit || ''}`;
+          if (letter === 'B') return `${fillers}8${maybeDigit || ''}`;
+          if (letter === 'G') return `${fillers}6${maybeDigit || ''}`;
+          return match;
+        }
+      );
+
+      return line;
+    })
+    .join('\n');
+
+  return corrected;
 };
 
 const generateAmbiguousVariants = (
@@ -182,7 +326,7 @@ const generateAmbiguousVariants = (
 
       for (const replacement of replacements) {
         if (replacement === entryChar) continue;
-        if (entries.length >= maxVariants) return entries.map(e => e.text);
+        if (entries.length >= maxVariants) return entries.map((e) => e.text);
 
         const newText =
           entry.text.slice(0, i) + replacement + entry.text.slice(i + 1);
@@ -194,7 +338,7 @@ const generateAmbiguousVariants = (
     }
   }
 
-  return entries.map(e => e.text);
+  return entries.map((e) => e.text);
 };
 
 /**
@@ -277,12 +421,76 @@ const validateMRZ = (
  * @param mrzText Raw OCR text
  * @returns Validation result with parsed fields
  */
-const validateMRZWithCorrections = (
-  mrzText: string
-): MRZValidationResult => {
+const validateMRZWithCorrections = (mrzText: string): MRZValidationResult => {
   return validateMRZ(mrzText, true);
 };
 
+/**
+ * Calculates quality score for recognized MRZ text (0-100)
+ * Higher score = higher confidence in the OCR result
+ * @param mrzText Recognized MRZ text
+ * @returns Quality score 0-100
+ */
+const calculateMRZQualityScore = (mrzText: string): number => {
+  if (!mrzText) return 0;
+
+  let score = 100;
+  const lines = mrzText.split('\n').filter((l) => l.trim());
+
+  // Penalty for incomplete lines
+  if (lines.length < 2) score -= 40;
+  if (lines.some((l) => l.length < 30)) score -= 20;
+
+  for (const line of lines) {
+    // Count suspicious patterns that indicate OCR errors
+    const fillerCount = (line.match(/</g) || []).length;
+    const digitCount = (line.match(/\d/g) || []).length;
+    const letterCount = (line.match(/[A-Z]/g) || []).length;
+    const suspiciousCount = (line.match(/[KGB]{2,}|[0O]{2,}/g) || []).length;
+
+    // Penalize if too many suspicious patterns
+    if (suspiciousCount > 0) score -= suspiciousCount * 5;
+
+    // Penalize if ratio of fillers seems wrong (should be 40-60% for most lines)
+    const fillerRatio = fillerCount / line.length;
+    if (fillerRatio < 0.3 || fillerRatio > 0.7) score -= 10;
+
+    // Penalize if no digits where expected (birth date, expiry date, check digits)
+    if (letterCount > digitCount) {
+      // Some lines should have mostly digits (date lines)
+      if (line.match(/\d{5,6}/)) {
+        // Has valid date pattern, ok
+      } else if (line.length > 30 && digitCount === 0) {
+        score -= 15;
+      }
+    }
+  }
+
+  // Apply consistency bonus if lines have similar length
+  const lengths = lines.map((l) => l.length);
+  const avgLength = lengths.reduce((a, b) => a + b, 0) / lines.length;
+  const variance =
+    lengths.reduce((sum, len) => sum + Math.abs(len - avgLength), 0) /
+    lines.length;
+  if (variance < 5) score += 10;
+
+  return Math.max(0, Math.min(100, score));
+};
+
+/**
+ * Validates MRZ quality and returns confidence level
+ * @param mrzText Raw or fixed MRZ text
+ * @returns Object with quality score and confidence level
+ */
+const assessMRZQuality = (mrzText: string) => {
+  const score = calculateMRZQualityScore(mrzText);
+  return {
+    score,
+    confidence: score >= 80 ? 'high' : score >= 60 ? 'medium' : 'low',
+    reliable: score >= 70,
+  };
+};
+
 /**
  * Converts an MRZ date string to an ISO date string.
  * @param mrzDate  The MRZ date string to convert (YYMMDD format)
@@ -308,5 +516,9 @@ export default {
   fixMRZ,
   validateMRZ,
   validateMRZWithCorrections,
+  calculateMRZQualityScore,
+  assessMRZQuality,
+  isValidOCRBPattern,
+  applyOCRBCorrections,
   convertMRZDateToISODate,
 };

package/src/Translation/Resources/en.ts

@@ -131,10 +131,6 @@ export default {
   'identityDocumentCamera.alignIDBackSide':
     'Align the back side of your ID card',
   'identityDocumentCamera.scanCompleted': 'Scan completed!',
-  'identityDocumentCamera.frontSideScanned': 'Front side scanned!',
-  'identityDocumentCamera.passportScanned': 'Passport scanned!',
-  'identityDocumentCamera.backSideScanned': 'Back side scanned!',
-  'identityDocumentCamera.hologramVerified': 'Hologram verified!',
   'identityDocumentCamera.searchingDocument':
     'Position document within the frame',
   'identityDocumentCamera.faceDetected': 'Keep device steady...',

package/src/Translation/Resources/tr.ts

@@ -132,10 +132,6 @@ export default {
   'identityDocumentCamera.alignIDBackSide':
     'Kimlik kartınızın arka yüzünü hizalayın',
   'identityDocumentCamera.scanCompleted': 'Tarama tamamlandı!',
-  'identityDocumentCamera.frontSideScanned': 'Ön yüz tarandı!',
-  'identityDocumentCamera.passportScanned': 'Pasaport tarandı!',
-  'identityDocumentCamera.backSideScanned': 'Arka yüz tarandı!',
-  'identityDocumentCamera.hologramVerified': 'Hologram doğrulandı!',
   'identityDocumentCamera.searchingDocument':
     'Belgeyi çerçeve içine yerleştirin',
   'identityDocumentCamera.faceDetected': 'Cihazı sabit tutun...',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.362.6';
+export const SDK_VERSION = '1.374.0';