@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/utils/convert.js

@@ -0,0 +1,197 @@
+"use strict";
+
+/**
+ * ML Kit Android barcode format constants
+ */
+export const AndroidBarcodeFormat = {
+  UNKNOWN: -1,
+  ALL_FORMATS: 0,
+  CODE_128: 1,
+  CODE_39: 2,
+  CODE_93: 4,
+  CODABAR: 8,
+  DATA_MATRIX: 16,
+  EAN_13: 32,
+  EAN_8: 64,
+  ITF: 128,
+  QR_CODE: 256,
+  UPC_A: 512,
+  UPC_E: 1024,
+  PDF417: 2048,
+  AZTEC: 4096
+};
+
+/**
+ * iOS Vision framework barcode symbology constants
+ */
+export const IOSBarcodeSymbology = {
+  aztec: 'VNBarcodeSymbologyAztec',
+  code128: 'VNBarcodeSymbologyCode128',
+  code39: 'VNBarcodeSymbologyCode39',
+  code39Checksum: 'VNBarcodeSymbologyCode39Checksum',
+  code39FullASCII: 'VNBarcodeSymbologyCode39FullASCII',
+  code39FullASCIIChecksum: 'VNBarcodeSymbologyCode39FullASCIIChecksum',
+  code93: 'VNBarcodeSymbologyCode93',
+  code93i: 'VNBarcodeSymbologyCode93i',
+  dataMatrix: 'VNBarcodeSymbologyDataMatrix',
+  ean13: 'VNBarcodeSymbologyEAN13',
+  ean8: 'VNBarcodeSymbologyEAN8',
+  face: 'VNBarcodeSymbologyFace',
+  i2of5: 'VNBarcodeSymbologyI2of5',
+  i2of5Checksum: 'VNBarcodeSymbologyI2of5Checksum',
+  itf14: 'VNBarcodeSymbologyITF14',
+  pdf417: 'VNBarcodeSymbologyPDF417',
+  qr: 'VNBarcodeSymbologyQR',
+  upce: 'VNBarcodeSymbologyUPCE',
+  codabar: 'VNBarcodeSymbologyCodabar'
+};
+
+/**
+ * Convert our BarcodeType to Android ML Kit format
+ */
+export const barcodeTypeToAndroidFormat = type => {
+  switch (type) {
+    case 'aztec':
+      return AndroidBarcodeFormat.AZTEC;
+    case 'codabar':
+      return AndroidBarcodeFormat.CODABAR;
+    case 'code-128':
+      return AndroidBarcodeFormat.CODE_128;
+    case 'code-39':
+      return AndroidBarcodeFormat.CODE_39;
+    case 'code-93':
+      return AndroidBarcodeFormat.CODE_93;
+    case 'data-matrix':
+      return AndroidBarcodeFormat.DATA_MATRIX;
+    case 'ean-13':
+      return AndroidBarcodeFormat.EAN_13;
+    case 'ean-8':
+      return AndroidBarcodeFormat.EAN_8;
+    case 'itf':
+      return AndroidBarcodeFormat.ITF;
+    case 'pdf-417':
+      return AndroidBarcodeFormat.PDF417;
+    case 'qr':
+      return AndroidBarcodeFormat.QR_CODE;
+    case 'upc-a':
+      return AndroidBarcodeFormat.UPC_A;
+    case 'upc-e':
+      return AndroidBarcodeFormat.UPC_E;
+    default:
+      return AndroidBarcodeFormat.UNKNOWN;
+  }
+};
+
+/**
+ * Convert our BarcodeType to iOS Vision framework symbology
+ */
+export const barcodeTypeToIOSSymbology = type => {
+  switch (type) {
+    case 'aztec':
+      return IOSBarcodeSymbology.aztec;
+    case 'codabar':
+      return IOSBarcodeSymbology.codabar;
+    case 'code-128':
+      return IOSBarcodeSymbology.code128;
+    case 'code-39':
+      return IOSBarcodeSymbology.code39;
+    case 'code-93':
+      return IOSBarcodeSymbology.code93;
+    case 'data-matrix':
+      return IOSBarcodeSymbology.dataMatrix;
+    case 'ean-13':
+      return IOSBarcodeSymbology.ean13;
+    case 'ean-8':
+      return IOSBarcodeSymbology.ean8;
+    case 'itf':
+      return IOSBarcodeSymbology.i2of5;
+    case 'pdf-417':
+      return IOSBarcodeSymbology.pdf417;
+    case 'qr':
+      return IOSBarcodeSymbology.qr;
+    case 'upc-a':
+      return IOSBarcodeSymbology.ean13;
+    // UPC-A is subset of EAN-13
+    case 'upc-e':
+      return IOSBarcodeSymbology.upce;
+    default:
+      return IOSBarcodeSymbology.qr;
+    // Default fallback
+  }
+};
+
+/**
+ * Convert Android ML Kit format to our BarcodeType
+ */
+export const androidFormatToBarcodeType = format => {
+  switch (format) {
+    case AndroidBarcodeFormat.AZTEC:
+      return 'aztec';
+    case AndroidBarcodeFormat.CODABAR:
+      return 'codabar';
+    case AndroidBarcodeFormat.CODE_128:
+      return 'code-128';
+    case AndroidBarcodeFormat.CODE_39:
+      return 'code-39';
+    case AndroidBarcodeFormat.CODE_93:
+      return 'code-93';
+    case AndroidBarcodeFormat.DATA_MATRIX:
+      return 'data-matrix';
+    case AndroidBarcodeFormat.EAN_13:
+      return 'ean-13';
+    case AndroidBarcodeFormat.EAN_8:
+      return 'ean-8';
+    case AndroidBarcodeFormat.ITF:
+      return 'itf';
+    case AndroidBarcodeFormat.PDF417:
+      return 'pdf-417';
+    case AndroidBarcodeFormat.QR_CODE:
+      return 'qr';
+    case AndroidBarcodeFormat.UPC_A:
+      return 'upc-a';
+    case AndroidBarcodeFormat.UPC_E:
+      return 'upc-e';
+    default:
+      return 'unknown';
+  }
+};
+
+/**
+ * Convert iOS Vision framework symbology to our BarcodeType
+ */
+export const iosSymbologyToBarcodeType = symbology => {
+  switch (symbology) {
+    case IOSBarcodeSymbology.aztec:
+      return 'aztec';
+    case IOSBarcodeSymbology.codabar:
+      return 'codabar';
+    case IOSBarcodeSymbology.code128:
+      return 'code-128';
+    case IOSBarcodeSymbology.code39:
+    case IOSBarcodeSymbology.code39Checksum:
+    case IOSBarcodeSymbology.code39FullASCII:
+    case IOSBarcodeSymbology.code39FullASCIIChecksum:
+      return 'code-39';
+    case IOSBarcodeSymbology.code93:
+    case IOSBarcodeSymbology.code93i:
+      return 'code-93';
+    case IOSBarcodeSymbology.dataMatrix:
+      return 'data-matrix';
+    case IOSBarcodeSymbology.ean13:
+      return 'ean-13';
+    case IOSBarcodeSymbology.ean8:
+      return 'ean-8';
+    case IOSBarcodeSymbology.i2of5:
+    case IOSBarcodeSymbology.i2of5Checksum:
+    case IOSBarcodeSymbology.itf14:
+      return 'itf';
+    case IOSBarcodeSymbology.pdf417:
+      return 'pdf-417';
+    case IOSBarcodeSymbology.qr:
+      return 'qr';
+    case IOSBarcodeSymbology.upce:
+      return 'upc-e';
+    default:
+      return 'unknown';
+  }
+};

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/utils/geometry.js

@@ -0,0 +1,101 @@
+"use strict";
+
+/**
+ * Convert frame coordinates to screen coordinates
+ */
+export const convertFrameToScreen = (point, frameDimensions, screenDimensions) => {
+  const scaleX = screenDimensions.width / frameDimensions.width;
+  const scaleY = screenDimensions.height / frameDimensions.height;
+  return {
+    x: point.x * scaleX,
+    y: point.y * scaleY
+  };
+};
+
+/**
+ * Convert screen coordinates to frame coordinates
+ */
+export const convertScreenToFrame = (point, frameDimensions, screenDimensions) => {
+  const scaleX = frameDimensions.width / screenDimensions.width;
+  const scaleY = frameDimensions.height / screenDimensions.height;
+  return {
+    x: point.x * scaleX,
+    y: point.y * scaleY
+  };
+};
+
+/**
+ * Convert barcode corner points to screen coordinates
+ */
+export const convertBarcodeToScreen = (barcode, frameDimensions, screenDimensions) => {
+  const convertedCornerPoints = barcode.cornerPoints?.map(point => convertFrameToScreen(point, frameDimensions, screenDimensions));
+  const convertedBoundingBox = barcode.boundingBox ? {
+    origin: convertFrameToScreen(barcode.boundingBox.origin, frameDimensions, screenDimensions),
+    size: {
+      width: barcode.boundingBox.size.width * screenDimensions.width / frameDimensions.width,
+      height: barcode.boundingBox.size.height * screenDimensions.height / frameDimensions.height
+    }
+  } : barcode.boundingBox;
+  return {
+    ...barcode,
+    cornerPoints: convertedCornerPoints,
+    boundingBox: convertedBoundingBox
+  };
+};
+
+/**
+ * Calculate center point of a rectangle
+ */
+export const getRectCenter = rect => {
+  return {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2
+  };
+};
+
+/**
+ * Calculate center point from corner points
+ */
+export const getCornerPointsCenter = cornerPoints => {
+  if (cornerPoints.length === 0) {
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+  const sum = cornerPoints.reduce((acc, point) => ({
+    x: acc.x + point.x,
+    y: acc.y + point.y
+  }), {
+    x: 0,
+    y: 0
+  });
+  return {
+    x: sum.x / cornerPoints.length,
+    y: sum.y / cornerPoints.length
+  };
+};
+
+/**
+ * Calculate bounding rectangle from corner points
+ */
+export const getBoundsFromCornerPoints = cornerPoints => {
+  if (cornerPoints.length === 0) {
+    return {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  const minX = Math.min(...cornerPoints.map(p => p.x));
+  const maxX = Math.max(...cornerPoints.map(p => p.x));
+  const minY = Math.min(...cornerPoints.map(p => p.y));
+  const maxY = Math.max(...cornerPoints.map(p => p.y));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+};

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/utils/highlights.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import { convertBarcodeToScreen } from "./geometry.js";
+
+/**
+ * Convert a BoundingBox to a Highlight with a key
+ */
+export const boundingBoxToHighlight = (boundingBox, key) => {
+  return {
+    ...boundingBox,
+    key
+  };
+};
+
+/**
+ * Convert barcodes to highlights for rendering
+ */
+export const barcodesToHighlights = (barcodes, frameDimensions, screenDimensions) => {
+  return barcodes.map((barcode, index) => {
+    const convertedBarcode = convertBarcodeToScreen(barcode, frameDimensions, screenDimensions);
+    return boundingBoxToHighlight(convertedBarcode.boundingBox, barcode.value || `barcode-${index}`);
+  });
+};
+
+/**
+ * Get highlight styles for rendering overlay
+ */
+export const getHighlightStyle = (highlight, color = '#00FF00', borderWidth = 2) => {
+  return {
+    position: 'absolute',
+    left: highlight.origin.x,
+    top: highlight.origin.y,
+    width: highlight.size.width,
+    height: highlight.size.height,
+    borderColor: color,
+    borderWidth,
+    backgroundColor: 'transparent'
+  };
+};
+
+/**
+ * Create polygon path from corner points for more precise highlighting
+ */
+export const cornerPointsToPath = cornerPoints => {
+  if (cornerPoints.length === 0) {
+    return '';
+  }
+  const pathCommands = cornerPoints.map((point, index) => {
+    const command = index === 0 ? 'M' : 'L';
+    return `${command} ${point.x} ${point.y}`;
+  });
+  return `${pathCommands.join(' ')} Z`;
+};
+
+/**
+ * Get SVG polygon points string from corner points
+ */
+export const cornerPointsToPolygonPoints = cornerPoints => {
+  return cornerPoints.map(point => `${point.x},${point.y}`).join(' ');
+};

package/lib/module/Shared/VisionCameraPlugins/Cropper/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { VisionCameraProxy } from 'react-native-vision-camera';
+const LINKING_ERROR = `Can't load plugin crop. Try cleaning cache or reinstall plugin.`;
+export function createCropperPlugin() {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('crop', {});
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+  return {
+    crop: (frame, config) => {
+      'worklet';
+
+      if (config) {
+        const record = {};
+        if (config.includeImageBase64 !== undefined && config.includeImageBase64 !== null) {
+          record.includeImageBase64 = config.includeImageBase64;
+        }
+        if (config.saveAsFile !== undefined && config.saveAsFile !== null) {
+          record.saveAsFile = config.saveAsFile;
+        }
+        if (config.saveBitmap !== undefined && config.saveBitmap !== null) {
+          record.saveBitmap = config.saveBitmap;
+        }
+        if (config.cropRegion) {
+          const cropRegionRecord = {};
+          cropRegionRecord.left = config.cropRegion.left;
+          cropRegionRecord.top = config.cropRegion.top;
+          cropRegionRecord.width = config.cropRegion.width;
+          cropRegionRecord.height = config.cropRegion.height;
+          record.cropRegion = cropRegionRecord;
+        }
+        return plugin.call(frame, record);
+      } else {
+        return plugin.call(frame);
+      }
+    }
+  };
+}
+
+// Create default plugin instance and export crop function
+const defaultPlugin = createCropperPlugin();
+export const crop = defaultPlugin.crop;
+
+// Types
+
+// The value is in percentage

package/lib/module/Shared/VisionCameraPlugins/FaceDetector/Camera.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import React, { forwardRef, useMemo } from 'react';
+import { Camera as VisionCamera, useFrameProcessor } from 'react-native-vision-camera';
+import { createFaceDetectorPlugin } from "./detectFaces.js";
+import { useRunOnJS } from 'react-native-worklets-core';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+export const Camera = /*#__PURE__*/forwardRef(function Camera(props, ref) {
+  const {
+    device,
+    callback,
+    options,
+    ...p
+  } = props;
+  const {
+    detectFaces
+  } = useFaceDetector(options);
+  const runOnJS = useRunOnJS(data => {
+    callback(data);
+  }, [options]);
+  const frameProcessor = useFrameProcessor(frame => {
+    'worklet';
+
+    const faces = detectFaces(frame);
+    runOnJS(faces);
+  }, []);
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: !!device && /*#__PURE__*/_jsx(VisionCamera, {
+      pixelFormat: "yuv",
+      ref: ref,
+      frameProcessor: frameProcessor,
+      device: device,
+      ...p
+    })
+  });
+});
+export function useFaceDetector(options) {
+  return useMemo(() => {
+    const plugin = createFaceDetectorPlugin(options);
+    return plugin;
+  }, [options]);
+}

package/lib/module/Shared/VisionCameraPlugins/FaceDetector/detectFaces.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { VisionCameraProxy } from 'react-native-vision-camera';
+const LINKING_ERROR = `Can't load plugin detectFaces. Try cleaning cache or reinstall plugin.`;
+export function createFaceDetectorPlugin(options) {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('detectFaces', {
+    performanceMode: 'accurate',
+    landmarkMode: 'none',
+    contourMode: 'none',
+    classificationMode: 'none',
+    minFaceSize: 0.1,
+    trackingEnabled: false,
+    autoScale: true,
+    windowWidth: 1.0,
+    windowHeight: 1.0,
+    ...options
+  });
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+  return {
+    detectFaces: frame => {
+      'worklet';
+
+      try {
+        // @ts-ignore
+        const result = plugin.call(frame);
+        return result || [];
+      } catch (error) {
+        console.warn('detectFaces: Plugin call failed:', error);
+        return [];
+      }
+    }
+  };
+}

package/lib/module/Shared/VisionCameraPlugins/FaceDetector/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { Camera, useFaceDetector } from "./Camera.js";
+export * from "./types.js";

package/lib/module/Shared/VisionCameraPlugins/FaceDetector/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/Camera.js

@@ -0,0 +1,56 @@
+"use strict";
+
+import React, { forwardRef, useMemo } from 'react';
+import { Camera as VisionCamera, useFrameProcessor } from 'react-native-vision-camera';
+import { createTextRecognitionPlugin } from "./scanText.js";
+import { useRunOnJS } from 'react-native-worklets-core';
+import { createTranslatorPlugin } from "./translateText.js";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+export const Camera = /*#__PURE__*/forwardRef(function Camera(props, ref) {
+  const {
+    device,
+    callback,
+    options,
+    mode,
+    ...p
+  } = props;
+  let plugin;
+  if (mode === 'translate') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const {
+      translate
+    } = useTranslate(options);
+    plugin = translate;
+  } else {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const {
+      scanText
+    } = useTextRecognition(options);
+    plugin = scanText;
+  }
+  const runOnJS = useRunOnJS(data => {
+    callback(data);
+  }, [options]);
+  const frameProcessor = useFrameProcessor(frame => {
+    'worklet';
+
+    const data = plugin(frame);
+    // @ts-ignore
+    runOnJS(data);
+  }, []);
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: !!device && /*#__PURE__*/_jsx(VisionCamera, {
+      pixelFormat: "yuv",
+      ref: ref,
+      frameProcessor: frameProcessor,
+      device: device,
+      ...p
+    })
+  });
+});
+export function useTextRecognition(options) {
+  return useMemo(() => createTextRecognitionPlugin(options), [options]);
+}
+export function useTranslate(options) {
+  return useMemo(() => createTranslatorPlugin(options), [options]);
+}

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/PhotoRecognizer.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { NativeModules, Platform } from 'react-native';
+export async function PhotoRecognizer(options) {
+  const {
+    PhotoRecognizerModule
+  } = NativeModules;
+  const {
+    uri,
+    orientation
+  } = options;
+  if (!uri) {
+    throw Error("Can't resolve img uri");
+  }
+  if (Platform.OS === 'ios') {
+    return await PhotoRecognizerModule.process(uri.replace('file://', ''), orientation || 'portrait');
+  } else {
+    return await PhotoRecognizerModule.process(uri);
+  }
+}

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/RemoveLanguageModel.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { NativeModules } from 'react-native';
+export async function RemoveLanguageModel(code) {
+  const {
+    RemoveLanguageModel: Remove
+  } = NativeModules;
+  return await Remove.remove(code);
+}

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export { Camera, useTranslate, useTextRecognition } from "./Camera.js";
+export { RemoveLanguageModel } from "./RemoveLanguageModel.js";
+export { PhotoRecognizer } from "./PhotoRecognizer.js";
+export * from "./types.js";

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/scanText.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { VisionCameraProxy } from 'react-native-vision-camera';
+const LINKING_ERROR = `Can't load plugin scanText.Try cleaning cache or reinstall plugin.`;
+export function createTextRecognitionPlugin(options) {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('scanText', {
+    ...options
+  });
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+  return {
+    scanText: frame => {
+      'worklet';
+
+      // @ts-ignore
+      return plugin.call(frame);
+    }
+  };
+}

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/translateText.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { VisionCameraProxy } from 'react-native-vision-camera';
+const LINKING_ERROR = `Can't load plugin translate.Try cleaning cache or reinstall plugin.`;
+export function createTranslatorPlugin(options) {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('translate', {
+    ...options
+  });
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+  return {
+    translate: frame => {
+      'worklet';
+
+      return plugin.call(frame);
+    }
+  };
+}

package/lib/module/Shared/VisionCameraPlugins/TextRecognition/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};