@trustchex/react-native-sdk 1.161.0

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

@@ -0,0 +1,57 @@
+"use strict";
+
+const demoSession = {
+  id: 'demo-verification-id',
+  identificationId: 'demo-identification-id',
+  sendOTP: true,
+  locale: 'en',
+  branding: {
+    primaryColor: '#000000',
+    secondaryColor: '#000000',
+    tertiaryColor: '#000000'
+  },
+  workflowSteps: [{
+    type: 'CONTRACT_ACCEPTANCE',
+    required: false,
+    data: {
+      contracts: {
+        en: {
+          id: '1',
+          name: 'Terms of Service',
+          url: `https://app.trustchex.com/app/mobile/tcpp/demo/en.html`
+        },
+        tr: {
+          id: '2',
+          name: 'Hizmet Şartları',
+          url: `https://app.trustchex.com/app/mobile/tcpp/demo/tr.html`
+        }
+      }
+    }
+  }, {
+    type: 'IDENTITY_DOCUMENT_SCAN',
+    required: false
+  }, {
+    type: 'IDENTITY_DOCUMENT_EID_SCAN',
+    required: false
+  }, {
+    type: 'LIVENESS_CHECK',
+    required: false
+  }]
+};
+const isDemoSession = email => email === 'demo@trustchex.com';
+const getSimulatedDemoData = (dataType, body) => {
+  switch (dataType) {
+    case 'VERIFICATION_SESSIONS':
+      return [demoSession];
+    case 'GET_SESSION':
+      return demoSession;
+    case 'SEND_VERIFICATION_CODE':
+      return {};
+    case 'GET_VERIFIED_SESSION':
+      if (!body || !(body && typeof body === 'object' && 'code' in body) || body.code !== '877829') {
+        throw new Error('Invalid verification code');
+      }
+      return demoSession;
+  }
+};
+export { getSimulatedDemoData, isDemoSession };

package/lib/module/Shared/Libs/http-client.js

@@ -0,0 +1,104 @@
+"use strict";
+
+export class HttpClientError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+export class UnauthorizedError extends HttpClientError {
+  constructor(message) {
+    super(message ?? 'Unauthorized');
+  }
+}
+export class ForbiddenError extends HttpClientError {
+  constructor(message) {
+    super(message ?? 'Forbidden');
+  }
+}
+export class NotFoundError extends HttpClientError {
+  constructor(message) {
+    super(message ?? 'Not found');
+  }
+}
+export class BadRequestError extends HttpClientError {
+  constructor(message) {
+    super(message ?? 'Bad request');
+  }
+}
+export class InternalServerError extends HttpClientError {
+  constructor(message) {
+    super(message ?? 'Internal server error');
+  }
+}
+const request = async (httpMethod, url, body, simulatedResponse) => {
+  if (simulatedResponse) {
+    return new Promise(resolve => {
+      setTimeout(() => {
+        resolve(simulatedResponse);
+      }, 1000);
+    });
+  }
+  const response = await fetch(url, {
+    method: httpMethod,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+  let responseJson = null;
+  try {
+    responseJson = await response.json();
+  } catch (error) {
+    // throw new Error("Invalid response");
+  }
+  if (response && !response.ok && responseJson) {
+    const message = responseJson.message;
+    if (response.status === 401) {
+      throw new UnauthorizedError(message);
+    }
+    if (response.status === 403) {
+      throw new ForbiddenError(message);
+    }
+    if (response.status === 404) {
+      throw new NotFoundError(message);
+    }
+    if (response.status >= 500) {
+      throw new InternalServerError(message);
+    }
+    if (response.status >= 400) {
+      throw new BadRequestError(message);
+    }
+    throw new Error(message);
+  }
+  return responseJson;
+};
+const get = (url, simulatedResponse) => {
+  return request('GET', url, undefined, simulatedResponse);
+};
+const post = (url, body, simulatedResponse) => {
+  return request('POST', url, body, simulatedResponse);
+};
+const put = (url, body, simulatedResponse) => {
+  return request('PUT', url, body, simulatedResponse);
+};
+const del = (url, simulatedResponse) => {
+  return request('DELETE', url, undefined, simulatedResponse);
+};
+const upload = async (url, file) => {
+  const formData = new FormData();
+  formData.append('file', file);
+  const response = await fetch(url, {
+    method: 'POST',
+    body: formData
+  });
+  if (!response.ok) {
+    throw new Error('Upload failed');
+  }
+};
+export default {
+  get,
+  post,
+  put,
+  del,
+  upload
+};

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

@@ -0,0 +1,99 @@
+"use strict";
+
+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 => {
+  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 => {
+  if (MRZ_REGEX.test(fixedText)) {
+    return fixedText.match(MRZ_REGEX)[0];
+  }
+  return null;
+};
+const getMRZData = ocrText => {
+  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 => {
+  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/lib/module/Shared/Libs/native-device-info.utils.js

@@ -0,0 +1,44 @@
+"use strict";
+
+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: () => {
+    return Platform.OS === 'ios' ? 'Apple' : 'Android';
+  },
+  getModel: () => {
+    // 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: () => {
+    return Platform.OS === 'ios' ? 'iOS' : 'Android';
+  },
+  getSystemVersion: () => {
+    return Platform.Version.toString();
+  },
+  getUniqueId: async () => {
+    // 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 () => {
+    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/lib/module/Shared/Libs/native-keep-awake.utils.js

@@ -0,0 +1,85 @@
+"use strict";
+
+import { useEffect } from 'react';
+
+// Try to import the native module, but don't fail if it's not available
+let NativeTrustchexSDK = 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 = () => {
+  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/lib/module/Shared/Libs/opencv.utils.js

@@ -0,0 +1,21 @@
+"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/promise.utils.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const runWithRetry = async (fn, maxRetries = 3, delay = 1000) => {
+  let retries = 0;
+  let result;
+  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/lib/module/Shared/Libs/tts.utils.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import i18n from "../../Translation/index.js";
+import Tts from 'react-native-tts';
+import debounce from "./debounce.utils.js";
+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 => {
+  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/lib/module/Shared/Types/identificationInfo.js

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

package/lib/module/Shared/Types/instruction.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/Shared/Types/livenessIntructionType.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/Shared/Types/verificationSession.js

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

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/components/BarcodeCamera.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import React, { useCallback, useState } from 'react';
+import { StyleSheet, View } from 'react-native';
+import { Camera, useCameraDevices } from 'react-native-vision-camera';
+import { useBarcodeScanner, useCameraPermissions } from "../index.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export const BarcodeCamera = ({
+  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 /*#__PURE__*/_jsx(View, {
+      style: [styles.container, style]
+    });
+  }
+  return /*#__PURE__*/_jsx(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/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/hooks/useBarcodeScanner.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import { useCallback, useState } from 'react';
+import { createBarcodeScannerPlugin } from "../scanCodes.js";
+let barcodeScannerPlugin = null;
+export const useBarcodeScanner = (options = {}) => {
+  const [barcodes, setBarcodes] = useState([]);
+  const [isScanning, setIsScanning] = useState(false);
+  const scanBarcodes = useCallback(frame => {
+    'worklet';
+
+    if (!barcodeScannerPlugin) {
+      try {
+        barcodeScannerPlugin = createBarcodeScannerPlugin();
+      } catch (error) {
+        console.warn('useBarcodeScanner: Failed to initialize plugin:', error);
+        options.onError?.(error);
+        return [];
+      }
+    }
+    setIsScanning(true);
+    try {
+      const scanOptions = {
+        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);
+      return [];
+    } finally {
+      setIsScanning(false);
+    }
+  }, [options]);
+  return {
+    scanBarcodes,
+    barcodes,
+    isScanning
+  };
+};

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/hooks/useCameraPermissions.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { Alert, Linking } from 'react-native';
+import { useCameraPermission } from 'react-native-vision-camera';
+export const useCameraPermissions = () => {
+  const {
+    hasPermission: cameraPermission,
+    requestPermission: requestCameraPermission
+  } = useCameraPermission();
+  const [hasPermission, setHasPermission] = useState(cameraPermission);
+  useEffect(() => {
+    setHasPermission(cameraPermission);
+  }, [cameraPermission]);
+  const requestPermission = async () => {
+    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
+  };
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+
+// Main plugin function
+export { createBarcodeScannerPlugin } from "./scanCodes.js";
+
+// Create default plugin instance and export scanCodes function
+import { createBarcodeScannerPlugin } from "./scanCodes.js";
+const defaultPlugin = createBarcodeScannerPlugin();
+export const scanCodes = defaultPlugin.scanCodes;
+
+// Types
+
+// Hooks
+export { useBarcodeScanner } from "./hooks/useBarcodeScanner.js";
+export { useCameraPermissions } from "./hooks/useCameraPermissions.js";
+// Components
+export { BarcodeCamera } from "./components/BarcodeCamera.js";
+// Utilities
+export { convertFrameToScreen, convertScreenToFrame, convertBarcodeToScreen, getRectCenter, getCornerPointsCenter, getBoundsFromCornerPoints } from "./utils/geometry.js";
+export { boundingBoxToHighlight, barcodesToHighlights, getHighlightStyle, cornerPointsToPath, cornerPointsToPolygonPoints } from "./utils/highlights.js";
+export { barcodeTypeToAndroidFormat, barcodeTypeToIOSSymbology, androidFormatToBarcodeType, iosSymbologyToBarcodeType, AndroidBarcodeFormat, IOSBarcodeSymbology } from "./utils/convert.js";

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/scanCodes.js

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

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

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