@test-web/react-native-sdk 1.0.0 → 2.0.0

package/src/services/getUserData.ts

@@ -0,0 +1,111 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+
+interface UserData {
+  permissionGranted: boolean;
+  location: any | null;
+  ipAddress: string | null;
+  deviceInfo: any;
+}
+
+/**
+ * Gets user data including location, device info, and IP address
+ * Handles permission requests for Android
+ */
+const getUserData = async (): Promise<UserData> => {
+  let permissionGranted = true;
+  let location: any | null = null;
+  let ipAddress: string | null = null;
+
+  // Get device info (requires react-native-device-info)
+  let deviceInfo: any = {
+    brand: 'Unknown',
+    model: 'Unknown',
+    systemName: Platform.OS,
+    systemVersion: Platform.Version.toString(),
+    uniqueId: 'unknown',
+  };
+
+  try {
+    // Try to import device info if available
+    const DeviceInfo = require('react-native-device-info');
+    deviceInfo = {
+      brand: DeviceInfo.getBrand(),
+      model: DeviceInfo.getModel(),
+      systemName: DeviceInfo.getSystemName(),
+      systemVersion: DeviceInfo.getSystemVersion(),
+      uniqueId: await DeviceInfo.getUniqueId(),
+    };
+  } catch (error) {
+    console.warn('react-native-device-info not available:', error);
+  }
+
+  // Android: Check location permission
+  if (Platform.OS === 'android') {
+    try {
+      const alreadyGranted = await PermissionsAndroid.check(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION
+      );
+
+      if (!alreadyGranted) {
+        const granted = await PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+          {
+            title: 'Location Permission',
+            message: 'This app needs access to your location.',
+            buttonPositive: 'OK',
+            buttonNegative: 'Cancel',
+          }
+        );
+
+        if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
+          permissionGranted = false;
+        }
+      }
+    } catch (err) {
+      console.warn('Permission check error:', err);
+      permissionGranted = false;
+    }
+  }
+
+  // Get location if permission granted
+  if (permissionGranted) {
+    try {
+      // Try to import geolocation if available
+      const Geolocation = require('react-native-geolocation-service');
+      location = await new Promise((resolve, reject) => {
+        Geolocation.getCurrentPosition(
+          resolve,
+          reject,
+          {
+            enableHighAccuracy: true,
+            timeout: 15000,
+            maximumAge: 10000,
+          }
+        );
+      });
+    } catch (err) {
+      console.warn('Location fetch error:', err);
+      location = null;
+    }
+  }
+
+  // Get IP address
+  try {
+    const response = await fetch('https://api.ipify.org?format=json');
+    if (response.ok) {
+      const data = await response.json();
+      ipAddress = data.ip;
+    }
+  } catch (err) {
+    console.warn('IP fetch error:', err);
+  }
+
+  return {
+    permissionGranted,
+    location,
+    ipAddress,
+    deviceInfo,
+  };
+};
+
+export default getUserData;

package/src/types/IDMConf.ts

@@ -1,13 +1,58 @@
 export interface IDMConf {
-  theme?: string | any;
+  clientID: string;
+  clientSecret: string;
+  environment: 'sandbox' | 'production';
+  requestData: RequestData;
+  theme?: 'light' | 'dark' | any;
   userDetails?: UserDetails;
   accessToken?: string;
   verificationCode?: string;
-  requestData?: any;
-  configuration?: any;
+  configuration?: Configuration;
   countryDetails?: CountryDetail[];
-  selectedCountryDetails?: any;
-  requestConfiguration?: any;
+  selectedCountryDetails?: SelectedCountryDetail;
+  requestConfiguration?: RequestConfiguration;
+}
+
+export interface RequestData {
+  requestID: string;
+  name?: string;
+  dateOfBirth?: string;
+  countryCode?: string;
+  mobile?: string;
+  callbackURL?: string;
+  redirectURL?: string;
+}
+
+export interface Configuration {
+  logo?: string;
+  hideFooter?: boolean;
+  skipInputName?: boolean;
+  enableLiveVideo?: boolean;
+  defaultWebTemplate?: boolean;
+  tenantName?: string;
+  geoLocationRequired?: boolean;
+  showEndUserVerificationHistory?: boolean;
+  enableLiveVideoMode?: boolean;
+  showFooterTenantName?: boolean;
+  verificationCode?: string | null | boolean;
+}
+
+export interface RequestConfiguration {
+  requestID?: string | null;
+  callbackURL?: string | null;
+  uniqueID?: string | null;
+  status?: string | null;
+  documentType?: string | null;
+  barcodeType?: string | null;
+  skipBarcode?: boolean | null;
+  skipLiveness?: boolean | null;
+  enableCardBackCapture?: boolean | null;
+  qrCode?: string;
+  redirectURL?: string | null;
+  verificationLink?: string | null;
+  country?: string | null;
+  countryCode?: string | null;
+  liveVideo?: boolean | null;
 }
 
 export interface UserDetails {
@@ -17,12 +62,41 @@ export interface UserDetails {
       latitude: number;
       longitude: number;
     };
+  } | null;
+  ipAddress?: string | null;
+  deviceInfo?: {
+    brand: string;
+    model: string;
+    systemName: string;
+    systemVersion: string;
+    uniqueId: string;
   };
   [key: string]: any;
 }
 
 export interface CountryDetail {
   label: string;
-  value: string;
-  metadata: any[];
+  value: string | number;
+  metadata: DocumentMetadata[];
+}
+
+export interface SelectedCountryDetail extends CountryDetail {
+  selectedMetaData?: DocumentMetadata;
+}
+
+export interface DocumentMetadata {
+  id: number;
+  country: string;
+  countryCode: string;
+  type: string; // DL, PP, NI, PC, GC, etc.
+  barcode: string; // PDF417 B, PDF417F, TD3, TD2, TD1, None
+  dateFormat: string;
+  distance: number;
+  comparedText: string | null;
+  alternateText: string;
+  live: boolean;
+  selected: boolean;
+  countryEuropean: boolean;
+  engineLanguage: boolean;
+  document_flow: string[]; // ["F"], ["F", "B"], etc.
 }

package/src/utils/base64.ts

@@ -0,0 +1,25 @@
+/**
+ * Encodes a string to base64
+ * @param str - The string to encode
+ * @returns Base64 encoded string
+ */
+export const base64Encode = (str: string): string => {
+  if (typeof btoa !== 'undefined') {
+    return btoa(str);
+  }
+  // Fallback for environments without btoa
+  return Buffer.from(str, 'utf-8').toString('base64');
+};
+
+/**
+ * Decodes a base64 string
+ * @param str - The base64 string to decode
+ * @returns Decoded string
+ */
+export const base64Decode = (str: string): string => {
+  if (typeof atob !== 'undefined') {
+    return atob(str);
+  }
+  // Fallback for environments without atob
+  return Buffer.from(str, 'base64').toString('utf-8');
+};

package/src/utils/flowManager.ts

@@ -0,0 +1,138 @@
+import { DocumentMetadata } from '../types/IDMConf';
+
+export type FlowStep = 'F' | 'B'; // Front, Back
+export type BarcodeType = 'PDF417 B' | 'PDF417F' | 'TD3' | 'TD2' | 'TD1' | 'None' | 'NONE';
+
+/**
+ * Determines the next screen in the verification flow based on metadata
+ */
+export class FlowManager {
+  private metadata: DocumentMetadata;
+  private completedSteps: Set<FlowStep>;
+
+  constructor(metadata: DocumentMetadata) {
+    this.metadata = metadata;
+    this.completedSteps = new Set();
+  }
+
+  /**
+   * Mark a step as completed
+   */
+  markStepCompleted(step: FlowStep): void {
+    this.completedSteps.add(step);
+  }
+
+  /**
+   * Get the next screen to navigate to after capturing front document
+   */
+  getNextScreenAfterFront(): string {
+    this.markStepCompleted('F');
+
+    const { document_flow, barcode } = this.metadata;
+
+    // Check if back capture is required
+    if (document_flow && document_flow.includes('B') && !this.completedSteps.has('B')) {
+      return 'BackDocumentAdvice';
+    }
+
+    // Check for barcode/MRZ requirements
+    return this.getNextScreenForBarcode(barcode);
+  }
+
+  /**
+   * Get the next screen to navigate to after capturing back document
+   */
+  getNextScreenAfterBack(): string {
+    this.markStepCompleted('B');
+
+    const { barcode } = this.metadata;
+    return this.getNextScreenForBarcode(barcode);
+  }
+
+  /**
+   * Determine next screen based on barcode type
+   */
+  private getNextScreenForBarcode(barcode: string): string {
+    const barcodeUpper = barcode?.toUpperCase() || 'NONE';
+
+    if (barcodeUpper.includes('PDF417')) {
+      return 'BarcodeAdvice';
+    }
+
+    if (['TD3', 'TD2', 'TD1'].includes(barcodeUpper)) {
+      return 'MrzAdvice';
+    }
+
+    // No barcode/MRZ required, go to thank you
+    return 'ThankYou';
+  }
+
+  /**
+   * Check if back capture is required
+   */
+  requiresBackCapture(): boolean {
+    const { document_flow } = this.metadata;
+    return document_flow && document_flow.includes('B') || false;
+  }
+
+  /**
+   * Check if barcode scan is required
+   */
+  requiresBarcodeCapture(): boolean {
+    const { barcode } = this.metadata;
+    const barcodeUpper = barcode?.toUpperCase() || 'NONE';
+    return barcodeUpper.includes('PDF417');
+  }
+
+  /**
+   * Check if MRZ scan is required
+   */
+  requiresMRZCapture(): boolean {
+    const { barcode } = this.metadata;
+    const barcodeUpper = barcode?.toUpperCase() || 'NONE';
+    return ['TD3', 'TD2', 'TD1'].includes(barcodeUpper);
+  }
+
+  /**
+   * Get all required steps for this document
+   */
+  getRequiredSteps(): string[] {
+    const steps: string[] = [];
+    const { document_flow, barcode } = this.metadata;
+
+    if (document_flow) {
+      if (document_flow.includes('F')) steps.push('FrontCapture');
+      if (document_flow.includes('B')) steps.push('BackCapture');
+    }
+
+    const barcodeUpper = barcode?.toUpperCase() || 'NONE';
+    if (barcodeUpper.includes('PDF417')) {
+      steps.push('BarcodeCapture');
+    } else if (['TD3', 'TD2', 'TD1'].includes(barcodeUpper)) {
+      steps.push('MRZCapture');
+    }
+
+    return steps;
+  }
+
+  /**
+   * Get MRZ engine type based on barcode type
+   */
+  getMRZEngine(): string {
+    const { barcode } = this.metadata;
+    const barcodeUpper = barcode?.toUpperCase() || 'NONE';
+
+    if (barcodeUpper === 'TD3') return 'TD3';
+    if (barcodeUpper === 'TD2') return 'TD2';
+    if (barcodeUpper === 'TD1') return 'TD1';
+
+    return 'TD3'; // Default
+  }
+}
+
+/**
+ * Helper function to create a FlowManager instance
+ */
+export const createFlowManager = (metadata: DocumentMetadata): FlowManager => {
+  return new FlowManager(metadata);
+};

package/src/utils/imageProcessor.ts

@@ -0,0 +1,96 @@
+/**
+ * Image processing utilities for document capture
+ * Handles image resizing and base64 conversion
+ */
+
+interface ResizeOptions {
+  width?: number;
+  height?: number;
+  quality?: number;
+  format?: 'JPEG' | 'PNG';
+}
+
+/**
+ * Resize and convert image to base64
+ * Requires react-native-image-resizer and react-native-fs
+ */
+export const processImageToBase64 = async (
+  imagePath: string,
+  options: ResizeOptions = {}
+): Promise<string> => {
+  const {
+    width = 810,
+    height = 1080,
+    quality = 70,
+    format = 'JPEG',
+  } = options;
+
+  try {
+    // Try to import required libraries
+    const ImageResizer = require('react-native-image-resizer');
+    const RNFS = require('react-native-fs');
+
+    // Ensure path has file:// prefix
+    const fullPath = imagePath.startsWith('file://') ? imagePath : `file://${imagePath}`;
+
+    try {
+      // Resize the image
+      const resizedImage = await ImageResizer.createResizedImage(
+        fullPath,
+        width,
+        height,
+        format,
+        quality,
+        0,
+        undefined,
+        false
+      );
+
+      // Convert to base64
+      const base64Image = await RNFS.readFile(resizedImage.uri, 'base64');
+      return base64Image;
+    } catch (resizeError: any) {
+      console.warn('Image resizing failed, using original image:', resizeError.message);
+      
+      // Fallback: use original image
+      const base64Image = await RNFS.readFile(fullPath, 'base64');
+      return base64Image;
+    }
+  } catch (error: any) {
+    console.error('Image processing error:', error);
+    throw new Error(`Failed to process image: ${error.message}`);
+  }
+};
+
+/**
+ * Validate image path
+ */
+export const validateImagePath = (path: string | undefined): boolean => {
+  if (!path) {
+    console.error('No image path provided');
+    return false;
+  }
+  return true;
+};
+
+/**
+ * Get image dimensions (if needed)
+ */
+export const getImageDimensions = async (
+  imagePath: string
+): Promise<{ width: number; height: number }> => {
+  try {
+    const Image = require('react-native').Image;
+    
+    return new Promise((resolve, reject) => {
+      Image.getSize(
+        imagePath,
+        (width: number, height: number) => resolve({ width, height }),
+        (error: any) => reject(error)
+      );
+    });
+  } catch (error: any) {
+    console.error('Failed to get image dimensions:', error);
+    throw error;
+  }
+};

package/src/utils/index.ts

@@ -17,3 +17,21 @@ export {
   BatchUpdater,
   createStableRef,
 } from './performance';
+
+// Base64 utilities
+export { base64Encode, base64Decode } from './base64';
+
+// Document type labels
+export const DOCUMENT_LABELS: Record<string, string> = {
+  DL: "Driver's License",
+  PP: 'Passport',
+  NI: 'National ID',
+  PC: 'Passport Card',
+  GC: 'Green Card',
+  HC: 'Health Card',
+};
+
+export const getDocumentLabel = (type: string): string => {
+  return DOCUMENT_LABELS[type] || type;
+};
+