@trustchex/react-native-sdk 1.360.0 → 1.362.0

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

@@ -1,9 +1,294 @@
+import { parse } from 'mrz';
+import type { MRZFields } from '../Types/mrzFields';
+
+/**
+ * MRZ Format Types according to ICAO 9303
+ */
+export type MRZFormat = 'TD1' | 'TD2' | 'TD3' | 'UNKNOWN';
+
+/**
+ * MRZ Validation Result
+ */
+export interface MRZValidationResult {
+  valid: boolean;
+  format: MRZFormat;
+  fields?: MRZFields;
+  error?: string;
+}
+
+/**
+ * Fixes raw MRZ text by removing noise and normalizing
+ * @param rawText Raw OCR text
+ * @returns Cleaned and normalized MRZ text
+ */
+const fixMRZ = (rawText: string): string => {
+  if (!rawText) {
+    return '';
+  }
+
+  // Ensure uppercase immediately
+  rawText = rawText.toUpperCase();
+
+  const fillerChar = '<';
+  const mrzFormats = [
+    { lines: 3, length: 30 }, // TD1
+    { lines: 2, length: 36 }, // TD2
+    { lines: 2, length: 44 }, // TD3
+  ];
+
+  // Remove « characters, spaces, and tabs (but preserve newlines for line splitting)
+  // OCR sometimes inserts spaces within document numbers
+  let cleanedText = rawText.replace(/[« \t*]/g, '');
+
+  // Critical OCR fix: "1" at start of line is always "I" in MRZ (document code)
+  cleanedText = cleanedText.replace(/^1</gm, 'I<');
+  cleanedText = cleanedText.replace(/\n1</g, '\nI<');
+
+  // 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
+  cleanedText = cleanedText.replace(/TUR[<K]+(\d)$/gm, (match, checkDigit) => {
+    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, '<');
+  });
+
+  // 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 => {
+      // 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;
+      
+      return false;
+    });
+
+  if (lines.length === 0) {
+    return rawText;
+  }
+
+  // Detect format based on line lengths
+  let detectedFormat: { lines: number; length: number } | null = null;
+  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)) {
+      detectedFormat = format;
+      break;
+    }
+  }
+
+  if (!detectedFormat) {
+    return rawText;
+  }
+
+  const expectedLen = detectedFormat.length;
+  const expectedLines = detectedFormat.lines;
+
+  // Pad lines to expected length
+  const mrzLines: string[] = [];
+  for (let line of lines) {
+    if (line.includes('<')) {
+      if (line.length < expectedLen) {
+        // Pad to expected length
+        line = line.padEnd(expectedLen, fillerChar);
+      } else if (line.length > expectedLen) {
+        // Truncate to expected length
+        line = line.substring(0, expectedLen);
+      }
+      mrzLines.push(line);
+
+      // Stop when we have the expected number of lines
+      if (mrzLines.length >= expectedLines) break;
+    }
+  }
+
+  if (mrzLines.length < 2) {
+    return rawText;
+  }
+
+  const fixedMRZ = mrzLines.join('\n');
+  return fixedMRZ;
+};
+
+const AMBIGUOUS_CHAR_MAP: Record<string, string[]> = {
+  '0': ['O', 'Q', 'D'],
+  O: ['0', 'Q', 'D'],
+  Q: ['0', 'O', 'D'],
+  D: ['0', 'O', 'Q'],
+  '1': ['I', 'L'],
+  I: ['1', 'L'],
+  L: ['1', 'I'],
+  '2': ['Z'],
+  Z: ['2'],
+  '5': ['S'],
+  S: ['5'],
+  '6': ['G'],
+  G: ['6'],
+  '8': ['B'],
+  B: ['8'],
+};
+
+const generateAmbiguousVariants = (
+  text: string,
+  maxChanges: number = 2,
+  maxVariants: number = 64
+): string[] => {
+  const entries: Array<{ text: string; changes: number }> = [
+    { text, changes: 0 },
+  ];
+  const seen = new Set<string>([text]);
+
+  for (let i = 0; i < text.length; i++) {
+    const initialReplacements = AMBIGUOUS_CHAR_MAP[text[i]];
+    if (!initialReplacements) continue;
+
+    const currentLen = entries.length;
+    for (let j = 0; j < currentLen; j++) {
+      const entry = entries[j];
+      if (entry.changes >= maxChanges) continue;
+
+      const entryChar = entry.text[i];
+      const replacements = AMBIGUOUS_CHAR_MAP[entryChar];
+      if (!replacements) continue;
+
+      for (const replacement of replacements) {
+        if (replacement === entryChar) continue;
+        if (entries.length >= maxVariants) return entries.map(e => e.text);
+
+        const newText =
+          entry.text.slice(0, i) + replacement + entry.text.slice(i + 1);
+        if (!seen.has(newText)) {
+          seen.add(newText);
+          entries.push({ text: newText, changes: entry.changes + 1 });
+        }
+      }
+    }
+  }
+
+  return entries.map(e => e.text);
+};
+
+/**
+ * Validates MRZ text using the mrz npm package
+ * @param mrzText Raw or cleaned MRZ text
+ * @param autocorrect Enable autocorrection
+ * @returns Validation result with parsed fields
+ */
+const validateMRZ = (
+  mrzText: string,
+  autocorrect: boolean = true
+): MRZValidationResult => {
+  try {
+    const fixedText = fixMRZ(mrzText);
+    let result = parse(fixedText, { autocorrect });
+
+    if (!result || !result.valid) {
+      const variants = generateAmbiguousVariants(fixedText);
+      for (const variant of variants) {
+        if (variant === fixedText) continue;
+        const candidate = parse(variant, { autocorrect });
+        if (candidate && candidate.valid) {
+          result = candidate;
+          break;
+        }
+      }
+    }
+
+    if (!result || !result.valid) {
+      return {
+        valid: false,
+        format: 'UNKNOWN',
+        error: 'Invalid MRZ format or checksum',
+      };
+    }
+
+    // Map mrz package format to our format
+    let format: MRZFormat = 'UNKNOWN';
+    if (result.format === 'TD1') format = 'TD1';
+    else if (result.format === 'TD2') format = 'TD2';
+    else if (result.format === 'TD3') format = 'TD3';
+
+    // Map mrz package fields to our MRZFields type
+    const fields: MRZFields = {
+      documentCode: result.fields.documentCode || null,
+      issuingState: result.fields.issuingState || null,
+      documentNumber: result.fields.documentNumber || null,
+      documentNumberCheckDigit: result.fields.documentNumberCheckDigit || null,
+      nationality: result.fields.nationality || null,
+      lastName: result.fields.lastName || null,
+      firstName: result.fields.firstName || null,
+      sex: result.fields.sex || null,
+      birthDate: result.fields.birthDate || null,
+      birthDateCheckDigit: result.fields.birthDateCheckDigit || null,
+      expirationDate: result.fields.expirationDate || null,
+      expirationDateCheckDigit: result.fields.expirationDateCheckDigit || null,
+      personalNumber: result.fields.personalNumber || null,
+      personalNumberCheckDigit: result.fields.personalNumberCheckDigit || null,
+      compositeCheckDigit: result.fields.compositeCheckDigit || null,
+      optional1: result.fields.optional1 || null,
+      optional2: result.fields.optional2 || null,
+    };
+
+    return {
+      valid: true,
+      format,
+      fields,
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      format: 'UNKNOWN',
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+};
+
+/**
+ * Validates MRZ with corrections (uses autocorrect from mrz package)
+ * @param mrzText Raw OCR text
+ * @returns Validation result with parsed fields
+ */
+const validateMRZWithCorrections = (
+  mrzText: string
+): MRZValidationResult => {
+  return validateMRZ(mrzText, true);
+};
+
 /**
  * Converts an MRZ date string to an ISO date string.
  * @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) => {
+const convertMRZDateToISODate = (mrzDate?: string | null): string | null => {
   if (!mrzDate || mrzDate.length !== 6) {
     return null;
   }
@@ -20,5 +305,8 @@ const convertMRZDateToISODate = (mrzDate?: string | null) => {
 };
 
 export default {
+  fixMRZ,
+  validateMRZ,
+  validateMRZWithCorrections,
   convertMRZDateToISODate,
 };

package/src/Trustchex.tsx

@@ -15,6 +15,7 @@ import ContractAcceptanceScreen from './Screens/Dynamic/ContractAcceptanceScreen
 import VerificationSessionCheckScreen from './Screens/Static/VerificationSessionCheckScreen';
 import QrCodeScanningScreen from './Screens/Static/QrCodeScanningScreen';
 import OTPVerificationScreen from './Screens/Static/OTPVerificationScreen';
+import MRZTestScreen from './Screens/Debug/MRZTestScreen';
 import AppContext from './Shared/Contexts/AppContext';
 import DebugNavigationPanel from './Shared/Components/DebugNavigationPanel';
 import i18n from './Translation';
@@ -227,6 +228,10 @@ const Trustchex: React.FC<TrustchexProps> = ({
                 name="QrCodeScanningScreen"
                 component={QrCodeScanningScreen}
               />
+              <Stack.Screen
+                name="MRZTestScreen"
+                component={MRZTestScreen}
+              />
             </Stack.Navigator>
             <DebugNavigationPanel />
           </NavigationContainer>

package/src/index.tsx

@@ -48,5 +48,8 @@ export type {
   ErrorContext,
   ErrorEventMetadata,
 } from './Shared/Types/analytics.types';
+export { default as mrzUtils } from './Shared/Libs/mrz.utils';
+export type { MRZFormat, MRZValidationResult } from './Shared/Libs/mrz.utils';
+export type { MRZFields, MRZFieldName } from './Shared/Types/mrzFields';
 
 export default Trustchex;

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.360.0';
+export const SDK_VERSION = '1.362.0';