@trustchex/react-native-sdk 1.361.0 → 1.362.1

package/ios/MRZValidator.swift

@@ -1,466 +0,0 @@
-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)
-    }
-}