@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/facedetector/FaceDetectorFrameProcessorPlugin.kt

@@ -1,303 +0,0 @@
-package com.trustchex.reactnativesdk.visioncameraplugins.facedetector
-
-import android.graphics.Rect
-import android.util.Log
-import com.google.android.gms.tasks.Tasks
-import com.google.mlkit.vision.common.InputImage
-import com.google.mlkit.vision.face.*
-import com.mrousavy.camera.core.FrameInvalidError
-import com.mrousavy.camera.core.types.Orientation
-import com.mrousavy.camera.frameprocessors.Frame
-import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
-
-class FaceDetectorFrameProcessorPlugin(options: Map<String, Any>?) :
-        FrameProcessorPlugin() {
-
-  // Detection properties
-  private var autoScale = false
-  private var faceDetector: FaceDetector? = null
-  private var runLandmarks = false
-  private var runClassifications = false
-  private var runContours = false
-  private var trackingEnabled = false
-  private var windowWidth = 1.0
-  private var windowHeight = 1.0
-
-  init {
-    // Handle auto scaling and window dimensions
-    autoScale = options?.get("autoScale").toString() == "true"
-    windowWidth = (options?.get("windowWidth") ?: 1.0) as Double
-    windowHeight = (options?.get("windowHeight") ?: 1.0) as Double
-
-    // Initialize faceDetector on creation
-    var performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_FAST
-    var landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_NONE
-    var classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_NONE
-    var contourModeValue = FaceDetectorOptions.CONTOUR_MODE_NONE
-
-    if (options?.get("performanceMode").toString() == "accurate") {
-      performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE
-    }
-
-    if (options?.get("landmarkMode").toString() == "all") {
-      runLandmarks = true
-      landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_ALL
-    }
-
-    if (options?.get("classificationMode").toString() == "all") {
-      runClassifications = true
-      classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_ALL
-    }
-
-    if (options?.get("contourMode").toString() == "all") {
-      runContours = true
-      contourModeValue = FaceDetectorOptions.CONTOUR_MODE_ALL
-    }
-
-    val minFaceSize: Double = (options?.get("minFaceSize") ?: 0.15) as Double
-    val optionsBuilder = FaceDetectorOptions.Builder()
-      .setPerformanceMode(performanceModeValue)
-      .setLandmarkMode(landmarkModeValue)
-      .setContourMode(contourModeValue)
-      .setClassificationMode(classificationModeValue)
-      .setMinFaceSize(minFaceSize.toFloat())
-
-    if (options?.get("trackingEnabled").toString() == "true") {
-      trackingEnabled = true
-      optionsBuilder.enableTracking()
-    }
-
-    faceDetector = FaceDetection.getClient(optionsBuilder.build())
-  }
-
-  override fun callback(frame: Frame, params: Map<String, Any>?): Any {
-    val result = ArrayList<Map<String, Any>>()
-
-    try {
-      val orientation = getOrientation(frame.orientation)
-      val image = InputImage.fromMediaImage(frame.image, orientation)
-      // We need to invert sizes as frame is always -90deg rotated
-      val width = image.height.toDouble()
-      val height = image.width.toDouble()
-      val scaleX = if(autoScale) windowWidth / width else 1.0
-      val scaleY = if(autoScale) windowHeight / height else 1.0
-
-      val task = faceDetector!!.process(image)
-      val faces = Tasks.await(task)
-
-      Log.d(TAG, "Detected ${faces.size} faces")
-
-      faces.forEach { face ->
-        val map: MutableMap<String, Any> = HashMap()
-
-        if (runLandmarks) {
-          map["landmarks"] = processLandmarks(face, scaleX, scaleY)
-        }
-
-        if (runClassifications) {
-          map["leftEyeOpenProbability"] = face.leftEyeOpenProbability?.toDouble() ?: -1
-          map["rightEyeOpenProbability"] = face.rightEyeOpenProbability?.toDouble() ?: -1
-          map["smilingProbability"] = face.smilingProbability?.toDouble() ?: -1
-        }
-
-        if (runContours) {
-          map["contours"] = processFaceContours(face, scaleX, scaleY)
-        }
-
-        if (trackingEnabled) {
-          map["trackingId"] = face.trackingId ?: -1
-        }
-
-        map["rollAngle"] = face.headEulerAngleZ.toDouble()
-        map["pitchAngle"] = face.headEulerAngleX.toDouble()
-        map["yawAngle"] = face.headEulerAngleY.toDouble()
-        map["bounds"] = processBoundingBox(
-          face.boundingBox,
-          width,
-          height,
-          frame.orientation,
-          scaleX,
-          scaleY
-        )
-        result.add(map)
-      }
-    } catch (e: Exception) {
-      Log.e(TAG, "Error processing face detection: ", e)
-    } catch (e: FrameInvalidError) {
-      Log.e(TAG, "Frame invalid error: ", e)
-    }
-
-    return result
-  }
-
-  private fun processBoundingBox(
-    boundingBox: Rect,
-    sourceWidth: Double,
-    sourceHeight: Double,
-    orientation: Orientation,
-    scaleX: Double,
-    scaleY: Double
-  ): Map<String, Any> {
-    val bounds: MutableMap<String, Any> = HashMap()
-    val width = boundingBox.width().toDouble() * scaleX
-    val height = boundingBox.height().toDouble() * scaleY
-    val x = boundingBox.left.toDouble() * scaleX
-    val y = boundingBox.top.toDouble() * scaleY
-
-    when(orientation) {
-      Orientation.PORTRAIT -> {
-        // device is landscape left
-        bounds["x"] = (-y + sourceWidth * scaleX) - width
-        bounds["y"] = (-x + sourceHeight * scaleY) - height
-      }
-      Orientation.LANDSCAPE_LEFT -> {
-        // device is portrait
-        bounds["x"] = (-x + sourceWidth * scaleX) - width
-        bounds["y"] = y
-      }
-      Orientation.PORTRAIT_UPSIDE_DOWN -> {
-        // device is landscape right
-        bounds["x"] = y
-        bounds["y"] = x
-      }
-      Orientation.LANDSCAPE_RIGHT -> {
-        // device is upside down
-        bounds["x"] = x
-        bounds["y"] = (-y + sourceHeight * scaleY) - height
-      }
-    }
-
-    bounds["width"] = width
-    bounds["height"] = height
-    return bounds
-  }
-
-  private fun processLandmarks(
-    face: Face,
-    scaleX: Double,
-    scaleY: Double
-  ): Map<String, Any> {
-    val faceLandmarksTypes = intArrayOf(
-      FaceLandmark.LEFT_CHEEK,
-      FaceLandmark.LEFT_EAR,
-      FaceLandmark.LEFT_EYE,
-      FaceLandmark.MOUTH_BOTTOM,
-      FaceLandmark.MOUTH_LEFT,
-      FaceLandmark.MOUTH_RIGHT,
-      FaceLandmark.NOSE_BASE,
-      FaceLandmark.RIGHT_CHEEK,
-      FaceLandmark.RIGHT_EAR,
-      FaceLandmark.RIGHT_EYE
-    )
-    val faceLandmarksTypesStrings = arrayOf(
-      "LEFT_CHEEK",
-      "LEFT_EAR",
-      "LEFT_EYE",
-      "MOUTH_BOTTOM",
-      "MOUTH_LEFT",
-      "MOUTH_RIGHT",
-      "NOSE_BASE",
-      "RIGHT_CHEEK",
-      "RIGHT_EAR",
-      "RIGHT_EYE"
-    )
-    val faceLandmarksTypesMap: MutableMap<String, Any> = HashMap()
-    for (i in faceLandmarksTypesStrings.indices) {
-      val landmark = face.getLandmark(faceLandmarksTypes[i])
-      val landmarkName = faceLandmarksTypesStrings[i]
-      Log.d(TAG, "Getting '$landmarkName' landmark")
-      if (landmark == null) {
-        Log.d(TAG, "Landmark '$landmarkName' is null - going next")
-        continue
-      }
-      val point = landmark.position
-      val currentPointsMap: MutableMap<String, Double> = HashMap()
-      currentPointsMap["x"] = point.x.toDouble() * scaleX
-      currentPointsMap["y"] = point.y.toDouble() * scaleY
-      faceLandmarksTypesMap[landmarkName] = currentPointsMap
-    }
-
-    return faceLandmarksTypesMap
-  }
-
-  private fun processFaceContours(
-    face: Face,
-    scaleX: Double,
-    scaleY: Double
-  ): Map<String, Any> {
-    val faceContoursTypes = intArrayOf(
-      FaceContour.FACE,
-      FaceContour.LEFT_CHEEK,
-      FaceContour.LEFT_EYE,
-      FaceContour.LEFT_EYEBROW_BOTTOM,
-      FaceContour.LEFT_EYEBROW_TOP,
-      FaceContour.LOWER_LIP_BOTTOM,
-      FaceContour.LOWER_LIP_TOP,
-      FaceContour.NOSE_BOTTOM,
-      FaceContour.NOSE_BRIDGE,
-      FaceContour.RIGHT_CHEEK,
-      FaceContour.RIGHT_EYE,
-      FaceContour.RIGHT_EYEBROW_BOTTOM,
-      FaceContour.RIGHT_EYEBROW_TOP,
-      FaceContour.UPPER_LIP_BOTTOM,
-      FaceContour.UPPER_LIP_TOP
-    )
-    val faceContoursTypesStrings = arrayOf(
-      "FACE",
-      "LEFT_CHEEK",
-      "LEFT_EYE",
-      "LEFT_EYEBROW_BOTTOM",
-      "LEFT_EYEBROW_TOP",
-      "LOWER_LIP_BOTTOM",
-      "LOWER_LIP_TOP",
-      "NOSE_BOTTOM",
-      "NOSE_BRIDGE",
-      "RIGHT_CHEEK",
-      "RIGHT_EYE",
-      "RIGHT_EYEBROW_BOTTOM",
-      "RIGHT_EYEBROW_TOP",
-      "UPPER_LIP_BOTTOM",
-      "UPPER_LIP_TOP"
-    )
-    val faceContoursTypesMap: MutableMap<String, Any> = HashMap()
-    for (i in faceContoursTypesStrings.indices) {
-      val contour = face.getContour(faceContoursTypes[i])
-      val contourName = faceContoursTypesStrings[i]
-      Log.d(TAG, "Getting '$contourName' contour")
-      if (contour == null) {
-        Log.d(TAG, "Face contour '$contourName' is null - going next")
-        continue
-      }
-      val points = contour.points
-      val pointsMap: MutableMap<String, Map<String, Double>> = HashMap()
-      for (j in points.indices) {
-        val currentPointsMap: MutableMap<String, Double> = HashMap()
-        currentPointsMap["x"] = points[j].x.toDouble() * scaleX
-        currentPointsMap["y"] = points[j].y.toDouble() * scaleY
-        pointsMap[j.toString()] = currentPointsMap
-      }
-
-      faceContoursTypesMap[contourName] = pointsMap
-    }
-    return faceContoursTypesMap
-  }
-
-  private fun getOrientation(
-    orientation: Orientation
-  ): Int {
-    return when (orientation) {
-      // device is landscape left
-      Orientation.PORTRAIT -> 0
-      // device is portrait
-      Orientation.LANDSCAPE_LEFT -> 270
-      // device is landscape right
-      Orientation.PORTRAIT_UPSIDE_DOWN -> 180
-      // device is upside-down
-      Orientation.LANDSCAPE_RIGHT -> 90
-    }
-  }
-
-  companion object {
-    private const val TAG = "FaceDetectorFrameProcessorPlugin"
-  }
-}

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/textrecognition/TextRecognitionFrameProcessorPlugin.kt

@@ -1,115 +0,0 @@
-package com.trustchex.reactnativesdk.visioncameraplugins.textrecognition
-
-import android.graphics.Point
-import android.graphics.Rect
-import android.media.Image
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
-import com.google.android.gms.tasks.Task
-import com.google.android.gms.tasks.Tasks
-import com.google.mlkit.vision.common.InputImage
-import com.google.mlkit.vision.text.Text
-import com.google.mlkit.vision.text.TextRecognition
-import com.google.mlkit.vision.text.latin.TextRecognizerOptions
-import com.mrousavy.camera.frameprocessors.Frame
-import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
-import com.mrousavy.camera.frameprocessors.VisionCameraProxy
-import java.util.HashMap
-
-class TextRecognitionFrameProcessorPlugin(proxy: VisionCameraProxy, options: Map<String, Any>?) :
-    FrameProcessorPlugin() {
-
-    private var recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
-
-    override fun callback(frame: Frame, arguments: Map<String, Any>?): HashMap<String, Any?>? {
-        val data = WritableNativeMap()
-        val mediaImage: Image = frame.image
-        val image =
-            InputImage.fromMediaImage(mediaImage, frame.imageProxy.imageInfo.rotationDegrees)
-        val task: Task<Text> = recognizer.process(image)
-        try {
-            val text: Text = Tasks.await(task)
-            if (text.text.isEmpty()) {
-                return WritableNativeMap().toHashMap()
-            }
-            data.putString("resultText", text.text)
-            data.putArray("blocks", getBlocks(text.textBlocks))
-            return data.toHashMap()
-        } catch (e: Exception) {
-            e.printStackTrace()
-            return null
-        }
-    }
-
-    companion object {
-        fun getBlocks(blocks: MutableList<Text.TextBlock>): WritableNativeArray {
-            val blockArray = WritableNativeArray()
-            blocks.forEach { block ->
-                val blockMap = WritableNativeMap().apply {
-                    putString("blockText", block.text)
-                    putArray("blockCornerPoints", block.cornerPoints?.let { getCornerPoints(it) })
-                    putMap("blockFrame", getFrame(block.boundingBox))
-                    putArray("lines", getLines(block.lines))
-                }
-                blockArray.pushMap(blockMap)
-            }
-            return blockArray
-        }
-
-        private fun getLines(lines: MutableList<Text.Line>): WritableNativeArray {
-            val lineArray = WritableNativeArray()
-            lines.forEach { line ->
-                val lineMap = WritableNativeMap().apply {
-                    putString("lineText", line.text)
-                    putArray("lineCornerPoints", line.cornerPoints?.let { getCornerPoints(it) })
-                    putMap("lineFrame", getFrame(line.boundingBox))
-                    putArray(
-                        "lineLanguages",
-                        WritableNativeArray().apply { pushString(line.recognizedLanguage) })
-                    putArray("elements", getElements(line.elements))
-                }
-                lineArray.pushMap(lineMap)
-            }
-            return lineArray
-        }
-
-        private fun getElements(elements: MutableList<Text.Element>): WritableNativeArray {
-            val elementArray = WritableNativeArray()
-            elements.forEach { element ->
-                val elementMap = WritableNativeMap().apply {
-                    putString("elementText", element.text)
-                    putArray(
-                        "elementCornerPoints",
-                        element.cornerPoints?.let { getCornerPoints(it) })
-                    putMap("elementFrame", getFrame(element.boundingBox))
-                }
-                elementArray.pushMap(elementMap)
-            }
-            return elementArray
-        }
-
-        private fun getCornerPoints(points: Array<Point>): WritableNativeArray {
-            val cornerPoints = WritableNativeArray()
-            points.forEach { point ->
-                cornerPoints.pushMap(WritableNativeMap().apply {
-                    putInt("x", point.x)
-                    putInt("y", point.y)
-                })
-            }
-            return cornerPoints
-        }
-
-        private fun getFrame(boundingBox: Rect?): WritableNativeMap {
-            return WritableNativeMap().apply {
-                boundingBox?.let {
-                    putDouble("x", it.exactCenterX().toDouble())
-                    putDouble("y", it.exactCenterY().toDouble())
-                    putInt("width", it.width())
-                    putInt("height", it.height())
-                    putInt("boundingCenterX", it.centerX())
-                    putInt("boundingCenterY", it.centerY())
-                }
-            }
-        }
-    }
-}

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin-Bridging-Header.h

@@ -1,9 +0,0 @@
-#ifndef BarcodeScannerFrameProcessorPlugin_Bridging_Header_h
-#define BarcodeScannerFrameProcessorPlugin_Bridging_Header_h
-
-#if VISION_CAMERA_ENABLE_FRAME_PROCESSORS
-#import <VisionCamera/FrameProcessorPlugin.h>
-#import <VisionCamera/Frame.h>
-#endif
-
-#endif /* BarcodeScannerFrameProcessorPlugin_Bridging_Header_h */

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin.mm

@@ -1,22 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <VisionCamera/FrameProcessorPlugin.h>
-#import <VisionCamera/FrameProcessorPluginRegistry.h>
-#import <VisionCamera/Frame.h>
-
-#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
-#import "TrustchexSDK/TrustchexSDK-Swift.h"
-#else
-#import "TrustchexSDK-Swift.h"
-#endif
-
-@interface BarcodeScannerFrameProcessorPlugin (FrameProcessorPluginLoader)
-@end
-
-@implementation BarcodeScannerFrameProcessorPlugin (FrameProcessorPluginLoader)
-+ (void)load {
-  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"scanCodes"
-                                        withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
-    return [[BarcodeScannerFrameProcessorPlugin alloc] initWithProxy:proxy withOptions:options];
-  }];
-}
-@end

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin.swift

@@ -1,188 +0,0 @@
-import Foundation
-import Vision
-import VisionCamera
-
-@objc(BarcodeScannerFrameProcessorPlugin)
-public class BarcodeScannerFrameProcessorPlugin: FrameProcessorPlugin {
-
-  public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
-    super.init(proxy: proxy, options: options)
-    print(
-      "BarcodeScannerFrameProcessorPlugin: Initialized with options: \(String(describing: options))"
-    )
-  }
-
-  public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?)
-    -> Any?
-  {
-    print("BarcodeScannerFrameProcessorPlugin: callback called")
-
-    // Get the pixel buffer from the frame
-    guard let imageBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
-      print("BarcodeScannerFrameProcessorPlugin: Could not get pixel buffer from frame")
-      return []
-    }
-
-    // Parse barcode types from arguments (default to QR codes)
-    var symbologies: [VNBarcodeSymbology] = [.qr]
-
-    if let arguments = arguments,
-      let barcodeTypes = arguments["barcodeTypes"] as? [String]
-    {
-      symbologies = barcodeTypes.compactMap { type in
-        switch type {
-        case "aztec": return .aztec
-        case "codabar": return .codabar
-        case "code-128": return .code128
-        case "code-39": return .code39
-        case "code-93": return .code93
-        case "data-matrix": return .dataMatrix
-        case "ean-13": return .ean13
-        case "ean-8": return .ean8
-        case "itf": return .i2of5
-        case "pdf-417": return .pdf417
-        case "qr": return .qr
-        case "upc-a": return .ean13  // UPC-A is subset of EAN-13
-        case "upc-e": return .upce
-        default: return nil
-        }
-      }
-    }
-
-    // Use semaphore to make async Vision calls synchronous for frame processor
-    let semaphore = DispatchSemaphore(value: 0)
-    var detectedBarcodes: [VNBarcodeObservation] = []
-    var visionError: Error? = nil
-
-    // Create Vision request handler
-    let handler = VNImageRequestHandler(cvPixelBuffer: imageBuffer, options: [:])
-
-    // Create barcode detection request
-    let request = VNDetectBarcodesRequest { (request, error) in
-      defer { semaphore.signal() }
-
-      if let error = error {
-        print("BarcodeScannerFrameProcessorPlugin: Vision error: \(error.localizedDescription)")
-        visionError = error
-        return
-      }
-
-      detectedBarcodes = request.results as? [VNBarcodeObservation] ?? []
-      print("BarcodeScannerFrameProcessorPlugin: Detected \(detectedBarcodes.count) barcodes")
-    }
-
-    // Set symbologies
-    request.symbologies = symbologies
-
-    // Perform the request
-    do {
-      try handler.perform([request])
-    } catch {
-      print(
-        "BarcodeScannerFrameProcessorPlugin: Error performing Vision request: \(error.localizedDescription)"
-      )
-      return []
-    }
-
-    // Wait for completion with timeout
-    let waitResult = semaphore.wait(timeout: .now() + 0.1)  // 100ms timeout
-    if waitResult == .timedOut {
-      print("BarcodeScannerFrameProcessorPlugin: Vision request timed out")
-      return []
-    }
-
-    // Check for errors
-    if let error = visionError {
-      print(
-        "BarcodeScannerFrameProcessorPlugin: Vision processing failed: \(error.localizedDescription)"
-      )
-      return []
-    }
-
-    // Convert results to pixel coordinates at iOS level
-    let result = detectedBarcodes.compactMap { barcode -> [String: Any]? in
-      guard let barcodeValue = barcode.payloadStringValue, !barcodeValue.isEmpty else {
-        return nil
-      }
-
-      print("BarcodeScannerFrameProcessorPlugin: Processing barcode: \(barcodeValue)")
-
-      var map: [String: Any] = [:]
-
-      // Main value that TypeScript interface expects
-      map["value"] = barcodeValue
-
-      // Convert from normalized (0-1) coordinates to pixel coordinates
-      let frameWidth = frame.width
-      let frameHeight = frame.height
-      let boundingBox = barcode.boundingBox
-
-      // Convert from normalized (0-1) with bottom-left origin to pixel coordinates with top-left origin
-      let left = boundingBox.origin.x * CGFloat(frameWidth)
-      let bottom = boundingBox.origin.y * CGFloat(frameHeight)
-      let width = boundingBox.size.width * CGFloat(frameWidth)
-      let height = boundingBox.size.height * CGFloat(frameHeight)
-      let top = CGFloat(frameHeight) - bottom - height  // Flip Y coordinate from bottom-left to top-left
-
-      // Create bounding box in pixel coordinates with top-left origin
-      map["boundingBox"] = [
-        "origin": [
-          "x": Int(left),
-          "y": Int(top),
-        ],
-        "size": [
-          "width": Int(width),
-          "height": Int(height),
-        ],
-      ]
-
-      // Convert corner points to pixel coordinates with top-left origin
-      let cornerPoints = [
-        [
-          "x": Int(barcode.topLeft.x * CGFloat(frameWidth)),
-          "y": Int((1.0 - barcode.topLeft.y) * CGFloat(frameHeight)),
-        ],
-        [
-          "x": Int(barcode.topRight.x * CGFloat(frameWidth)),
-          "y": Int((1.0 - barcode.topRight.y) * CGFloat(frameHeight)),
-        ],
-        [
-          "x": Int(barcode.bottomRight.x * CGFloat(frameWidth)),
-          "y": Int((1.0 - barcode.bottomRight.y) * CGFloat(frameHeight)),
-        ],
-        [
-          "x": Int(barcode.bottomLeft.x * CGFloat(frameWidth)),
-          "y": Int((1.0 - barcode.bottomLeft.y) * CGFloat(frameHeight)),
-        ],
-      ]
-      map["cornerPoints"] = cornerPoints
-
-      // Map barcode symbology to TypeScript BarcodeType strings
-      let typeString: String
-      switch barcode.symbology {
-      case .aztec: typeString = "aztec"
-      case .codabar: typeString = "codabar"
-      case .code128: typeString = "code-128"
-      case .code39: typeString = "code-39"
-      case .code93: typeString = "code-93"
-      case .dataMatrix: typeString = "data-matrix"
-      case .ean13: typeString = "ean-13"
-      case .ean8: typeString = "ean-8"
-      case .i2of5, .i2of5Checksum, .itf14: typeString = "itf"
-      case .pdf417: typeString = "pdf-417"
-      case .qr: typeString = "qr"
-      case .upce: typeString = "upc-e"
-      default: typeString = "unknown"
-      }
-      map["type"] = typeString
-
-      print(
-        "BarcodeScannerFrameProcessorPlugin: Converted barcode - value: \(barcodeValue), type: \(typeString), boundingBox: \(map["boundingBox"] ?? "nil")"
-      )
-      return map
-    }
-
-    print("BarcodeScannerFrameProcessorPlugin: Returning \(result.count) processed barcodes")
-    return result
-  }
-}

package/ios/VisionCameraPlugins/Cropper/Cropper-Bridging-Header.h

@@ -1,13 +0,0 @@
-//
-//  VisionCameraCropper-Bridging-Header.h
-//  TrustchexSDK
-//
-
-#ifndef VisionCameraCropper_Bridging_Header_h
-#define VisionCameraCropper_Bridging_Header_h
-
-#import <React/RCTBridgeModule.h>
-#import <React/RCTLog.h>
-#import <React/RCTUtils.h>
-
-#endif /* VisionCameraCropper_Bridging_Header_h */

package/ios/VisionCameraPlugins/Cropper/Cropper.h

@@ -1,20 +0,0 @@
-//
-//  VisionCameraCropper.h
-//  TrustchexSDK
-//
-
-#ifndef VisionCameraCropper_h
-#define VisionCameraCropper_h
-
-#import <React/RCTBridgeModule.h>
-#import <UIKit/UIKit.h>
-
-@interface VisionCameraCropper : NSObject <RCTBridgeModule>
-
-+ (UIImage *)rotateImage:(UIImage *)image degree:(float)degree;
-+ (NSString *)getBase64FromImage:(UIImage *)image;
-+ (UIImage *)convertBase64ToImage:(NSString *)base64String;
-
-@end
-
-#endif /* VisionCameraCropper_h */

package/ios/VisionCameraPlugins/Cropper/Cropper.mm

@@ -1,22 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <VisionCamera/FrameProcessorPlugin.h>
-#import <VisionCamera/FrameProcessorPluginRegistry.h>
-#import <VisionCamera/Frame.h>
-
-#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
-#import "TrustchexSDK/TrustchexSDK-Swift.h"
-#else
-#import "TrustchexSDK-Swift.h"
-#endif
-
-@interface VisionCameraCropper (FrameProcessorPluginLoader)
-@end
-
-@implementation VisionCameraCropper (FrameProcessorPluginLoader)
-+ (void)load {
-  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"crop"
-                                        withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
-    return [[VisionCameraCropper alloc] initWithProxy:proxy withOptions:options];
-  }];
-}
-@end