@trustchex/react-native-sdk 1.355.1 → 1.357.0

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

@@ -1,195 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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;
-}

package/src/Shared/VisionCameraPlugins/FaceDetector/Camera.tsx

@@ -1,63 +0,0 @@
-import React, { forwardRef, type ForwardedRef, useMemo } from 'react';
-import {
-  Camera as VisionCamera,
-  useFrameProcessor,
-} from 'react-native-vision-camera';
-import { createFaceDetectorPlugin } from './detectFaces';
-import { useRunOnJS } from 'react-native-worklets-core';
-import type {
-  CameraTypes,
-  Face,
-  Frame,
-  ReadonlyFrameProcessor,
-  FaceDetectorPlugin,
-  FaceDetectorOptions,
-} from './types';
-
-export const Camera = forwardRef(function Camera(
-  props: CameraTypes,
-  ref: ForwardedRef<any>
-) {
-  const { device, callback, options, ...p } = props;
-
-  const { detectFaces } = useFaceDetector(options);
-
-  const runOnJS = useRunOnJS(
-    (data: Face[]): void => {
-      callback(data);
-    },
-    [options]
-  );
-
-  const frameProcessor: ReadonlyFrameProcessor = useFrameProcessor(
-    (frame: Frame) => {
-      'worklet';
-      const faces: Face[] = detectFaces(frame);
-      runOnJS(faces);
-    },
-    []
-  );
-
-  return (
-    <>
-      {!!device && (
-        <VisionCamera
-          pixelFormat="yuv"
-          ref={ref}
-          frameProcessor={frameProcessor}
-          device={device}
-          {...p}
-        />
-      )}
-    </>
-  );
-});
-
-export function useFaceDetector(
-  options?: FaceDetectorOptions
-): FaceDetectorPlugin {
-  return useMemo(() => {
-    const plugin = createFaceDetectorPlugin(options);
-    return plugin;
-  }, [options]);
-}

package/src/Shared/VisionCameraPlugins/FaceDetector/detectFaces.ts

@@ -1,44 +0,0 @@
-import { VisionCameraProxy } from 'react-native-vision-camera';
-import type {
-  Frame,
-  FaceDetectorPlugin,
-  FaceDetectorOptions,
-  Face,
-} from './types';
-
-const LINKING_ERROR = `Can't load plugin detectFaces. Try cleaning cache or reinstall plugin.`;
-
-export function createFaceDetectorPlugin(
-  options?: FaceDetectorOptions
-): FaceDetectorPlugin {
-  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: Frame): Face[] => {
-      'worklet';
-      try {
-        // @ts-ignore
-        const result = plugin.call(frame) as Face[];
-        return result || [];
-      } catch (error) {
-        console.warn('detectFaces: Plugin call failed:', error);
-        return [];
-      }
-    },
-  };
-}

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

@@ -1,3 +0,0 @@
-export { Camera, useFaceDetector } from './Camera';
-
-export * from './types';

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

@@ -1,99 +0,0 @@
-export type {
-  Frame,
-  ReadonlyFrameProcessor,
-  FrameProcessorPlugin,
-  FrameInternal,
-  CameraProps,
-  CameraDevice,
-} from 'react-native-vision-camera';
-export type { ForwardedRef } from 'react';
-import type { CameraProps, Frame } from 'react-native-vision-camera';
-
-export type FaceDetectorOptions = {
-  performanceMode?: 'fast' | 'accurate';
-  landmarkMode?: 'none' | 'all';
-  contourMode?: 'none' | 'all';
-  classificationMode?: 'none' | 'all';
-  minFaceSize?: number;
-  trackingEnabled?: boolean;
-  autoScale?: boolean;
-  windowWidth?: number;
-  windowHeight?: number;
-};
-
-export type CameraTypes = {
-  callback: (data: Face[]) => void;
-  mode: 'detectFaces';
-  options?: FaceDetectorOptions;
-} & CameraProps;
-
-export type FaceDetectorPlugin = {
-  detectFaces: (frame: Frame) => Face[];
-};
-
-export type Face = {
-  bounds: Bounds;
-  landmarks?: FaceLandmarks;
-  contours?: FaceContours;
-  trackingId?: number;
-  leftEyeOpenProbability?: number;
-  rightEyeOpenProbability?: number;
-  smilingProbability?: number;
-  headEulerAngleX?: number;
-  headEulerAngleY?: number;
-  headEulerAngleZ?: number;
-  // Aliases for backwards compatibility with external library API
-  pitchAngle?: number;
-  yawAngle?: number;
-  rollAngle?: number;
-};
-
-export type Bounds = {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-};
-
-export type Point = {
-  x: number;
-  y: number;
-};
-
-export type FaceLandmarks = {
-  leftEye?: Point;
-  rightEye?: Point;
-  noseBase?: Point;
-  leftCheek?: Point;
-  rightCheek?: Point;
-  leftEar?: Point;
-  rightEar?: Point;
-  leftMouth?: Point;
-  rightMouth?: Point;
-  bottomMouth?: Point;
-};
-
-export type FaceContours = {
-  face?: Point[];
-  leftEyebrow?: Point[];
-  rightEyebrow?: Point[];
-  leftEye?: Point[];
-  rightEye?: Point[];
-  upperLipTop?: Point[];
-  upperLipBottom?: Point[];
-  lowerLipTop?: Point[];
-  lowerLipBottom?: Point[];
-  noseBridge?: Point[];
-  noseBottom?: Point[];
-  leftCheek?: Point[];
-  rightCheek?: Point[];
-};
-
-export type PhotoOptions = {
-  uri: string;
-  orientation?:
-    | 'landscapeRight'
-    | 'portrait'
-    | 'portraitUpsideDown'
-    | 'landscapeLeft';
-};