@trustchex/react-native-sdk 1.161.0

package/src/Shared/VisionCameraPlugins/BarcodeScanner/index.ts

@@ -0,0 +1,64 @@
+// Main plugin function
+export { createBarcodeScannerPlugin } from './scanCodes';
+
+// Create default plugin instance and export scanCodes function
+import { createBarcodeScannerPlugin } from './scanCodes';
+const defaultPlugin = createBarcodeScannerPlugin();
+export const scanCodes = defaultPlugin.scanCodes;
+
+// Types
+export type {
+  BarcodeType,
+  Barcode,
+  ScanBarcodesOptions,
+  Point,
+  Size,
+  Rect,
+  BoundingBox,
+  CornerPoints,
+  Highlight,
+  FrameProcessorPlugin,
+  BarcodeScannerPlugin,
+  BarcodeScannerOptions,
+} from './types';
+
+// Hooks
+export { useBarcodeScanner } from './hooks/useBarcodeScanner';
+export { useCameraPermissions } from './hooks/useCameraPermissions';
+export type {
+  UseBarcodeScannerOptions,
+  UseBarcodeScannerResult,
+} from './hooks/useBarcodeScanner';
+export type { UseCameraPermissionResult } from './hooks/useCameraPermissions';
+
+// Components
+export { BarcodeCamera } from './components/BarcodeCamera';
+export type { BarcodeCameraProps } from './components/BarcodeCamera';
+
+// Utilities
+export {
+  convertFrameToScreen,
+  convertScreenToFrame,
+  convertBarcodeToScreen,
+  getRectCenter,
+  getCornerPointsCenter,
+  getBoundsFromCornerPoints,
+} from './utils/geometry';
+export type { FrameDimensions, ScreenDimensions } from './utils/geometry';
+
+export {
+  boundingBoxToHighlight,
+  barcodesToHighlights,
+  getHighlightStyle,
+  cornerPointsToPath,
+  cornerPointsToPolygonPoints,
+} from './utils/highlights';
+
+export {
+  barcodeTypeToAndroidFormat,
+  barcodeTypeToIOSSymbology,
+  androidFormatToBarcodeType,
+  iosSymbologyToBarcodeType,
+  AndroidBarcodeFormat,
+  IOSBarcodeSymbology,
+} from './utils/convert';

package/src/Shared/VisionCameraPlugins/BarcodeScanner/scanCodes.ts

@@ -0,0 +1,30 @@
+import { VisionCameraProxy, type Frame } from 'react-native-vision-camera';
+import type {
+  ScanBarcodesOptions,
+  Barcode,
+  BarcodeScannerPlugin,
+} from './types';
+
+const LINKING_ERROR = `Can't load plugin scanCodes. Try cleaning cache or reinstall plugin.`;
+
+export function createBarcodeScannerPlugin(): BarcodeScannerPlugin {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('scanCodes', {});
+
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+
+  return {
+    scanCodes: (frame: Frame, options?: ScanBarcodesOptions): Barcode[] => {
+      'worklet';
+      try {
+        // @ts-ignore
+        const result = plugin.call(frame, options) as Barcode[];
+        return result || [];
+      } catch (error) {
+        console.warn('scanCodes: Plugin call failed:', error);
+        return [];
+      }
+    },
+  };
+}

package/src/Shared/VisionCameraPlugins/BarcodeScanner/types.ts

@@ -0,0 +1,82 @@
+import type { Frame } from 'react-native-vision-camera';
+
+export type Point = {
+  x: number;
+  y: number;
+};
+
+export type Size = {
+  width: number;
+  height: number;
+};
+
+export type Rect = Point & Size;
+
+export type Key = string | number | bigint;
+
+export type BoundingBox = {
+  origin: Point;
+  size: Size;
+};
+
+export type CornerPoints = Point[];
+export type Highlight = BoundingBox & { key: Key };
+
+export type BarcodeType =
+  | 'aztec'
+  | 'codabar'
+  | 'code-128'
+  | 'code-39'
+  | 'code-93'
+  | 'data-matrix'
+  | 'ean-13'
+  | 'ean-8'
+  | 'gs1-databar'
+  | 'itf'
+  | 'msi-plessey'
+  | 'pdf-417'
+  | 'qr'
+  | 'upc-a'
+  | 'upc-e'
+  | 'unknown';
+
+export type Barcode = {
+  value: string | null;
+  type: BarcodeType;
+  boundingBox: BoundingBox;
+  cornerPoints: Point[];
+  native?: any;
+};
+
+export type ScanBarcodesOptions = {
+  barcodeTypes?: BarcodeType[];
+  regionOfInterest?: [number, number, number, number];
+};
+
+export type BasicParameterType = string | number | boolean | undefined;
+export type ParameterType =
+  | BasicParameterType
+  | BasicParameterType[]
+  | Record<string, BasicParameterType | undefined>;
+
+export interface FrameProcessorPlugin {
+  call: (
+    frame: Frame,
+    options?: Record<string, ParameterType>
+  ) => ParameterType;
+}
+
+export interface BarcodeScannerPlugin {
+  scanCodes: (frame: Frame, options?: ScanBarcodesOptions) => Barcode[];
+}
+
+export type BarcodeScannerOptions = {
+  barcodeTypes?: BarcodeType[];
+  regionOfInterest?: Rect;
+  fps?: number;
+  onBarcodeScanned: (barcodes: Barcode[], frame: Frame) => void;
+  disableHighlighting?: boolean;
+  resizeMode?: 'cover' | 'contain';
+  scanMode?: 'continuous' | 'once';
+  isMountedRef?: { value: boolean };
+};

package/src/Shared/VisionCameraPlugins/BarcodeScanner/utils/convert.ts

@@ -0,0 +1,195 @@
+import type { BarcodeType } from '../types';
+
+/**
+ * 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,
+} as const;
+
+/**
+ * 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',
+} as const;
+
+/**
+ * Convert our BarcodeType to Android ML Kit format
+ */
+export const barcodeTypeToAndroidFormat = (type: BarcodeType): number => {
+  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: BarcodeType): string => {
+  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: number): BarcodeType => {
+  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: string): BarcodeType => {
+  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/src/Shared/VisionCameraPlugins/BarcodeScanner/utils/geometry.ts

@@ -0,0 +1,135 @@
+import type { Barcode, Point, Rect } from '../types';
+
+export interface FrameDimensions {
+  width: number;
+  height: number;
+}
+
+export interface ScreenDimensions {
+  width: number;
+  height: number;
+}
+
+/**
+ * Convert frame coordinates to screen coordinates
+ */
+export const convertFrameToScreen = (
+  point: Point,
+  frameDimensions: FrameDimensions,
+  screenDimensions: ScreenDimensions
+): Point => {
+  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: Point,
+  frameDimensions: FrameDimensions,
+  screenDimensions: ScreenDimensions
+): Point => {
+  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: Barcode,
+  frameDimensions: FrameDimensions,
+  screenDimensions: ScreenDimensions
+): Barcode => {
+  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: Rect): Point => {
+  return {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  };
+};
+
+/**
+ * Calculate center point from corner points
+ */
+export const getCornerPointsCenter = (cornerPoints: Point[]): Point => {
+  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: Point[]): Rect => {
+  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/src/Shared/VisionCameraPlugins/BarcodeScanner/utils/highlights.ts

@@ -0,0 +1,84 @@
+import type { Barcode, Highlight, BoundingBox, Point } from '../types';
+import {
+  convertBarcodeToScreen,
+  type FrameDimensions,
+  type ScreenDimensions,
+} from './geometry';
+
+/**
+ * Convert a BoundingBox to a Highlight with a key
+ */
+export const boundingBoxToHighlight = (
+  boundingBox: BoundingBox,
+  key: string | number
+): Highlight => {
+  return {
+    ...boundingBox,
+    key,
+  };
+};
+
+/**
+ * Convert barcodes to highlights for rendering
+ */
+export const barcodesToHighlights = (
+  barcodes: Barcode[],
+  frameDimensions: FrameDimensions,
+  screenDimensions: ScreenDimensions
+): Highlight[] => {
+  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: Highlight,
+  color: string = '#00FF00',
+  borderWidth: number = 2
+) => {
+  return {
+    position: 'absolute' as const,
+    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: Point[]): string => {
+  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: Point[]): string => {
+  return cornerPoints.map((point) => `${point.x},${point.y}`).join(' ');
+};

package/src/Shared/VisionCameraPlugins/Cropper/index.ts

@@ -0,0 +1,78 @@
+import { VisionCameraProxy, type Frame } from 'react-native-vision-camera';
+
+const LINKING_ERROR = `Can't load plugin crop. Try cleaning cache or reinstall plugin.`;
+
+export function createCropperPlugin(): CropperPlugin {
+  const plugin = VisionCameraProxy.initFrameProcessorPlugin('crop', {});
+
+  if (!plugin) {
+    throw new Error(LINKING_ERROR);
+  }
+
+  return {
+    crop: (frame: Frame, config?: CropConfig): CropResult => {
+      'worklet';
+
+      if (config) {
+        const record: Record<string, any> = {};
+
+        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: Record<string, any> = {};
+          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) as CropResult;
+      } else {
+        return plugin.call(frame) as CropResult;
+      }
+    },
+  };
+}
+
+// Create default plugin instance and export crop function
+const defaultPlugin = createCropperPlugin();
+export const crop = defaultPlugin.crop;
+
+// Types
+export interface CropperPlugin {
+  crop: (frame: Frame, config?: CropConfig) => CropResult;
+}
+
+// The value is in percentage
+export interface CropRegion {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+export interface CropConfig {
+  cropRegion?: CropRegion;
+  includeImageBase64?: boolean;
+  saveBitmap?: boolean;
+  saveAsFile?: boolean;
+}
+
+export interface CropResult {
+  base64?: string;
+  path?: string;
+}