@trustchex/react-native-sdk 1.354.1 → 1.357.0

package/ios/MLKit/MLKitModule.m

@@ -0,0 +1,23 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(MLKitModule, NSObject)
+
+RCT_EXTERN_METHOD(recognizeText:(NSString *)base64Image
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(detectFaces:(NSString *)base64Image
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(scanBarcodes:(NSString *)base64Image
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(calculateBlur:(NSString *)yPlaneBase64
+                  width:(nonnull NSNumber *)width
+                  height:(nonnull NSNumber *)height
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/MLKit/MLKitModule.swift

@@ -0,0 +1,250 @@
+import Foundation
+import React
+import MLKitTextRecognition
+import MLKitFaceDetection
+import MLKitBarcodeScanning
+import MLKitVision
+
+@objc(MLKitModule)
+class MLKitModule: NSObject {
+
+    private let textRecognizer = TextRecognizer.textRecognizer()
+    private lazy var faceDetector: FaceDetector = {
+        let options = FaceDetectorOptions()
+        options.performanceMode = .accurate
+        options.landmarkMode = .none
+        options.classificationMode = .all
+        options.minFaceSize = 0.1
+        options.isTrackingEnabled = true
+        return FaceDetector.faceDetector(options: options)
+    }()
+    private lazy var barcodeScanner: BarcodeScanner = {
+        let formats: BarcodeFormat = [.PDF417, .qrCode]
+        let options = BarcodeScannerOptions(formats: formats)
+        return BarcodeScanner.barcodeScanner(options: options)
+    }()
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    @objc
+    func recognizeText(_ base64Image: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        guard let image = base64ToVisionImage(base64Image) else {
+            rejecter("INVALID_IMAGE", "Failed to decode base64 image", nil)
+            return
+        }
+
+        textRecognizer.process(image) { result, error in
+            if let error = error {
+                rejecter("TEXT_RECOGNITION_ERROR", error.localizedDescription, error)
+                return
+            }
+
+            guard let result = result else {
+                resolver([])
+                return
+            }
+
+            var blocks: [[String: Any]] = []
+
+            for block in result.blocks {
+                var blockMap: [String: Any] = [
+                    "text": block.text
+                ]
+
+                let frame = block.frame
+                blockMap["boundingBox"] = [
+                    "left": Int(frame.minX),
+                    "top": Int(frame.minY),
+                    "right": Int(frame.maxX),
+                    "bottom": Int(frame.maxY)
+                ]
+
+                var cornerPoints: [[String: Int]] = []
+                for point in block.cornerPoints ?? [] {
+                    let cgPoint = point.cgPointValue
+                    cornerPoints.append([
+                        "x": Int(cgPoint.x),
+                        "y": Int(cgPoint.y)
+                    ])
+                }
+                blockMap["cornerPoints"] = cornerPoints
+
+                blocks.append(blockMap)
+            }
+
+            resolver(blocks)
+        }
+    }
+
+    @objc
+    func detectFaces(_ base64Image: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        guard let image = base64ToVisionImage(base64Image) else {
+            rejecter("INVALID_IMAGE", "Failed to decode base64 image", nil)
+            return
+        }
+
+        faceDetector.process(image) { faces, error in
+            if let error = error {
+                rejecter("FACE_DETECTION_ERROR", error.localizedDescription, error)
+                return
+            }
+
+            guard let faces = faces, !faces.isEmpty else {
+                resolver([])
+                return
+            }
+
+            var facesArray: [[String: Any]] = []
+
+            for face in faces {
+                var faceMap: [String: Any] = [:]
+
+                let frame = face.frame
+                faceMap["boundingBox"] = [
+                    "left": Int(frame.minX),
+                    "top": Int(frame.minY),
+                    "right": Int(frame.maxX),
+                    "bottom": Int(frame.maxY),
+                    "width": Int(frame.width),
+                    "height": Int(frame.height)
+                ]
+
+                if face.hasHeadEulerAngleY {
+                    faceMap["headEulerAngleY"] = face.headEulerAngleY
+                }
+
+                if face.hasHeadEulerAngleZ {
+                    faceMap["headEulerAngleZ"] = face.headEulerAngleZ
+                }
+
+                if face.hasTrackingID {
+                    faceMap["trackingId"] = face.trackingID
+                }
+
+                facesArray.append(faceMap)
+            }
+
+            resolver(facesArray)
+        }
+    }
+
+    @objc
+    func scanBarcodes(_ base64Image: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        guard let image = base64ToVisionImage(base64Image) else {
+            rejecter("INVALID_IMAGE", "Failed to decode base64 image", nil)
+            return
+        }
+
+        barcodeScanner.process(image) { barcodes, error in
+            if let error = error {
+                rejecter("BARCODE_SCANNING_ERROR", error.localizedDescription, error)
+                return
+            }
+
+            guard let barcodes = barcodes, !barcodes.isEmpty else {
+                resolver([])
+                return
+            }
+
+            var barcodesArray: [[String: Any]] = []
+
+            for barcode in barcodes {
+                var barcodeMap: [String: Any] = [:]
+
+                if let rawValue = barcode.rawValue {
+                    barcodeMap["rawValue"] = rawValue
+                }
+
+                if let displayValue = barcode.displayValue {
+                    barcodeMap["displayValue"] = displayValue
+                }
+
+                barcodeMap["format"] = barcode.format.rawValue
+
+                let frame = barcode.frame
+                barcodeMap["boundingBox"] = [
+                    "left": Int(frame.minX),
+                    "top": Int(frame.minY),
+                    "right": Int(frame.maxX),
+                    "bottom": Int(frame.maxY)
+                ]
+
+                var cornerPoints: [[String: Int]] = []
+                for point in barcode.cornerPoints ?? [] {
+                    let cgPoint = point.cgPointValue
+                    cornerPoints.append([
+                        "x": Int(cgPoint.x),
+                        "y": Int(cgPoint.y)
+                    ])
+                }
+                barcodeMap["cornerPoints"] = cornerPoints
+
+                barcodesArray.append(barcodeMap)
+            }
+
+            resolver(barcodesArray)
+        }
+    }
+
+    @objc
+    func calculateBlur(_ yPlaneBase64: String, width: NSNumber, height: NSNumber, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        guard let yPlaneData = Data(base64Encoded: yPlaneBase64) else {
+            rejecter("INVALID_DATA", "Failed to decode Y plane data", nil)
+            return
+        }
+
+        let w = width.intValue
+        let h = height.intValue
+
+        // Laplacian variance for blur detection (matches Flutter implementation)
+        var sum: Double = 0
+        var sumSq: Double = 0
+        var count = 0
+
+        yPlaneData.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in
+            guard let baseAddress = buffer.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                return
+            }
+
+            // Apply Laplacian kernel (simplified 3x3)
+            for y in stride(from: 1, to: h - 1, by: 4) { // Sample every 4th row for performance
+                for x in stride(from: 1, to: w - 1, by: 4) { // Sample every 4th column
+                    let idx = y * w + x
+                    guard idx + w + 1 < yPlaneData.count && idx - w - 1 >= 0 else { continue }
+
+                    let center = Double(baseAddress[idx])
+                    let top = Double(baseAddress[idx - w])
+                    let bottom = Double(baseAddress[idx + w])
+                    let left = Double(baseAddress[idx - 1])
+                    let right = Double(baseAddress[idx + 1])
+
+                    // Laplacian: 4*center - (top + bottom + left + right)
+                    let laplacian = 4 * center - (top + bottom + left + right)
+
+                    sum += laplacian
+                    sumSq += laplacian * laplacian
+                    count += 1
+                }
+            }
+        }
+
+        if count > 0 {
+            let mean = sum / Double(count)
+            let variance = (sumSq / Double(count)) - (mean * mean)
+            resolver(variance)
+        } else {
+            resolver(0.0)
+        }
+    }
+
+    private func base64ToVisionImage(_ base64: String) -> VisionImage? {
+        guard let imageData = Data(base64Encoded: base64),
+              let uiImage = UIImage(data: imageData) else {
+            return nil
+        }
+        return VisionImage(image: uiImage)
+    }
+}

package/ios/MRZValidation.m

@@ -0,0 +1,39 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(MRZValidation, NSObject)
+
+/**
+ * Primary MRZ validation with OCR corrections and composite checksum brute-force
+ * This is the main entry point for fast native processing
+ */
+RCT_EXTERN_METHOD(validateMRZWithCorrections:(NSString *)ocrText
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+/**
+ * Validates MRZ text and returns parse result with checksum validation
+ */
+RCT_EXTERN_METHOD(validateMRZ:(NSString *)mrzText
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+/**
+ * Calculates checksum for MRZ field using 7-3-1 algorithm
+ */
+RCT_EXTERN_METHOD(calculateChecksum:(NSString *)data
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+/**
+ * Fixes common OCR errors in MRZ text
+ */
+RCT_EXTERN_METHOD(fixMRZText:(NSString *)mrzText
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end