@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/ios/MRZValidator.swift

@@ -0,0 +1,466 @@
+import Foundation
+
+/**
+ * Pure MRZ validation logic with no React Native dependencies.
+ * Used by both MRZValidation and TrustchexCameraView.
+ */
+class MRZValidator {
+
+    enum MRZFormat: String {
+        case TD1 = "TD1"
+        case TD2 = "TD2"
+        case TD3 = "TD3"
+        case UNKNOWN = "UNKNOWN"
+    }
+
+    struct MRZResult {
+        let valid: Bool
+        let format: String
+        let error: String?
+        let documentCode: String?
+        let issuingState: String?
+        let documentNumber: String?
+        let lastName: String?
+        let firstName: String?
+        let birthDate: String?
+        let sex: String?
+        let expirationDate: String?
+        let nationality: String?
+        let optional1: String?
+        let optional2: String?
+        let rawLines: String?
+
+        func toDictionary() -> [String: Any] {
+            var dict: [String: Any] = ["valid": valid, "format": format]
+            if let e = error { dict["error"] = e }
+            if let v = documentCode { dict["documentCode"] = v }
+            if let v = issuingState { dict["issuingState"] = v }
+            if let v = documentNumber { dict["documentNumber"] = v }
+            if let v = lastName { dict["lastName"] = v }
+            if let v = firstName { dict["firstName"] = v }
+            if let v = birthDate { dict["birthDate"] = v }
+            if let v = sex { dict["sex"] = v }
+            if let v = expirationDate { dict["expirationDate"] = v }
+            if let v = nationality { dict["nationality"] = v }
+            if let v = optional1 { dict["optional1"] = v }
+            if let v = optional2 { dict["optional2"] = v }
+            if let v = rawLines { dict["rawLines"] = v }
+            return dict
+        }
+    }
+
+    func validateWithCorrections(_ ocrText: String) -> MRZResult {
+        let fixedText = fixMRZ(ocrText)
+        var lines = fixedText.trimmingCharacters(in: .whitespacesAndNewlines)
+            .components(separatedBy: "\n")
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+
+        if lines.isEmpty || fixedText.count < 60 {
+            return MRZResult(valid: false, format: "UNKNOWN", error: "MRZ text too short",
+                documentCode: nil, issuingState: nil, documentNumber: nil, lastName: nil,
+                firstName: nil, birthDate: nil, sex: nil, expirationDate: nil,
+                nationality: nil, optional1: nil, optional2: nil, rawLines: nil)
+        }
+
+        let format = detectMRZFormat(lines)
+        guard format != .UNKNOWN else {
+            return MRZResult(valid: false, format: "UNKNOWN", error: "Unknown MRZ format",
+                documentCode: nil, issuingState: nil, documentNumber: nil, lastName: nil,
+                firstName: nil, birthDate: nil, sex: nil, expirationDate: nil,
+                nationality: nil, optional1: nil, optional2: nil, rawLines: nil)
+        }
+
+        // Phase 1
+        var result = parseMRZ(fixedText)
+        if result.valid { return result }
+
+        // Phase 2: composite brute-force
+        let compositePos: (line: Int, pos: Int)?
+        switch format {
+        case .TD1: compositePos = (1, 29)
+        case .TD2: compositePos = (1, 35)
+        case .TD3: compositePos = (1, 43)
+        case .UNKNOWN: compositePos = nil
+        }
+        if let pos = compositePos {
+            for digit in 0...9 {
+                var testLines = lines
+                var chars = Array(testLines[pos.line])
+                chars[pos.pos] = Character(String(digit))
+                testLines[pos.line] = String(chars)
+                let testResult = parseMRZ(testLines.joined(separator: "\n"))
+                if testResult.valid { return testResult }
+            }
+        }
+
+        // Phase 3: O/0 permutations
+        for permutation in generateO0Permutations(fixedText) {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        // Phase 4: I/1 permutations
+        for permutation in generateI1Permutations(fixedText) {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        // Phase 5: S/5 permutations
+        for permutation in generatePairPermutations(fixedText, letter: "S", digit: "5") {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        // Phase 6: B/8 permutations
+        for permutation in generatePairPermutations(fixedText, letter: "B", digit: "8") {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        // Phase 7: Z/2 permutations
+        for permutation in generatePairPermutations(fixedText, letter: "Z", digit: "2") {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        // Phase 8: G/6 permutations
+        for permutation in generatePairPermutations(fixedText, letter: "G", digit: "6") {
+            let testResult = parseMRZ(permutation)
+            if testResult.valid { return testResult }
+        }
+
+        return result
+    }
+
+    private func parseMRZ(_ rawText: String) -> MRZResult {
+        let lines = rawText.trimmingCharacters(in: .whitespacesAndNewlines)
+            .components(separatedBy: "\n")
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+
+        let format = detectMRZFormat(lines)
+        guard format != .UNKNOWN else {
+            return MRZResult(valid: false, format: "UNKNOWN", error: "Unknown MRZ format",
+                documentCode: nil, issuingState: nil, documentNumber: nil, lastName: nil,
+                firstName: nil, birthDate: nil, sex: nil, expirationDate: nil,
+                nationality: nil, optional1: nil, optional2: nil, rawLines: nil)
+        }
+
+        let fields: MRZResult
+        switch format {
+        case .TD1: fields = parseTD1(lines, format: format)
+        case .TD2: fields = parseTD2(lines, format: format)
+        case .TD3: fields = parseTD3(lines, format: format)
+        case .UNKNOWN:
+            return MRZResult(valid: false, format: "UNKNOWN", error: "Unsupported format",
+                documentCode: nil, issuingState: nil, documentNumber: nil, lastName: nil,
+                firstName: nil, birthDate: nil, sex: nil, expirationDate: nil,
+                nationality: nil, optional1: nil, optional2: nil, rawLines: nil)
+        }
+
+        let allValid = validateChecksums(format: format, lines: lines)
+        return MRZResult(valid: allValid, format: format.rawValue, error: fields.error,
+            documentCode: fields.documentCode, issuingState: fields.issuingState,
+            documentNumber: fields.documentNumber, lastName: fields.lastName,
+            firstName: fields.firstName, birthDate: fields.birthDate, sex: fields.sex,
+            expirationDate: fields.expirationDate, nationality: fields.nationality,
+            optional1: fields.optional1, optional2: fields.optional2,
+            rawLines: allValid ? rawText.trimmingCharacters(in: .whitespacesAndNewlines) : nil)
+    }
+
+    private func detectMRZFormat(_ lines: [String]) -> MRZFormat {
+        if lines.count == 3 && lines.allSatisfy({ $0.count == 30 }) { return .TD1 }
+        if lines.count == 2 && lines.allSatisfy({ $0.count == 36 }) { return .TD2 }
+        if lines.count == 2 && lines.allSatisfy({ $0.count == 44 }) { return .TD3 }
+        return .UNKNOWN
+    }
+
+    private func str(_ s: String, from: Int, length: Int) -> String {
+        let start = s.index(s.startIndex, offsetBy: from)
+        let end = s.index(start, offsetBy: length)
+        return String(s[start..<end]).replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces)
+    }
+
+    private func raw(_ s: String, from: Int, length: Int) -> String {
+        let start = s.index(s.startIndex, offsetBy: from)
+        let end = s.index(start, offsetBy: length)
+        return String(s[start..<end])
+    }
+
+    private func parseTD1(_ lines: [String], format: MRZFormat) -> MRZResult {
+        let names = lines[2].components(separatedBy: "<<")
+        return MRZResult(valid: false, format: format.rawValue, error: nil,
+            documentCode: str(lines[0], from: 0, length: 2),
+            issuingState: str(lines[0], from: 2, length: 3),
+            documentNumber: str(lines[0], from: 5, length: 9),
+            lastName: names[0].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces),
+            firstName: names.count > 1 ? names[1].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces) : "",
+            birthDate: raw(lines[1], from: 0, length: 6),
+            sex: raw(lines[1], from: 7, length: 1),
+            expirationDate: raw(lines[1], from: 8, length: 6),
+            nationality: str(lines[1], from: 15, length: 3),
+            optional1: str(lines[0], from: 15, length: 15),
+            optional2: str(lines[1], from: 18, length: 11), rawLines: nil)
+    }
+
+    private func parseTD2(_ lines: [String], format: MRZFormat) -> MRZResult {
+        let names = String(lines[0].dropFirst(5)).components(separatedBy: "<<")
+        return MRZResult(valid: false, format: format.rawValue, error: nil,
+            documentCode: str(lines[0], from: 0, length: 2),
+            issuingState: str(lines[0], from: 2, length: 3),
+            documentNumber: str(lines[1], from: 0, length: 9),
+            lastName: names[0].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces),
+            firstName: names.count > 1 ? names[1].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces) : "",
+            birthDate: raw(lines[1], from: 13, length: 6),
+            sex: raw(lines[1], from: 20, length: 1),
+            expirationDate: raw(lines[1], from: 21, length: 6),
+            nationality: str(lines[1], from: 10, length: 3),
+            optional1: str(lines[1], from: 28, length: 7),
+            optional2: nil, rawLines: nil)
+    }
+
+    private func parseTD3(_ lines: [String], format: MRZFormat) -> MRZResult {
+        let names = String(lines[0].dropFirst(5)).components(separatedBy: "<<")
+        return MRZResult(valid: false, format: format.rawValue, error: nil,
+            documentCode: str(lines[0], from: 0, length: 2),
+            issuingState: str(lines[0], from: 2, length: 3),
+            documentNumber: str(lines[1], from: 0, length: 9),
+            lastName: names[0].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces),
+            firstName: names.count > 1 ? names[1].replacingOccurrences(of: "<", with: " ").trimmingCharacters(in: .whitespaces) : "",
+            birthDate: raw(lines[1], from: 13, length: 6),
+            sex: raw(lines[1], from: 20, length: 1),
+            expirationDate: raw(lines[1], from: 21, length: 6),
+            nationality: str(lines[1], from: 10, length: 3),
+            optional1: str(lines[1], from: 28, length: 14),
+            optional2: nil, rawLines: nil)
+    }
+
+    private func validateChecksums(format: MRZFormat, lines: [String]) -> Bool {
+        guard lines.count >= (format == .TD1 ? 3 : 2) else { return false }
+        do {
+            switch format {
+            case .TD1:
+                let l0 = lines[0], l1 = lines[1]
+                let docValid = try calculateChecksum(raw(l0, from: 5, length: 9)) == l0[l0.index(l0.startIndex, offsetBy: 14)]
+                let birthValid = try calculateChecksum(raw(l1, from: 0, length: 6)) == l1[l1.index(l1.startIndex, offsetBy: 6)]
+                let expiryValid = try calculateChecksum(raw(l1, from: 8, length: 6)) == l1[l1.index(l1.startIndex, offsetBy: 14)]
+                let composite = String(l0.dropFirst(5)) + String(l1.prefix(7)) + String(l1.dropFirst(8).prefix(7)) + String(l1.dropFirst(18).prefix(11))
+                let compValid = try calculateChecksum(composite) == l1[l1.index(l1.startIndex, offsetBy: 29)]
+                return docValid && birthValid && expiryValid && compValid
+            case .TD2:
+                let l = lines[1]
+                let docValid = try calculateChecksum(raw(l, from: 0, length: 9)) == l[l.index(l.startIndex, offsetBy: 9)]
+                let birthValid = try calculateChecksum(raw(l, from: 13, length: 6)) == l[l.index(l.startIndex, offsetBy: 19)]
+                let expiryValid = try calculateChecksum(raw(l, from: 21, length: 6)) == l[l.index(l.startIndex, offsetBy: 27)]
+                let composite = String(l.prefix(10)) + String(l.dropFirst(13).prefix(7)) + String(l.dropFirst(21).prefix(14))
+                let compValid = try calculateChecksum(composite) == l[l.index(l.startIndex, offsetBy: 35)]
+                return docValid && birthValid && expiryValid && compValid
+            case .TD3:
+                let l = lines[1]
+                let docValid = try calculateChecksum(raw(l, from: 0, length: 9)) == l[l.index(l.startIndex, offsetBy: 9)]
+                let birthValid = try calculateChecksum(raw(l, from: 13, length: 6)) == l[l.index(l.startIndex, offsetBy: 19)]
+                let expiryValid = try calculateChecksum(raw(l, from: 21, length: 6)) == l[l.index(l.startIndex, offsetBy: 27)]
+                let personalValid = try calculateChecksum(raw(l, from: 28, length: 14)) == l[l.index(l.startIndex, offsetBy: 42)]
+                let composite = String(l.prefix(10)) + String(l.dropFirst(13).prefix(7)) + String(l.dropFirst(21).prefix(22))
+                let compValid = try calculateChecksum(composite) == l[l.index(l.startIndex, offsetBy: 43)]
+                return docValid && birthValid && expiryValid && personalValid && compValid
+            case .UNKNOWN:
+                return false
+            }
+        } catch {
+            return false
+        }
+    }
+
+    private func calculateChecksum(_ data: String) throws -> Character {
+        let weights = [7, 3, 1]
+        var sum = 0
+        for (index, char) in data.enumerated() {
+            let value: Int
+            switch char {
+            case "0"..."9": value = Int(char.asciiValue! - Character("0").asciiValue!)
+            case "A"..."Z": value = Int(char.asciiValue! - Character("A").asciiValue!) + 10
+            default: value = 0
+            }
+            sum += value * weights[index % 3]
+        }
+        return Character(String(sum % 10))
+    }
+
+    func fixMRZ(_ rawText: String) -> String {
+        var fixed = rawText
+            .replacingOccurrences(of: " ", with: "")
+            .replacingOccurrences(of: "«", with: "")
+        if let regex = try? NSRegularExpression(pattern: "<K+|r+K+|<r+K+") {
+            fixed = regex.stringByReplacingMatches(in: fixed, range: NSRange(fixed.startIndex..., in: fixed), withTemplate: "")
+        }
+        if let regex = try? NSRegularExpression(pattern: "\\bI<TUR([A-Z0-9]{3})0([A-Z0-9]{6})\\b") {
+            fixed = regex.stringByReplacingMatches(in: fixed, range: NSRange(fixed.startIndex..., in: fixed), withTemplate: "I<TUR$1O$2")
+        }
+        let mrzCharRegex = try? NSRegularExpression(pattern: "^[A-Z0-9<]+$")
+        let allLines = fixed.components(separatedBy: "\n").map { $0.trimmingCharacters(in: .whitespaces) }
+
+        // Extract only lines that are exact MRZ lengths with valid MRZ characters
+        let mrzLines = allLines.filter { line in
+            (line.count == 30 || line.count == 36 || line.count == 44) &&
+            mrzCharRegex?.firstMatch(in: line, range: NSRange(line.startIndex..., in: line)) != nil
+        }
+
+        // Fall back to lines containing '<' if no exact-length lines found
+        let candidateLines = mrzLines.isEmpty ? allLines.filter { $0.contains("<") } : mrzLines
+
+        let targetLength: Int
+        if candidateLines.allSatisfy({ $0.count <= 30 }) { targetLength = 30 }
+        else if candidateLines.allSatisfy({ $0.count <= 36 }) { targetLength = 36 }
+        else if candidateLines.allSatisfy({ $0.count <= 44 }) { targetLength = 44 }
+        else { return rawText }
+
+        // Keep only lines that fit the target length and have valid MRZ characters
+        let filteredLines = candidateLines.filter { line in
+            line.count <= targetLength &&
+            mrzCharRegex?.firstMatch(in: line, range: NSRange(line.startIndex..., in: line)) != nil
+        }
+        if filteredLines.isEmpty { return rawText }
+
+        let paddedLines = filteredLines.map { line in
+            line.count < targetLength ? line.padding(toLength: targetLength, withPad: "<", startingAt: 0) : line
+        }
+        return applyOCRCorrections(paddedLines.joined(separator: "\n"))
+    }
+
+    private func applyOCRCorrections(_ mrzText: String) -> String {
+        var lines = mrzText.components(separatedBy: "\n")
+        if lines.isEmpty { return mrzText }
+        let format = detectMRZFormat(lines)
+        if format == .UNKNOWN { return mrzText }
+        switch format {
+        case .TD1:
+            lines[0] = correctLetterPositions(lines[0], ranges: [0...1, 2...4])
+            lines[0] = correctCheckDigitPositions(lines[0], positions: [14])
+            lines[1] = correctDigitPositions(lines[1], ranges: [0...5, 8...13])
+            lines[1] = correctCheckDigitPositions(lines[1], positions: [6, 14, 29])
+            lines[1] = correctLetterPositions(lines[1], ranges: [7...7, 15...17])
+            lines[2] = correctLetterPositions(lines[2], ranges: [0...29])
+        case .TD2:
+            lines[0] = correctLetterPositions(lines[0], ranges: [0...1, 2...4, 5...35])
+            lines[1] = correctDigitPositions(lines[1], ranges: [13...18, 21...26])
+            lines[1] = correctCheckDigitPositions(lines[1], positions: [9, 19, 27, 35])
+            lines[1] = correctLetterPositions(lines[1], ranges: [10...12, 20...20])
+        case .TD3:
+            lines[0] = correctLetterPositions(lines[0], ranges: [0...1, 2...4, 5...43])
+            lines[1] = correctDigitPositions(lines[1], ranges: [13...18, 21...26])
+            lines[1] = correctCheckDigitPositions(lines[1], positions: [9, 19, 27, 42])
+            lines[1] = correctLetterPositions(lines[1], ranges: [10...12, 20...20])
+        case .UNKNOWN: break
+        }
+        return lines.joined(separator: "\n")
+    }
+
+    private func correctDigitPositions(_ line: String, ranges: [ClosedRange<Int>]) -> String {
+        var c = Array(line)
+        ranges.forEach { r in r.forEach { i in
+            if i < c.count {
+                switch c[i] {
+                case "O", "o": c[i] = "0"
+                case "I", "l": c[i] = "1"
+                case "Z": c[i] = "2"
+                case "S": c[i] = "5"
+                case "G": c[i] = "6"
+                case "B": c[i] = "8"
+                case "D", "Q": c[i] = "0"
+                default: break
+                }
+            }
+        }}
+        return String(c)
+    }
+
+    private func correctLetterPositions(_ line: String, ranges: [ClosedRange<Int>]) -> String {
+        var c = Array(line)
+        ranges.forEach { r in r.forEach { i in
+            if i < c.count {
+                switch c[i] {
+                case "0": c[i] = "O"
+                case "1": c[i] = "I"
+                case "5": c[i] = "S"
+                case "8": c[i] = "B"
+                case "2": c[i] = "Z"
+                case "6": c[i] = "G"
+                default: break
+                }
+            }
+        }}
+        return String(c)
+    }
+
+    private func correctCheckDigitPositions(_ line: String, positions: [Int]) -> String {
+        var c = Array(line)
+        positions.forEach { i in
+            if i < c.count {
+                switch c[i] {
+                case "O", "o": c[i] = "0"
+                case "I", "l": c[i] = "1"
+                case "Z": c[i] = "2"
+                case "S": c[i] = "5"
+                case "G": c[i] = "6"
+                case "B": c[i] = "8"
+                default: break
+                }
+            }
+        }
+        return String(c)
+    }
+
+    private func generateO0Permutations(_ mrzText: String, maxPermutations: Int = 100) -> [String] {
+        var permutations = Set<String>([mrzText])
+        let positions = Array(mrzText.enumerated().compactMap { (i, c) in
+            (c == "O" || c == "o" || c == "0") ? i : nil
+        }.prefix(7))
+        let limit = min(1 << positions.count, maxPermutations)
+        for i in 0..<limit {
+            var variant = Array(mrzText)
+            for (j, pos) in positions.enumerated() {
+                let useZero = (i & (1 << j)) != 0
+                if useZero && variant[pos] != "0" { variant[pos] = "0" }
+                else if !useZero && variant[pos] != "O" { variant[pos] = "O" }
+            }
+            permutations.insert(String(variant))
+        }
+        return Array(permutations)
+    }
+
+    private func generatePairPermutations(_ mrzText: String, letter: Character, digit: Character, maxPermutations: Int = 30) -> [String] {
+        var permutations = Set<String>([mrzText])
+        let positions = Array(mrzText.enumerated().compactMap { (i, c) in
+            (c == letter || c == Character(letter.lowercased()) || c == digit) ? i : nil
+        }.prefix(5))
+        let limit = min(1 << positions.count, maxPermutations)
+        for i in 0..<limit {
+            var variant = Array(mrzText)
+            for (j, pos) in positions.enumerated() {
+                let useDigit = (i & (1 << j)) != 0
+                if useDigit && variant[pos] != digit { variant[pos] = digit }
+                else if !useDigit && variant[pos] != letter { variant[pos] = letter }
+            }
+            permutations.insert(String(variant))
+        }
+        return Array(permutations)
+    }
+
+    private func generateI1Permutations(_ mrzText: String, maxPermutations: Int = 50) -> [String] {
+        var permutations = Set<String>([mrzText])
+        let positions = Array(mrzText.enumerated().compactMap { (i, c) in
+            (c == "I" || c == "i" || c == "l" || c == "1") ? i : nil
+        }.prefix(6))
+        let limit = min(1 << positions.count, maxPermutations)
+        for i in 0..<limit {
+            var variant = Array(mrzText)
+            for (j, pos) in positions.enumerated() {
+                let useOne = (i & (1 << j)) != 0
+                if useOne && variant[pos] != "1" { variant[pos] = "1" }
+                else if !useOne && (variant[pos] == "1" || variant[pos] == "l" || variant[pos] == "i") { variant[pos] = "I" }
+            }
+            permutations.insert(String(variant))
+        }
+        return Array(permutations)
+    }
+}

package/ios/OpenCV/OpenCVModule.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+
+@interface OpenCVModule : NSObject <RCTBridgeModule>
+@end