@transfergratis/react-native-sdk 0.1.2

package/src/hooks/useKYCFlow.ts

@@ -0,0 +1,248 @@
+import { useState, useCallback, useMemo } from 'react';
+import {
+  KYCFlowConfig,
+  KYCFlowState,
+  KYCFlowActions,
+  UseKYCFlowReturn
+} from '../types/KYC.types';
+
+export const useKYCFlow = (): UseKYCFlowReturn => {
+  const [state, setState] = useState<KYCFlowState>({
+    config: {
+      id: '',
+      name: '',
+      description: '',
+      version: '1.0.0',
+      elements: [],
+      settings: {
+        allowBackNavigation: true,
+        showProgressBar: true,
+        showStepNumbers: true,
+        autoAdvance: false,
+        enableRetry: true,
+        maxRetries: 3,
+      },
+      styling: {
+        primaryColor: '#4CAF50',
+        secondaryColor: '#2196F3',
+        backgroundColor: '#f8f9fa',
+        textColor: '#333',
+        borderRadius: 8,
+      },
+      localization: {
+        language: 'fr',
+        translations: {},
+      },
+    },
+    currentElementIndex: 0,
+    completedElements: [],
+    elementData: {},
+    errors: {},
+    isProcessing: false,
+  });
+
+  // Élément actuel
+  const currentElement = useMemo(() => {
+    if (state.config.elements.length === 0) return null;
+    return state.config.elements[state.currentElementIndex] || null;
+  }, [state.config.elements, state.currentElementIndex]);
+
+  // Progression
+  const progress = useMemo(() => {
+    if (state.config.elements.length === 0) return 0;
+    return (state.currentElementIndex / (state.config.elements.length - 1)) * 100;
+  }, [state.currentElementIndex, state.config.elements.length]);
+
+  // Navigation - validation simple sans dépendances complexes
+  const canGoNext = useMemo(() => {
+    if (!currentElement) return false;
+    if (state.isProcessing) return false;
+    
+    // Validation simple
+    const data = state.elementData[currentElement.id];
+    const validation = currentElement.validation;
+    
+    if (validation?.required && (!data || (typeof data === 'string' && data.trim() === ''))) {
+      return false;
+    }
+    
+    return state.currentElementIndex < state.config.elements.length - 1;
+  }, [currentElement, state.isProcessing, state.currentElementIndex, state.config.elements.length, state.elementData]);
+
+  const canGoPrevious = useMemo(() => {
+    return state.config.settings.allowBackNavigation && 
+           state.currentElementIndex > 0 && 
+           !state.isProcessing;
+  }, [state.config.settings.allowBackNavigation, state.currentElementIndex, state.isProcessing]);
+
+  const isComplete = useMemo(() => {
+    return state.currentElementIndex === state.config.elements.length - 1 &&
+           state.completedElements.length === state.config.elements.length;
+  }, [state.currentElementIndex, state.config.elements.length, state.completedElements.length]);
+
+  // Actions
+  const actions: KYCFlowActions = {
+    initializeFlow: useCallback((config: KYCFlowConfig) => {
+      setState({
+        config,
+        currentElementIndex: 0,
+        completedElements: [],
+        elementData: {},
+        errors: {},
+        isProcessing: false,
+      });
+    }, []),
+
+    nextElement: useCallback(() => {
+      const currentEl = currentElement;
+      if (currentEl) {
+        setState(prev => ({
+          ...prev,
+          completedElements: [...prev.completedElements, currentEl.id],
+          currentElementIndex: prev.currentElementIndex + 1,
+        }));
+      }
+    }, [currentElement]),
+
+    previousElement: useCallback(() => {
+      setState(prev => ({
+        ...prev,
+        currentElementIndex: prev.currentElementIndex - 1,
+      }));
+    }, []),
+
+    goToElement: useCallback((elementId: string) => {
+      const elementIndex = state.config.elements.findIndex(el => el.id === elementId);
+      if (elementIndex !== -1) {
+        setState(prev => ({
+          ...prev,
+          currentElementIndex: elementIndex,
+        }));
+      }
+    }, [state.config.elements]),
+
+    updateElementData: useCallback((elementId: string, data: any) => {
+      setState(prev => ({
+        ...prev,
+        elementData: { ...prev.elementData, [elementId]: data },
+      }));
+    }, []),
+
+    validateElement: useCallback((elementId: string) => {
+      const element = state.config.elements.find(el => el.id === elementId);
+      if (!element) return false;
+
+      const data = state.elementData[elementId];
+      const validation = element.validation;
+
+      if (!validation) return true;
+
+      // Validation requise
+      if (validation.required && (!data || (typeof data === 'string' && data.trim() === ''))) {
+        setState(prev => ({
+          ...prev,
+          errors: { ...prev.errors, [elementId]: 'Ce champ est requis' }
+        }));
+        return false;
+      }
+
+      // Validation de longueur
+      if (validation.minLength && data && data.length < validation.minLength) {
+        setState(prev => ({
+          ...prev,
+          errors: { ...prev.errors, [elementId]: `Minimum ${validation.minLength} caractères` }
+        }));
+        return false;
+      }
+
+      if (validation.maxLength && data && data.length > validation.maxLength) {
+        setState(prev => ({
+          ...prev,
+          errors: { ...prev.errors, [elementId]: `Maximum ${validation.maxLength} caractères` }
+        }));
+        return false;
+      }
+
+      // Validation par pattern
+      if (validation.pattern && data && !new RegExp(validation.pattern).test(data)) {
+        setState(prev => ({
+          ...prev,
+          errors: { ...prev.errors, [elementId]: 'Format invalide' }
+        }));
+        return false;
+      }
+
+      // Validation personnalisée
+      if (validation.customValidator && data) {
+        const result = validation.customValidator(data);
+        if (typeof result === 'string') {
+          setState(prev => ({
+            ...prev,
+            errors: { ...prev.errors, [elementId]: result }
+          }));
+          return false;
+        }
+        if (!result) {
+          setState(prev => ({
+            ...prev,
+            errors: { ...prev.errors, [elementId]: 'Validation échouée' }
+          }));
+          return false;
+        }
+      }
+
+      // Effacer l'erreur si la validation réussit
+      if (state.errors[elementId]) {
+        const newErrors = { ...state.errors };
+        delete newErrors[elementId];
+        setState(prev => ({
+          ...prev,
+          errors: newErrors
+        }));
+      }
+
+      return true;
+    }, [state.config.elements, state.elementData, state.errors]),
+
+    submitFlow: useCallback(async () => {
+      setState(prev => ({ ...prev, isProcessing: true }));
+
+      try {
+        console.log('Submitting KYC flow:', state.elementData);
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        setState(prev => ({
+          ...prev,
+          isProcessing: false,
+        }));
+      } catch (error) {
+        setState(prev => ({
+          ...prev,
+          isProcessing: false,
+          errors: { ...prev.errors, submit: 'Erreur lors de la soumission' }
+        }));
+      }
+    }, [state.elementData]),
+
+    resetFlow: useCallback(() => {
+      setState(prev => ({
+        ...prev,
+        currentElementIndex: 0,
+        completedElements: [],
+        elementData: {},
+        errors: {},
+        isProcessing: false,
+      }));
+    }, []),
+  };
+
+  return {
+    state,
+    actions,
+    currentElement,
+    progress,
+    canGoNext,
+    canGoPrevious,
+    isComplete,
+  };
+}; 

package/src/hooks/useLocation.ts

@@ -0,0 +1,221 @@
+import { useState, useEffect, useCallback } from 'react';
+import * as Location from 'expo-location';
+
+export interface LocationData {
+  latitude: number;
+  longitude: number;
+  accuracy: number | null;
+  altitude: number | null;
+  heading: number | null;
+  speed: number | null;
+  timestamp: number;
+}
+
+export interface LocationError {
+  code: string;
+  message: string;
+}
+
+export interface UseLocationOptions {
+  enableHighAccuracy?: boolean;
+  timeInterval?: number;
+  distanceInterval?: number;
+  requestPermissions?: boolean;
+}
+
+export interface UseLocationReturn {
+  location: LocationData | null;
+  error: LocationError | null;
+  loading: boolean;
+  requestPermission: () => Promise<boolean>;
+  getCurrentLocation: () => Promise<LocationData | null>;
+  startLocationUpdates: () => Promise<void>;
+  stopLocationUpdates: () => void;
+  hasPermission: boolean;
+}
+
+const useLocation = (options: UseLocationOptions = {}): UseLocationReturn => {
+  const {
+    enableHighAccuracy = true,
+    timeInterval = 10000,
+    distanceInterval = 10,
+    requestPermissions = true,
+  } = options;
+
+  const [location, setLocation] = useState<LocationData | null>(null);
+  const [error, setError] = useState<LocationError | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [hasPermission, setHasPermission] = useState(false);
+  const [locationSubscription, setLocationSubscription] = useState<Location.LocationSubscription | null>(null);
+
+  // Check and request permissions
+  const checkPermissions = useCallback(async () => {
+    try {
+      const { status } = await Location.getForegroundPermissionsAsync();
+      const hasPermission = status === Location.PermissionStatus.GRANTED;
+      setHasPermission(hasPermission);
+      return hasPermission;
+    } catch (err) {
+      console.error('Error checking location permissions:', err);
+      return false;
+    }
+  }, []);
+
+  const requestPermission = useCallback(async (): Promise<boolean> => {
+    try {
+      setLoading(true);
+      setError(null);
+      
+      const { status } = await Location.requestForegroundPermissionsAsync();
+      const hasPermission = status === Location.PermissionStatus.GRANTED;
+      
+      setHasPermission(hasPermission);
+      
+      if (!hasPermission) {
+        setError({
+          code: 'PERMISSION_DENIED',
+          message: 'Location permission denied',
+        });
+      }
+      
+      return hasPermission;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      setError({
+        code: 'PERMISSION_ERROR',
+        message: errorMessage,
+      });
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  // Get current location once
+  const getCurrentLocation = useCallback(async (): Promise<LocationData | null> => {
+    try {
+      setLoading(true);
+      setError(null);
+
+      if (!hasPermission) {
+        const permissionGranted = await requestPermission();
+        if (!permissionGranted) {
+          return null;
+        }
+      }
+
+      const currentLocation = await Location.getCurrentPositionAsync({
+        accuracy: enableHighAccuracy ? Location.Accuracy.High : Location.Accuracy.Balanced,
+      });
+
+      const locationData: LocationData = {
+        latitude: currentLocation.coords.latitude,
+        longitude: currentLocation.coords.longitude,
+        accuracy: currentLocation.coords.accuracy,
+        altitude: currentLocation.coords.altitude,
+        heading: currentLocation.coords.heading,
+        speed: currentLocation.coords.speed,
+        timestamp: currentLocation.timestamp,
+      };
+
+      setLocation(locationData);
+      return locationData;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      setError({
+        code: 'LOCATION_ERROR',
+        message: errorMessage,
+      });
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [hasPermission, enableHighAccuracy, requestPermission]);
+
+  // Start continuous location updates
+  const startLocationUpdates = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+
+      if (!hasPermission) {
+        const permissionGranted = await requestPermission();
+        if (!permissionGranted) {
+          return;
+        }
+      }
+
+      // Stop any existing subscription
+      if (locationSubscription) {
+        locationSubscription.remove();
+      }
+
+      const subscription = await Location.watchPositionAsync(
+        {
+          accuracy: enableHighAccuracy ? Location.Accuracy.High : Location.Accuracy.Balanced,
+          timeInterval,
+          distanceInterval,
+        },
+        (newLocation) => {
+          const locationData: LocationData = {
+            latitude: newLocation.coords.latitude,
+            longitude: newLocation.coords.longitude,
+            accuracy: newLocation.coords.accuracy,
+            altitude: newLocation.coords.altitude,
+            heading: newLocation.coords.heading,
+            speed: newLocation.coords.speed,
+            timestamp: newLocation.timestamp,
+          };
+          setLocation(locationData);
+        }
+      );
+
+      setLocationSubscription(subscription);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+      setError({
+        code: 'LOCATION_UPDATE_ERROR',
+        message: errorMessage,
+      });
+    } finally {
+      setLoading(false);
+    }
+  }, [hasPermission, enableHighAccuracy, timeInterval, distanceInterval, requestPermission, locationSubscription]);
+
+  // Stop location updates
+  const stopLocationUpdates = useCallback(() => {
+    if (locationSubscription) {
+      locationSubscription.remove();
+      setLocationSubscription(null);
+    }
+  }, [locationSubscription]);
+
+  // Initialize permissions on mount
+  useEffect(() => {
+    if (requestPermissions) {
+      checkPermissions();
+    }
+  }, [requestPermissions, checkPermissions]);
+
+  // Cleanup subscription on unmount
+  useEffect(() => {
+    return () => {
+      if (locationSubscription) {
+        locationSubscription.remove();
+      }
+    };
+  }, [locationSubscription]);
+
+  return {
+    location,
+    error,
+    loading,
+    requestPermission,
+    getCurrentLocation,
+    startLocationUpdates,
+    stopLocationUpdates,
+    hasPermission,
+  };
+};
+
+export default useLocation; 

package/src/hooks/useOrientationVideo.ts

@@ -0,0 +1,148 @@
+import { useState, useCallback } from 'react';
+import { 
+  OrientationVideoState, 
+  OrientationVideoActions, 
+  OrientationVideoConfig,
+  OrientationVideoResult,
+  OrientationType 
+} from '../types/KYC.types';
+import KYCService from '../modules/api/KYCService';
+
+export interface UseOrientationVideoReturn {
+  state: OrientationVideoState;
+  actions: OrientationVideoActions;
+  config: OrientationVideoConfig;
+}
+
+export const useOrientationVideo = (
+  kycService: KYCService,
+  config?: Partial<OrientationVideoConfig>
+): UseOrientationVideoReturn => {
+  const defaultConfig: OrientationVideoConfig = {
+    duration: 10,
+    orientations: ['center', 'left', 'right'],
+    instructions: {
+      center: 'Look straight ahead at the camera',
+      left: 'Turn your head to the left',
+      right: 'Turn your head to the right',
+    },
+    showPreview: true,
+    allowRetake: true,
+    maxRetakes: 3,
+    quality: 0.8,
+    aspectRatio: 16 / 9,
+  };
+
+  const finalConfig = { ...defaultConfig, ...config };
+
+  const [state, setState] = useState<OrientationVideoState>({
+    isRecording: false,
+    currentOrientation: null,
+    recordedVideo: null,
+    processingResult: null,
+    isProcessing: false,
+    error: null,
+    retakeCount: 0,
+  });
+
+  const startRecording = useCallback(() => {
+    setState(prev => ({ 
+      ...prev, 
+      isRecording: true, 
+      error: null,
+      currentOrientation: 'center' // Start with center orientation
+    }));
+  }, []);
+
+  const stopRecording = useCallback(() => {
+    setState(prev => ({ ...prev, isRecording: false }));
+  }, []);
+
+  const processVideo = useCallback(async (): Promise<OrientationVideoResult> => {
+    if (!state.recordedVideo || state.isProcessing) {
+      throw new Error('No video to process or already processing');
+    }
+
+    setState(prev => ({ ...prev, isProcessing: true, error: null }));
+
+    try {
+      const result = await kycService.processOrientationVideo(state.recordedVideo);
+      
+      if (result.success && result.data) {
+        setState(prev => ({ 
+          ...prev, 
+          processingResult: result.data || null,
+          isProcessing: false 
+        }));
+        return result.data;
+      } else {
+        const errorMessage = result.message || 'Processing failed';
+        setState(prev => ({ 
+          ...prev, 
+          isProcessing: false,
+          error: errorMessage 
+        }));
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+      setState(prev => ({ 
+        ...prev, 
+        isProcessing: false,
+        error: errorMessage 
+      }));
+      throw error;
+    }
+  }, [state.recordedVideo, state.isProcessing, kycService]);
+
+  const retake = useCallback(() => {
+    if (state.retakeCount >= finalConfig.maxRetakes) {
+      throw new Error('Maximum retakes reached');
+    }
+
+    setState(prev => ({ 
+      ...prev, 
+      recordedVideo: null,
+      processingResult: null,
+      error: null,
+      retakeCount: prev.retakeCount + 1 
+    }));
+  }, [state.retakeCount, finalConfig.maxRetakes]);
+
+  const reset = useCallback(() => {
+    setState({
+      isRecording: false,
+      currentOrientation: null,
+      recordedVideo: null,
+      processingResult: null,
+      isProcessing: false,
+      error: null,
+      retakeCount: 0,
+    });
+  }, []);
+
+  const setCurrentOrientation = useCallback((orientation: OrientationType) => {
+    setState(prev => ({ ...prev, currentOrientation: orientation }));
+  }, []);
+
+  // const setRecordedVideo = useCallback((videoUri: string) => {
+  //   setState(prev => ({ ...prev, recordedVideo: videoUri }));
+  // }, []);
+
+  const actions: OrientationVideoActions = {
+    startRecording,
+    stopRecording,
+    processVideo,
+    retake,
+    reset,
+    setCurrentOrientation,
+  };
+
+  return {
+    state,
+    actions,
+    config: finalConfig,
+  };
+};
+
+export default useOrientationVideo;