@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/ios/VisionCameraPlugins/TextRecognition/TextRecognitionFrameProcessorPlugin.swift

@@ -1,144 +0,0 @@
-import Foundation
-import VisionCamera
-import MLKitVision
-import MLKitTextRecognition
-
-import Foundation
-import VisionCamera
-import MLKitVision
-import MLKitTextRecognition
-
-@objc(TextRecognitionFrameProcessorPlugin)
-public class TextRecognitionFrameProcessorPlugin: FrameProcessorPlugin {
-
-    private var textRecognizer = TextRecognizer()
-    private static let latinOptions = TextRecognizerOptions()
-    private var data: [String: Any] = [:]
-
-
-    public override init(proxy: VisionCameraProxyHolder, options: [AnyHashable: Any]! = [:]) {
-        super.init(proxy: proxy, options: options)
-        self.textRecognizer = TextRecognizer.textRecognizer(options: TextRecognitionFrameProcessorPlugin.latinOptions)
-    }
-
-
-    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any {
-        let buffer = frame.buffer
-        let image = VisionImage(buffer: buffer)
-        image.orientation = getOrientation(orientation: frame.orientation)
-
-        do {
-            let result = try self.textRecognizer.results(in: image)
-            let blocks = TextRecognitionFrameProcessorPlugin.processBlocks(blocks: result.blocks)
-            data["resultText"] = result.text
-            data["blocks"] = blocks
-            if result.text.isEmpty {
-                return [:]
-            }else{
-                return data
-            }
-        } catch {
-            print("Failed to recognize text: \(error.localizedDescription).")
-            return [:]
-        }
-    }
-
-      static func processBlocks(blocks:[TextBlock]) -> Array<Any> {
-        var blocksArray : [Any] = []
-        for block in blocks {
-            var blockData : [String:Any] = [:]
-            blockData["blockText"] = block.text
-            blockData["blockCornerPoints"] = processCornerPoints(block.cornerPoints)
-            blockData["blockFrame"] = processFrame(block.frame)
-            blockData["lines"] = processLines(lines: block.lines)
-            blocksArray.append(blockData)
-        }
-        return blocksArray
-    }
-
-    private static func processLines(lines:[TextLine]) -> Array<Any> {
-        var linesArray : [Any] = []
-        for line in lines {
-            var lineData : [String:Any] = [:]
-            lineData["lineText"] = line.text
-            lineData["lineLanguages"] = processRecognizedLanguages(line.recognizedLanguages)
-            lineData["lineCornerPoints"] = processCornerPoints(line.cornerPoints)
-            lineData["lineFrame"] = processFrame(line.frame)
-            lineData["elements"] = processElements(elements: line.elements)
-            linesArray.append(lineData)
-        }
-        return linesArray
-    }
-
-    private static func processElements(elements:[TextElement]) -> Array<Any> {
-        var elementsArray : [Any] = []
-
-        for element in elements {
-            var elementData : [String:Any] = [:]
-              elementData["elementText"] = element.text
-              elementData["elementCornerPoints"] = processCornerPoints(element.cornerPoints)
-              elementData["elementFrame"] = processFrame(element.frame)
-
-            elementsArray.append(elementData)
-          }
-
-        return elementsArray
-    }
-
-    private static func processRecognizedLanguages(_ languages: [TextRecognizedLanguage]) -> [String] {
-
-            var languageArray: [String] = []
-
-            for language in languages {
-                guard let code = language.languageCode else {
-                    print("No language code exists")
-                    break;
-                }
-                if code.isEmpty{
-                    languageArray.append("und")
-                }else {
-                    languageArray.append(code)
-
-                }
-            }
-
-            return languageArray
-        }
-
-    private static func processCornerPoints(_ cornerPoints: [NSValue]) -> [[String: CGFloat]] {
-        return cornerPoints.compactMap { $0.cgPointValue }.map { ["x": $0.x, "y": $0.y] }
-    }
-
-    private static func processFrame(_ frameRect: CGRect) -> [String: CGFloat] {
-        let offsetX = (frameRect.midX - ceil(frameRect.width)) / 2.0
-        let offsetY = (frameRect.midY - ceil(frameRect.height)) / 2.0
-
-        let x = frameRect.maxX + offsetX
-        let y = frameRect.minY + offsetY
-
-        return [
-            "x": frameRect.midX + (frameRect.midX - x),
-            "y": frameRect.midY + (y - frameRect.midY),
-            "width": frameRect.width,
-            "height": frameRect.height,
-            "boundingCenterX": frameRect.midX,
-            "boundingCenterY": frameRect.midY
-        ]
-    }
-
-    private func getOrientation(orientation: UIImage.Orientation) -> UIImage.Orientation {
-        switch orientation {
-        case .up:
-          return .up
-        case .left:
-          return .right
-        case .down:
-          return .down
-        case .right:
-          return .left
-        default:
-          return .up
-        }
-    }
-
-}

package/lib/module/Shared/Libs/camera.utils.js

@@ -1,308 +0,0 @@
-"use strict";
-
-/**
- * Check if frame is blurry using Laplacian variance
- * Uses both horizontal and vertical gradients for more accurate blur detection
- * Lower variance indicates a blurrier image
- * @param frame - The camera frame to analyze
- * @param threshold - Variance threshold below which image is considered blurry (default: 10)
- * @returns true if image is blurry, false otherwise
- */
-const isBlurry = (frame, threshold = 10) => {
-  'worklet';
-
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const width = frame.width;
-  const height = frame.height;
-  let sum = 0;
-  let sumSq = 0;
-  let count = 0;
-
-  // Sample central 50% region (matching Flutter algorithm)
-  const startY = Math.floor(height / 4);
-  const endY = Math.floor(3 * height / 4) - 1;
-  const startX = Math.floor(width / 4);
-  const endX = Math.floor(3 * width / 4) - 1;
-
-  // Sample at 5-pixel intervals for better accuracy (matching Flutter)
-  for (let y = startY; y < endY; y += 5) {
-    for (let x = startX; x < endX; x += 5) {
-      const idx = y * width + x;
-      const idxRight = idx + 1;
-      const idxDown = idx + width;
-
-      // Check bounds for both horizontal and vertical neighbors
-      if (idxRight < data.length && idxDown < data.length && data[idx] !== undefined && data[idxRight] !== undefined && data[idxDown] !== undefined) {
-        // Horizontal gradient
-        const diffH = Math.abs(data[idx] - data[idxRight]);
-        // Vertical gradient
-        const diffV = Math.abs(data[idx] - data[idxDown]);
-        // Combined Laplacian-like measure
-        const laplacian = diffH + diffV;
-        sum += laplacian;
-        sumSq += laplacian * laplacian;
-        count++;
-      }
-    }
-  }
-  if (count === 0) return false;
-
-  // Calculate variance: E[X²] - E[X]²
-  const mean = sum / count;
-  const variance = sumSq / count - mean * mean;
-  return variance < threshold;
-};
-
-/**
- * Get average brightness for entire frame (center area)
- */
-const getAverageBrightness = frame => {
-  'worklet';
-
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const width = frame.width;
-  const height = frame.height;
-  const centerX = Math.floor(width / 2);
-  const centerY = Math.floor(height / 2);
-  const halfSizeX = Math.floor(width / 2);
-  const halfSizeY = Math.floor(height / 2);
-  let luminanceSum = 0;
-  let pixelCount = 0;
-  for (let y = centerY - halfSizeY; y < centerY + halfSizeY; y++) {
-    for (let x = centerX - halfSizeX; x < centerX + halfSizeX; x++) {
-      const index = y * width + x;
-      if (data[index] !== undefined) {
-        luminanceSum += data[index];
-        pixelCount++;
-      }
-    }
-  }
-  return luminanceSum / pixelCount;
-};
-
-/**
- * Get average brightness for a specific circular region (for face detection)
- * Calculates brightness only for pixels inside the circle defined by centerX, centerY, and radius
- */
-const getCircularRegionBrightness = (frame, circleRect) => {
-  'worklet';
-
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const width = frame.width;
-  const height = frame.height;
-
-  // Calculate circle parameters from rect
-  const centerX = Math.floor(circleRect.minX + circleRect.width / 2);
-  const centerY = Math.floor(circleRect.minY + circleRect.height / 2);
-  const radius = Math.floor(Math.min(circleRect.width, circleRect.height) / 2);
-  let luminanceSum = 0;
-  let pixelCount = 0;
-
-  // Calculate bounding box for the circle to optimize iteration
-  const minX = Math.max(0, centerX - radius);
-  const maxX = Math.min(width - 1, centerX + radius);
-  const minY = Math.max(0, centerY - radius);
-  const maxY = Math.min(height - 1, centerY + radius);
-
-  // Iterate only over pixels in the bounding box
-  for (let y = minY; y <= maxY; y++) {
-    for (let x = minX; x <= maxX; x++) {
-      // Check if pixel is inside the circle
-      const dx = x - centerX;
-      const dy = y - centerY;
-      const distanceSquared = dx * dx + dy * dy;
-      if (distanceSquared <= radius * radius) {
-        const index = y * width + x;
-        if (data[index] !== undefined) {
-          luminanceSum += data[index];
-          pixelCount++;
-        }
-      }
-    }
-  }
-  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
-};
-const isFrameBright = frame => {
-  'worklet';
-
-  return getAverageBrightness(frame) > 60;
-};
-
-/**
- * Check if a circular region in the frame is bright enough
- */
-const isCircularRegionBright = (frame, circleRect, threshold = 60) => {
-  'worklet';
-
-  return getCircularRegionBrightness(frame, circleRect) > threshold;
-};
-
-/**
- * Get average brightness for a specific rectangular region
- */
-const getRegionBrightness = (frame, bounds) => {
-  'worklet';
-
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const width = frame.width;
-  const height = frame.height;
-  const minX = Math.max(0, Math.floor(bounds.minX));
-  const maxX = Math.min(width - 1, Math.floor(bounds.minX + bounds.width));
-  const minY = Math.max(0, Math.floor(bounds.minY));
-  const maxY = Math.min(height - 1, Math.floor(bounds.minY + bounds.height));
-  let luminanceSum = 0;
-  let pixelCount = 0;
-  for (let y = minY; y <= maxY; y++) {
-    for (let x = minX; x <= maxX; x++) {
-      const index = y * width + x;
-      if (data[index] !== undefined) {
-        luminanceSum += data[index];
-        pixelCount++;
-      }
-    }
-  }
-  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
-};
-
-/**
- * Calculate adaptive exposure step based on distance from target brightness
- * Uses smooth scaling to prevent abrupt exposure changes that could cause dark frames
- */
-const calculateExposureStep = (currentBrightness, targetBrightness) => {
-  'worklet';
-
-  const difference = Math.abs(targetBrightness - currentBrightness);
-  // Use smaller steps for smoother transitions: max 2, min 1
-  // Use floor + 1 to ensure at least step of 1 and prevent over-correction
-  const step = Math.min(2, Math.max(1, Math.floor(difference / 25)));
-  return step;
-};
-
-/**
- * Get the center point of the scan area
- * Scan area is typically 36%-64% of vertical space
- */
-const getScanAreaCenterPoint = (width, height) => {
-  const scanAreaTop = height * 0.36;
-  const scanAreaBottom = height * 0.64;
-  const scanAreaCenterY = (scanAreaTop + scanAreaBottom) / 2;
-  const scanAreaCenterX = width / 2;
-  return {
-    x: scanAreaCenterX,
-    y: scanAreaCenterY
-  };
-};
-
-/**
- * Document dimensions (in mm) for reference
- */
-const DOCUMENT_DIMENSIONS = {
-  ID_CARD: {
-    width: 85.6,
-    height: 53.98,
-    ratio: 1.586
-  },
-  PASSPORT: {
-    width: 125,
-    height: 88,
-    ratio: 1.42
-  }
-};
-
-/**
- * Detected document information
- */
-
-/**
- * Detect document contours and estimate document type based on aspect ratio
- * This is a simplified detection that looks for rectangular contours in the scan area
- * @param frame - The camera frame to analyze
- * @param scanAreaBounds - The bounds of the scan area {x, y, width, height}
- * @returns Detected document info or null if no document detected
- */
-const detectDocumentInFrame = (frame, scanAreaBounds) => {
-  'worklet';
-
-  // For now, we'll use a simple edge-based detection
-  // In production, this would integrate with OpenCV findContours
-  // This is a placeholder that estimates based on brightness patterns
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const frameWidth = frame.width;
-  const frameHeight = frame.height;
-
-  // Sample edges of scan area to detect document boundaries
-  const scanX = Math.floor(scanAreaBounds.x * frameWidth);
-  const scanY = Math.floor(scanAreaBounds.y * frameHeight);
-  const scanWidth = Math.floor(scanAreaBounds.width * frameWidth);
-  const scanHeight = Math.floor(scanAreaBounds.height * frameHeight);
-
-  // Calculate average brightness in scan area to detect presence of document
-  // Documents typically have good contrast against backgrounds
-  let totalBrightness = 0;
-  let sampleCount = 0;
-  const sampleStep = 20; // Sample every 20 pixels for performance
-
-  // Sample brightness across the scan area
-  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
-    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
-      const idx = y * frameWidth + x;
-      if (idx >= 0 && idx < data.length) {
-        totalBrightness += data[idx];
-        sampleCount++;
-      }
-    }
-  }
-  const avgBrightness = sampleCount > 0 ? totalBrightness / sampleCount : 0;
-
-  // Calculate standard deviation to measure contrast
-  let variance = 0;
-  for (let y = scanY; y < scanY + scanHeight; y += sampleStep) {
-    for (let x = scanX; x < scanX + scanWidth; x += sampleStep) {
-      const idx = y * frameWidth + x;
-      if (idx >= 0 && idx < data.length) {
-        const diff = data[idx] - avgBrightness;
-        variance += diff * diff;
-      }
-    }
-  }
-  const stdDev = sampleCount > 0 ? Math.sqrt(variance / sampleCount) : 0;
-
-  // Document is present if there's ANY reasonable content in scan area
-  // Lower threshold: stdDev > 10 indicates some content (not blank surface)
-  // Brightness between 20-240 covers most lighting conditions
-  const documentPresent = stdDev > 10 && avgBrightness > 20 && avgBrightness < 240;
-  if (!documentPresent) {
-    return null;
-  }
-
-  // Default to ID_CARD since scan area matches ID card proportions
-  // Passport detection would require actual contour detection
-  const type = 'ID_CARD';
-  const confidence = Math.min(1, stdDev / 50);
-
-  // Calculate how much of frame the document occupies
-  const framePercentage = scanWidth * scanHeight / (frameWidth * frameHeight);
-  const aspectRatio = scanWidth / scanHeight;
-
-  // Determine size feedback based on contrast level
-  // Higher contrast usually means document is closer/larger
-  let size = 'GOOD';
-  if (stdDev < 25) {
-    size = 'TOO_SMALL'; // Low contrast - probably far away
-  } else if (stdDev > 80) {
-    size = 'TOO_LARGE'; // Very high contrast - probably too close
-  }
-  return {
-    type,
-    size,
-    aspectRatio,
-    confidence: Math.min(1, confidence),
-    framePercentage
-  };
-};
-export { isBlurry, isFrameBright, getAverageBrightness, getCircularRegionBrightness, isCircularRegionBright, getRegionBrightness, calculateExposureStep, getScanAreaCenterPoint, detectDocumentInFrame, DOCUMENT_DIMENSIONS };

package/lib/module/Shared/Libs/frame-enhancement.utils.js

@@ -1,133 +0,0 @@
-"use strict";
-
-import { ColorConversionCodes, DataTypes, ObjectType, OpenCV } from 'react-native-fast-opencv';
-import { ENHANCEMENT_CONFIG } from "../Config/camera-enhancement.config.js";
-
-// Cast OpenCV for methods not in type definitions
-const OpenCVAny = OpenCV;
-
-/**
- * Convert YUV frame to BGR Mat for OpenCV processing
- */
-const convertYUVToBGR = frame => {
-  'worklet';
-
-  const buffer = frame.toArrayBuffer();
-  const data = new Uint8Array(buffer);
-  const width = frame.width;
-  const height = frame.height;
-
-  // Create YUV Mat from frame buffer
-  const yuvMat = OpenCV.createObject(ObjectType.Mat, height + height / 2, width, DataTypes.CV_8UC1);
-
-  // Copy frame data to YUV Mat
-  OpenCVAny.invoke('matSetData', yuvMat, data);
-
-  // Convert YUV to BGR
-  const bgrMat = OpenCV.createObject(ObjectType.Mat, height, width, DataTypes.CV_8UC3);
-  OpenCV.invoke('cvtColor', yuvMat, bgrMat, ColorConversionCodes.COLOR_YUV2BGR_NV21);
-  return bgrMat;
-};
-
-/**
- * Apply CLAHE (Contrast Limited Adaptive Histogram Equalization) to enhance frame
- * This improves text and face recognition in varying lighting conditions
- */
-const enhanceFrameForOCR = (frame, options) => {
-  'worklet';
-
-  const clipLimit = options?.clipLimit ?? ENHANCEMENT_CONFIG.contrast.clahe.clipLimit;
-  const tileGridSize = options?.tileGridSize ?? ENHANCEMENT_CONFIG.contrast.clahe.tileGridSize[0];
-  try {
-    // 1. Convert YUV to BGR
-    const bgrMat = convertYUVToBGR(frame);
-
-    // 2. Convert BGR to LAB color space (better for luminance enhancement)
-    const labMat = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC3);
-    OpenCV.invoke('cvtColor', bgrMat, labMat, ColorConversionCodes.COLOR_BGR2Lab);
-
-    // 3. Split LAB channels
-    const channels = OpenCVAny.invoke('split', labMat);
-    const lChannel = channels[0]; // Luminance channel
-    const aChannel = channels[1]; // a channel
-    const bChannel = channels[2]; // b channel
-
-    // 4. Apply CLAHE to L channel
-    const clahe = OpenCVAny.invoke('createCLAHE', clipLimit, [tileGridSize, tileGridSize]);
-    const enhancedL = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC1);
-    OpenCVAny.invoke('apply', clahe, lChannel, enhancedL);
-
-    // 5. Merge enhanced L channel with original a and b channels
-    const enhancedLab = OpenCVAny.invoke('merge', [enhancedL, aChannel, bChannel]);
-
-    // 6. Convert back to BGR
-    const enhancedBGR = OpenCV.createObject(ObjectType.Mat, frame.height, frame.width, DataTypes.CV_8UC3);
-    OpenCV.invoke('cvtColor', enhancedLab, enhancedBGR, ColorConversionCodes.COLOR_Lab2BGR);
-
-    // Cleanup intermediate Mats
-    OpenCVAny.invoke('delete', bgrMat);
-    OpenCVAny.invoke('delete', labMat);
-    OpenCVAny.invoke('delete', lChannel);
-    OpenCVAny.invoke('delete', aChannel);
-    OpenCVAny.invoke('delete', bChannel);
-    OpenCVAny.invoke('delete', enhancedL);
-    OpenCVAny.invoke('delete', enhancedLab);
-    return enhancedBGR;
-  } catch (error) {
-    console.warn('Error enhancing frame:', error);
-    // Return original frame converted to BGR if enhancement fails
-    return convertYUVToBGR(frame);
-  }
-};
-
-/**
- * Apply sharpening to enhance text clarity
- * Uses unsharp mask technique
- */
-const sharpenForText = (mat, amount = 1.5) => {
-  'worklet';
-
-  try {
-    const blurred = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
-
-    // Apply Gaussian blur
-    OpenCVAny.invoke('GaussianBlur', mat, blurred, [0, 0], 3.0);
-
-    // Create sharpened image: original * (1 + amount) - blurred * amount
-    const sharpened = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8UC3);
-    OpenCV.invoke('addWeighted', mat, 1.0 + amount, blurred, -amount, 0, sharpened);
-
-    // Cleanup
-    OpenCVAny.invoke('delete', blurred);
-    return sharpened;
-  } catch (error) {
-    console.warn('Error sharpening frame:', error);
-    return mat;
-  }
-};
-
-/**
- * Determine if frame should be enhanced based on current scanning state
- */
-const shouldEnhanceFrame = (nextStep, detectedFaces, mrzRetryCount) => {
-  'worklet';
-
-  const config = ENHANCEMENT_CONFIG.contrast.applyWhen;
-
-  // Always enhance for document back side (MRZ scanning)
-  if (config.documentBackSide && nextStep === 'SCAN_ID_BACK') {
-    return true;
-  }
-
-  // Enhance if faces are failing to detect on front/passport
-  if (config.faceFailing && nextStep === 'SCAN_ID_FRONT_OR_PASSPORT' && detectedFaces === 0) {
-    return true;
-  }
-
-  // Enhance if MRZ detection is failing
-  if (config.mrzFailing && mrzRetryCount >= config.retryThreshold) {
-    return true;
-  }
-  return false;
-};
-export { convertYUVToBGR, enhanceFrameForOCR, sharpenForText, shouldEnhanceFrame };

package/lib/module/Shared/Libs/opencv.utils.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import { ColorConversionCodes, DataTypes, ObjectType, OpenCV } from 'react-native-fast-opencv';
-const isImageBright = (width, height, frameBuffer) => {
-  'worklet';
-
-  try {
-    const imageMat = OpenCV.frameBufferToMat(height, width, 3, frameBuffer);
-    const grayMat = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_8U);
-    OpenCV.invoke('cvtColor', imageMat, grayMat, ColorConversionCodes.COLOR_BGR2GRAY);
-    const meanMat = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_64F);
-    const stdDevMat = OpenCV.createObject(ObjectType.Mat, 0, 0, DataTypes.CV_64F);
-    OpenCV.invoke('meanStdDev', grayMat, meanMat, stdDevMat);
-    const minMax = OpenCV.invoke('minMaxLoc', meanMat);
-    return minMax.maxVal >= 90;
-  } catch (e) {
-    // console.log('error', e);
-  }
-  return false;
-};
-export { isImageBright };

package/lib/module/Shared/Libs/worklet.utils.js

@@ -1,68 +0,0 @@
-"use strict";
-
-import { Worklets } from 'react-native-worklets-core';
-
-/**
- * A synchronized Shared Value to indicate whether the async context is currently executing
- */
-let isAsyncContextBusy;
-
-/**
- * Runs the given function on the async context, and sets isAsyncContextBusy to false after it finished executing.
- */
-let runOnAsyncContext;
-try {
-  isAsyncContextBusy = Worklets.createSharedValue(false);
-  const asyncContext = Worklets.defaultContext;
-  runOnAsyncContext = asyncContext.createRunAsync((frame, func) => {
-    'worklet';
-
-    try {
-      // Call long-running function
-      func();
-    } catch (e) {
-      // Re-throw error on JS Thread
-      throw e;
-    } finally {
-      // Potentially delete Frame if we were the last ref
-      const internal = frame;
-      internal.decrementRefCount();
-
-      // free up async context again, new calls can be made
-      isAsyncContextBusy.value = false;
-    }
-  });
-} catch (e) {
-  // react-native-worklets-core is not installed!
-  // Just use dummy implementations that will throw when the user tries to use Frame Processors.
-  isAsyncContextBusy = {
-    value: false
-  };
-  runOnAsyncContext = () => {
-    throw new Error('react-native-worklets-core is not installed! Please install it to use Frame Processors.');
-  };
-}
-
-/**
- * Runs the given func asynchronously on a separate thread,
- * allowing the Frame Processor to continue executing without dropping a Frame.
- * 
- * @note This is a custom implementation. For most cases, use runAsync from react-native-vision-camera.
- */
-export function runAsync(frame, func) {
-  'worklet';
-
-  if (isAsyncContextBusy.value) {
-    // async context is currently busy, we cannot schedule new work in time.
-    // drop this frame/runAsync call.
-    return;
-  }
-
-  // Increment ref count by one
-  const internal = frame;
-  internal.incrementRefCount();
-  isAsyncContextBusy.value = true;
-
-  // Call in separate background context
-  runOnAsyncContext(frame, func);
-}