@trustchex/react-native-sdk 1.161.0

package/src/Shared/Libs/mrz.utils.ts

@@ -0,0 +1,110 @@
+import { parse } from 'mrz';
+
+/**
+ * Fixes the raw text of an MRZ by removing spaces and « characters, and padding lines to the expected length.
+ * @param rawText  The raw text to fix
+ * @returns  The fixed text
+ */
+const fixMRZ = (rawText: string) => {
+  if (!rawText) {
+    return rawText;
+  }
+
+  const FILLER_CHAR = '<';
+  const MRZ_FORMATS = [
+    { lines: 3, length: 30 }, // TD1
+    { lines: 2, length: 36 }, // TD2
+    { lines: 2, length: 44 }, // TD3
+  ];
+
+  const cleanedText = rawText
+    .replace(/«| /g, '') // Remove « characters and spaces
+    .replace(/<K+|r+K+|<r+K+/g, '') // Remove invalid patterns
+    .replace(/\bI<TUR([A-Z0-9]{3})0([A-Z0-9]{6})\b/g, 'I<TUR$1O$2'); // Fix document number if it contains '0' instead of 'O'
+
+  const lines = cleanedText
+    .split(/\n/)
+    .map((line) => line.trim())
+    .filter((line) => /<+/.test(line));
+
+  let detectedFormat = MRZ_FORMATS.find((format) => {
+    return lines.every((line) => line.length <= format.length);
+  });
+
+  if (!detectedFormat) {
+    return rawText;
+  }
+
+  const fixedLines = lines.map((line) => {
+    if (/<+/.test(line) && line.length < detectedFormat.length) {
+      return line.padEnd(detectedFormat.length, FILLER_CHAR);
+    }
+    return line;
+  });
+
+  return fixedLines.join('\n');
+};
+
+const MRZ_REGEX =
+  /^(?:[A-Z0-9<]{44}\n[A-Z0-9<]{44}|[A-Z0-9<]{30}\n[A-Z0-9<]{30}\n[A-Z0-9<]{30}|[A-Z0-9<]{36}\n[A-Z0-9<]{36})$/im;
+
+const getMRZText = (fixedText: string) => {
+  if (MRZ_REGEX.test(fixedText)) {
+    return fixedText.match(MRZ_REGEX)![0];
+  }
+  return null;
+};
+
+const getMRZData = (ocrText: string) => {
+  const fixedText = fixMRZ(ocrText);
+  const mrzText = getMRZText(fixedText);
+  if (mrzText) {
+    const parsedResult = parse(mrzText, { autocorrect: true });
+    if (
+      parsedResult.fields.firstName &&
+      parsedResult.fields.lastName &&
+      parsedResult.fields.birthDate &&
+      parsedResult.fields.expirationDate &&
+      parsedResult.fields.documentNumber &&
+      parsedResult.fields.issuingState
+    ) {
+      return {
+        mrzText,
+        parsedResult,
+      };
+    }
+  }
+
+  return {
+    mrzText: null,
+    parsedResult: null,
+  };
+};
+
+/**
+ * Converts an MRZ date string to an ISO date string.
+ * @param mrzDate  The MRZ date string to convert
+ * @returns  The ISO date string, or null if the input is invalid
+ */
+const convertMRZDateToISODate = (mrzDate?: string | null) => {
+  if (!mrzDate || mrzDate.length !== 6) {
+    return null;
+  }
+
+  // Extract year, month, and day from the MRZ date string
+  let year = parseInt(mrzDate.slice(0, 2), 10);
+  let month = parseInt(mrzDate.slice(2, 4), 10) - 1;
+  let day = parseInt(mrzDate.slice(4, 6), 10);
+
+  // Handle century assumption (usually 1900 or 2000)
+  year += year < 50 ? 2000 : 1900;
+
+  const date = new Date(Date.UTC(year, month, day));
+
+  return date.toISOString();
+};
+
+export default {
+  getMRZData,
+  convertMRZDateToISODate,
+};

package/src/Shared/Libs/native-device-info.utils.ts

@@ -0,0 +1,50 @@
+import { Platform } from 'react-native';
+
+/**
+ * Native device info utility using React Native's built-in APIs
+ * Replaces basic react-native-device-info functionality
+ */
+export const NativeDeviceInfo = {
+  getBrand: (): string => {
+    return Platform.OS === 'ios' ? 'Apple' : 'Android';
+  },
+
+  getModel: (): string => {
+    // For React Native, we can't get the exact model without native modules
+    // But we can provide meaningful fallbacks
+    if (Platform.OS === 'ios') {
+      return Platform.isPad ? 'iPad' : 'iPhone';
+    }
+    return 'Android Device';
+  },
+
+  getSystemName: (): string => {
+    return Platform.OS === 'ios' ? 'iOS' : 'Android';
+  },
+
+  getSystemVersion: (): string => {
+    return Platform.Version.toString();
+  },
+
+  getUniqueId: async (): Promise<string> => {
+    // Generate a session-based unique identifier
+    // This is not persistent across app restarts but serves the same purpose for most use cases
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substr(2, 5);
+    const platform = Platform.OS.substr(0, 3);
+
+    return `${platform}-${timestamp}-${random}`;
+  },
+
+  generateHumanReadableIdentifier: async (): Promise<string> => {
+    const brand = NativeDeviceInfo.getBrand();
+    const model = NativeDeviceInfo.getModel();
+    const systemName = NativeDeviceInfo.getSystemName();
+    const systemVersion = NativeDeviceInfo.getSystemVersion();
+    const uniqueId = await NativeDeviceInfo.getUniqueId();
+
+    return `${brand} ${model} (${systemName} ${systemVersion}) - ${uniqueId}`;
+  },
+};
+
+export default NativeDeviceInfo;

package/src/Shared/Libs/native-keep-awake.utils.ts

@@ -0,0 +1,104 @@
+import { useEffect } from 'react';
+
+// Try to import the native module, but don't fail if it's not available
+let NativeTrustchexSDK: any = null;
+let isNativeModuleAvailable = false;
+
+try {
+  NativeTrustchexSDK = require('../../NativeTrustchexSDK').default;
+  isNativeModuleAvailable = true;
+} catch (error) {
+  // Native module not available
+}
+
+/**
+ * Simplified keep awake implementation using only native functionality
+ *
+ * Uses native TurboModule methods to prevent screen sleep
+ * No fallback strategies - fails gracefully if native module unavailable
+ */
+
+// Keep awake state management
+let isKeepAwakeActive = false;
+
+const enableKeepAwake = () => {
+  if (isKeepAwakeActive) return;
+
+  try {
+    if (
+      NativeTrustchexSDK &&
+      typeof NativeTrustchexSDK.enableKeepAwake === 'function'
+    ) {
+      NativeTrustchexSDK.enableKeepAwake();
+      isKeepAwakeActive = true;
+    } else {
+      console.warn('⚠️ Native keep-awake module not available');
+    }
+  } catch (error) {
+    console.error('❌ Failed to enable native keep awake:', error);
+  }
+};
+
+const disableKeepAwake = () => {
+  if (!isKeepAwakeActive) return;
+
+  try {
+    if (
+      NativeTrustchexSDK &&
+      typeof NativeTrustchexSDK.disableKeepAwake === 'function'
+    ) {
+      NativeTrustchexSDK.disableKeepAwake();
+    }
+
+    isKeepAwakeActive = false;
+  } catch (error) {
+    console.error('❌ Error during native keep-awake cleanup:', error);
+  }
+};
+
+/**
+ * Simple hook that provides native keep-awake functionality
+ * Only uses native module - no fallback strategies
+ */
+const useKeepAwake = () => {
+  useEffect(() => {
+    enableKeepAwake();
+
+    return () => {
+      disableKeepAwake();
+    };
+  }, []);
+};
+
+/**
+ * Utility function to check if keep-awake is currently active
+ */
+const isKeepAwakeCurrentlyActive = (): boolean => {
+  return isKeepAwakeActive;
+};
+
+/**
+ * Utility function to get current status
+ */
+const getKeepAwakeStats = () => {
+  return {
+    isActive: isKeepAwakeActive,
+    nativeModuleAvailable: isNativeModuleAvailable,
+  };
+};
+
+export {
+  useKeepAwake,
+  enableKeepAwake,
+  disableKeepAwake,
+  isKeepAwakeCurrentlyActive,
+  getKeepAwakeStats,
+};
+
+export default {
+  useKeepAwake,
+  enableKeepAwake,
+  disableKeepAwake,
+  isKeepAwakeCurrentlyActive,
+  getKeepAwakeStats,
+};

package/src/Shared/Libs/opencv.utils.ts

@@ -0,0 +1,40 @@
+import {
+  ColorConversionCodes,
+  DataTypes,
+  ObjectType,
+  OpenCV,
+} from 'react-native-fast-opencv';
+
+const isImageBright = (
+  width: number,
+  height: number,
+  frameBuffer: Uint8Array
+) => {
+  '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/src/Shared/Libs/promise.utils.ts

@@ -0,0 +1,20 @@
+const runWithRetry = async <T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  delay: number = 1000
+): Promise<T> => {
+  let retries = 0;
+  let result: T;
+  while (retries < maxRetries) {
+    try {
+      result = await fn();
+      return result;
+    } catch (error) {
+      retries++;
+      await new Promise((resolve) => setTimeout(resolve, delay * retries));
+    }
+  }
+  throw new Error('Max retries exceeded');
+};
+
+export { runWithRetry };

package/src/Shared/Libs/tts.utils.ts

@@ -0,0 +1,40 @@
+import i18n from '../../Translation';
+import Tts from 'react-native-tts';
+import debounce from './debounce.utils';
+
+Tts.addEventListener('tts-start', (_event) => {
+  // console.log('TTS started', event);
+});
+
+Tts.addEventListener('tts-finish', (_event) => {
+  // console.log('TTS finished', event);
+});
+
+Tts.addEventListener('tts-cancel', (_event) => {
+  // console.log('TTS cancelled', event);
+});
+
+const speak = async (text: string) => {
+  await Tts.setDefaultLanguage(i18n.language);
+  await Tts.stop();
+  Tts.speak(text);
+};
+
+const speakWithDebounce = debounce(speak, 500);
+
+const stopSpeaking = async () => {
+  await Tts.stop();
+};
+
+const initializeTTS = () => {
+  Tts.getInitStatus().then(
+    () => {},
+    (err) => {
+      if (err.code === 'no_engine') {
+        Tts.requestInstallEngine();
+      }
+    }
+  );
+};
+
+export { speak, speakWithDebounce, stopSpeaking, initializeTTS };

package/src/Shared/Types/identificationInfo.ts

@@ -0,0 +1,62 @@
+import type { FieldRecords } from 'mrz';
+import type { LivenessInstructionType } from './livenessIntructionType';
+
+export interface IdentificationInfo {
+  sessionId: string;
+  identificationId: string;
+  consent: {
+    contractIds: string[];
+    deviceInfo: string;
+  };
+  scannedDocument?: ScannedIdentityDocument;
+  livenessDetection?: LivenessDetection;
+  locale: string;
+}
+
+export interface ScannedIdentityDocument {
+  documentType: 'ID' | 'PASSPORT' | 'UNKNOWN';
+  dataSource: 'UNKNOWN' | 'OCR' | 'MRZ' | 'EID';
+  frontImage?: string;
+  backImage?: string;
+  faceImage?: string;
+  secondaryFaceImage?: string;
+  hologramImage?: string;
+  faceImageMimeType?: string;
+  barcodeValue?: string;
+  mrzText?: string;
+  mrzFields?: FieldRecords;
+}
+
+export interface LivenessDetection {
+  instructions: { instruction: string; photo: string }[];
+  videoPath: string;
+}
+
+export interface WorkflowStep {
+  id?: string;
+  type:
+    | 'CONTRACT_ACCEPTANCE'
+    | 'IDENTITY_DOCUMENT_SCAN'
+    | 'IDENTITY_DOCUMENT_EID_SCAN'
+    | 'LIVENESS_CHECK'
+    | 'AML_CHECK';
+  data?: {
+    contracts?: {
+      en: {
+        id: string;
+        name: string;
+        url: string;
+      };
+      tr: {
+        id: string;
+        name: string;
+        url: string;
+      };
+    };
+    allowedDocumentTypes?: ('I' | 'P')[] | null;
+    allowedCountries?: 'TUR'[] | null;
+    allowedLivenessInstructionTypes?: LivenessInstructionType[] | null;
+    voiceGuidanceActive?: boolean;
+  };
+  required: boolean;
+}

package/src/Shared/Types/instruction.ts

@@ -0,0 +1,4 @@
+export type Instruction = {
+  type: string;
+  photo: string;
+};

package/src/Shared/Types/livenessIntructionType.ts

@@ -0,0 +1,8 @@
+export type LivenessInstructionType =
+  | 'START'
+  | 'FINISH'
+  | 'SMILE'
+  | 'LOOK_STRAIGHT_AND_BLINK'
+  | 'TURN_HEAD_LEFT'
+  | 'TURN_HEAD_RIGHT'
+  | 'LOOK_UP';

package/src/Shared/Types/verificationSession.ts

@@ -0,0 +1,17 @@
+import type { WorkflowStep } from './identificationInfo';
+
+export type VerificationSession = {
+  id: string;
+  identificationId?: string;
+  workflowSteps?: WorkflowStep[];
+  sendOTP: boolean;
+  branding?: Branding;
+  locale?: string;
+};
+
+export type Branding = {
+  logoUrl?: string;
+  primaryColor: string;
+  secondaryColor: string;
+  tertiaryColor: string;
+};

package/src/Shared/VisionCameraPlugins/BarcodeScanner/components/BarcodeCamera.tsx

@@ -0,0 +1,85 @@
+import React, { useCallback, useState } from 'react';
+import { StyleSheet, View } from 'react-native';
+import {
+  Camera,
+  useCameraDevices,
+  type Frame,
+} from 'react-native-vision-camera';
+import {
+  useBarcodeScanner,
+  useCameraPermissions,
+  type Barcode,
+  type UseBarcodeScannerOptions,
+} from '../index';
+
+export interface BarcodeCameraProps extends UseBarcodeScannerOptions {
+  style?: any;
+  isActive?: boolean;
+  device?: 'back' | 'front';
+  enableZoomGesture?: boolean;
+  onInitialized?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export const BarcodeCamera: React.FC<BarcodeCameraProps> = ({
+  style,
+  isActive = true,
+  device = 'back',
+  enableZoomGesture = true,
+  onBarcodeScanned,
+  onError,
+  onInitialized,
+  ...barcodeScannerOptions
+}) => {
+  const devices = useCameraDevices();
+  const cameraDevice = devices.find((d) =>
+    device === 'back' ? d.position === 'back' : d.position === 'front'
+  );
+  const { hasPermission, requestPermission } = useCameraPermissions();
+  const [isCameraInitialized, setIsCameraInitialized] = useState(false);
+
+  const { scanBarcodes } = useBarcodeScanner({
+    ...barcodeScannerOptions,
+    onBarcodeScanned,
+    onError,
+  });
+
+  const handleCameraInitialized = useCallback(() => {
+    setIsCameraInitialized(true);
+    onInitialized?.();
+  }, [onInitialized]);
+
+  // Request permission if not granted
+  React.useEffect(() => {
+    if (!hasPermission) {
+      requestPermission();
+    }
+  }, [hasPermission, requestPermission]);
+
+  if (!hasPermission || !cameraDevice) {
+    return <View style={[styles.container, style]} />;
+  }
+
+  return (
+    <Camera
+      style={[styles.camera, style]}
+      device={cameraDevice}
+      isActive={isActive && isCameraInitialized}
+      enableZoomGesture={enableZoomGesture}
+      onInitialized={handleCameraInitialized}
+      onError={onError}
+    />
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: 'black',
+  },
+  camera: {
+    flex: 1,
+  },
+});
+
+export default BarcodeCamera;

package/src/Shared/VisionCameraPlugins/BarcodeScanner/hooks/useBarcodeScanner.ts

@@ -0,0 +1,79 @@
+import { useCallback, useState } from 'react';
+import type { Frame } from 'react-native-vision-camera';
+import { createBarcodeScannerPlugin } from '../scanCodes';
+import type { Barcode, ScanBarcodesOptions } from '../types';
+
+export interface UseBarcodeScannerOptions extends ScanBarcodesOptions {
+  onBarcodeScanned?: (barcodes: Barcode[]) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface UseBarcodeScannerResult {
+  scanBarcodes: (frame: Frame) => Barcode[];
+  barcodes: Barcode[];
+  isScanning: boolean;
+}
+
+let barcodeScannerPlugin: ReturnType<typeof createBarcodeScannerPlugin> | null =
+  null;
+
+export const useBarcodeScanner = (
+  options: UseBarcodeScannerOptions = {}
+): UseBarcodeScannerResult => {
+  const [barcodes, setBarcodes] = useState<Barcode[]>([]);
+  const [isScanning, setIsScanning] = useState(false);
+
+  const scanBarcodes = useCallback(
+    (frame: Frame): Barcode[] => {
+      'worklet';
+
+      if (!barcodeScannerPlugin) {
+        try {
+          barcodeScannerPlugin = createBarcodeScannerPlugin();
+        } catch (error) {
+          console.warn(
+            'useBarcodeScanner: Failed to initialize plugin:',
+            error
+          );
+          options.onError?.(error as Error);
+          return [];
+        }
+      }
+
+      setIsScanning(true);
+
+      try {
+        const scanOptions: ScanBarcodesOptions = {
+          barcodeTypes: options.barcodeTypes,
+          regionOfInterest: options.regionOfInterest,
+        };
+
+        const detectedBarcodes = barcodeScannerPlugin.scanCodes(
+          frame,
+          scanOptions
+        );
+
+        setBarcodes(detectedBarcodes);
+
+        if (detectedBarcodes.length > 0) {
+          options.onBarcodeScanned?.(detectedBarcodes);
+        }
+
+        return detectedBarcodes;
+      } catch (error) {
+        console.warn('useBarcodeScanner: Scan failed:', error);
+        options.onError?.(error as Error);
+        return [];
+      } finally {
+        setIsScanning(false);
+      }
+    },
+    [options]
+  );
+
+  return {
+    scanBarcodes,
+    barcodes,
+    isScanning,
+  };
+};

package/src/Shared/VisionCameraPlugins/BarcodeScanner/hooks/useCameraPermissions.ts

@@ -0,0 +1,45 @@
+import { useEffect, useState } from 'react';
+import { Alert, Linking } from 'react-native';
+import { useCameraPermission } from 'react-native-vision-camera';
+
+export interface UseCameraPermissionResult {
+  hasPermission: boolean;
+  requestPermission: () => Promise<boolean>;
+}
+
+export const useCameraPermissions = (): UseCameraPermissionResult => {
+  const {
+    hasPermission: cameraPermission,
+    requestPermission: requestCameraPermission,
+  } = useCameraPermission();
+
+  const [hasPermission, setHasPermission] = useState(cameraPermission);
+
+  useEffect(() => {
+    setHasPermission(cameraPermission);
+  }, [cameraPermission]);
+
+  const requestPermission = async (): Promise<boolean> => {
+    const permission = await requestCameraPermission();
+
+    if (!permission) {
+      Alert.alert(
+        'Camera Permission Required',
+        'This app needs camera access to scan barcodes. Please enable camera permissions in your device settings.',
+        [
+          { text: 'Cancel', style: 'cancel' },
+          { text: 'Open Settings', onPress: () => Linking.openSettings() },
+        ]
+      );
+      return false;
+    }
+
+    setHasPermission(permission);
+    return permission;
+  };
+
+  return {
+    hasPermission,
+    requestPermission,
+  };
+};