@transfergratis/react-native-sdk 0.1.2

package/src/stores/kycStore.ts

@@ -0,0 +1,161 @@
+import { create } from 'zustand';
+
+export interface UserData {
+  id: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber?: string;
+}
+
+export interface KYCSession {
+  sessionId: string;
+  userId: string;
+  currentStep: number;
+  documents: DocumentData[];
+  selfie?: string;
+  verificationId?: string;
+  status: 'pending' | 'completed' | 'failed';
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface DocumentData {
+  id: string;
+  type: 'passport' | 'id_card' | 'drivers_license';
+  imageUri: string;
+  uploadedAt: Date;
+  validated: boolean;
+}
+
+export interface KYCState {
+  // État de la session
+  currentSession: KYCSession | null;
+  userData: UserData | null;
+  
+  // État du processus
+  currentStep: number;
+  isProcessing: boolean;
+  error: string | null;
+  
+  // Actions
+  initializeSession: (userId: string) => void;
+  setCurrentStep: (step: number) => void;
+  setUserData: (userData: UserData) => void;
+  addDocument: (document: DocumentData) => void;
+  setSelfie: (selfieUri: string) => void;
+  setProcessing: (processing: boolean) => void;
+  setError: (error: string | null) => void;
+  clearSession: () => void;
+  updateSession: (updates: Partial<KYCSession>) => void;
+}
+
+export const useKYCStore = create<KYCState>((set, get) => ({
+  // État initial
+  currentSession: null,
+  userData: null,
+  currentStep: 0,
+  isProcessing: false,
+  error: null,
+
+  // Actions
+  initializeSession: (userId: string) => {
+    const session: KYCSession = {
+      sessionId: `kyc-${Date.now()}`,
+      userId,
+      currentStep: 0,
+      documents: [],
+      status: 'pending',
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    set({ 
+      currentSession: session,
+      currentStep: 0,
+      error: null 
+    });
+  },
+
+  setCurrentStep: (step: number) => {
+    set({ currentStep: step });
+    const { currentSession } = get();
+    if (currentSession) {
+      const updatedSession = { ...currentSession, currentStep: step, updatedAt: new Date() };
+      set({ currentSession: updatedSession });
+    }
+  },
+
+  setUserData: (userData: UserData) => {
+    set({ userData });
+  },
+
+  addDocument: (document: DocumentData) => {
+    const { currentSession } = get();
+    if (currentSession) {
+      const updatedSession = {
+        ...currentSession,
+        documents: [...currentSession.documents, document],
+        updatedAt: new Date()
+      };
+      set({ currentSession: updatedSession });
+    }
+  },
+
+  setSelfie: (selfieUri: string) => {
+    const { currentSession } = get();
+    if (currentSession) {
+      const updatedSession = {
+        ...currentSession,
+        selfie: selfieUri,
+        updatedAt: new Date()
+      };
+      set({ currentSession: updatedSession });
+    }
+  },
+
+  setProcessing: (processing: boolean) => {
+    set({ isProcessing: processing });
+  },
+
+  setError: (error: string | null) => {
+    set({ error });
+  },
+
+  clearSession: () => {
+    set({ 
+      currentSession: null,
+      currentStep: 0,
+      isProcessing: false,
+      error: null 
+    });
+  },
+
+  updateSession: (updates: Partial<KYCSession>) => {
+    const { currentSession } = get();
+    if (currentSession) {
+      const updatedSession = {
+        ...currentSession,
+        ...updates,
+        updatedAt: new Date()
+      };
+      set({ currentSession: updatedSession });
+    }
+  },
+}));
+
+// Hooks utilitaires
+export const useKYCStep = () => {
+  const { currentStep, setCurrentStep } = useKYCStore();
+  return { currentStep, setCurrentStep };
+};
+
+export const useKYCProcessing = () => {
+  const { isProcessing, setProcessing } = useKYCStore();
+  return { isProcessing, setProcessing };
+};
+
+export const useKYCError = () => {
+  const { error, setError } = useKYCStore();
+  return { error, setError };
+}; 

package/src/types/KYC.types.ts

@@ -0,0 +1,434 @@
+// Types pour les documents
+export interface Document {
+  id: string;
+  type: DocumentType;
+  imageUri: string;
+  uploadedAt: Date;
+  validated: boolean;
+  extractedData?: DocumentData;
+}
+
+export type DocumentType = 'passport' | 'id_card' | 'drivers_license';
+
+export interface DocumentData {
+  firstName?: string;
+  lastName?: string;
+  dateOfBirth?: string;
+  documentNumber?: string;
+  expiryDate?: string;
+  nationality?: string;
+}
+
+// Types pour les selfies
+export interface Selfie {
+  id: string;
+  imageUri: string;
+  capturedAt: Date;
+  validated: boolean;
+  faceDetected: boolean;
+}
+
+// Types pour la session KYC
+export interface KYCSession {
+  id: string;
+  userId: string;
+  status: KYCStatus;
+  currentStep: number;
+  documents: Document[];
+  selfie?: Selfie;
+  verificationId?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  completedAt?: Date;
+}
+
+export type KYCStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'rejected';
+
+// Types pour les étapes du processus
+export interface KYCStep {
+  id: number;
+  title: string;
+  description: string;
+  isCompleted: boolean;
+  isRequired: boolean;
+}
+
+// Types pour les erreurs
+export interface KYCError {
+  code: string;
+  message: string;
+  field?: string;
+  details?: any;
+}
+
+// Types pour les réponses API
+export interface KYCResponse {
+  success: boolean;
+  data?: any;
+  error?: KYCError;
+  message?: string;
+}
+
+// Types pour les événements
+export interface KYCEvent {
+  type: 'step_completed' | 'document_uploaded' | 'selfie_captured' | 'verification_started' | 'verification_completed';
+  timestamp: Date;
+  data?: any;
+}
+
+// Types pour les configurations
+export interface KYCConfig {
+  apiBaseUrl: string;
+  apiKey: string;
+  timeout: number;
+  retryAttempts: number;
+  enableDebug: boolean;
+}
+
+// Types pour les hooks
+export interface UseKYCReturn {
+  session: KYCSession | null;
+  currentStep: number;
+  isProcessing: boolean;
+  error: KYCError | null;
+  startSession: (userId: string) => void;
+  nextStep: () => void;
+  previousStep: () => void;
+  uploadDocument: (document: Document) => Promise<void>;
+  captureSelfie: (selfie: Selfie) => Promise<void>;
+  submitVerification: () => Promise<void>;
+  resetSession: () => void;
+}
+
+// ===== NOUVEAUX TYPES POUR CONFIGURATION AUTOMATIQUE =====
+
+// Types d'éléments KYC configurables
+export type KYCElementType =
+  | 'country_selection'
+  | 'document_type_selection'
+  | 'camera_capture'
+  | 'file_upload'
+  | 'selfie_capture'
+  | 'verification'
+  | 'completion';
+
+// Configuration d'un élément KYC
+export interface KYCElement {
+  id: string;
+  type: KYCElementType;
+  title: string;
+  description: string;
+  isRequired: boolean;
+  isVisible: boolean;
+  order: number;
+  validation?: KYCValidation;
+  options?: KYCElementOption[];
+  cameraConfig?: KYCCameraConfig;
+  uploadConfig?: KYCUploadConfig;
+}
+
+// Options pour les éléments de sélection
+export interface KYCElementOption {
+  value: string;
+  label: string;
+  icon?: string;
+  description?: string;
+}
+
+// Configuration de validation
+export interface KYCValidation {
+  required: boolean;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  customValidator?: (value: any) => boolean | string;
+}
+
+// Configuration de la caméra
+export interface KYCCameraConfig {
+  aspectRatio?: number;
+  quality?: number;
+  flashMode?: 'on' | 'off' | 'auto';
+  cameraType?: 'front' | 'back';
+  allowRetake: boolean;
+  maxRetakes?: number;
+  overlay?: {
+    showGuide: boolean;
+    guideText?: string;
+    guideImage?: string;
+  };
+}
+
+// Configuration d'upload
+export interface KYCUploadConfig {
+  allowedTypes: string[];
+  maxFiles: number;
+  maxFileSize?: number;
+  allowMultiple: boolean;
+}
+
+// Configuration complète du flux KYC
+export interface KYCFlowConfig {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  elements: KYCElement[];
+  settings: {
+    allowBackNavigation: boolean;
+    showProgressBar: boolean;
+    showStepNumbers: boolean;
+    autoAdvance: boolean;
+    enableRetry: boolean;
+    maxRetries: number;
+  };
+  styling: {
+    primaryColor: string;
+    secondaryColor: string;
+    backgroundColor: string;
+    textColor: string;
+    borderRadius: number;
+    fontFamily?: string;
+  };
+  localization: {
+    language: string;
+    translations: Record<string, Record<string, string>>;
+  };
+}
+
+// État du flux KYC
+export interface KYCFlowState {
+  config: KYCFlowConfig;
+  currentElementIndex: number;
+  completedElements: string[];
+  elementData: Record<string, any>;
+  errors: Record<string, string>;
+  isProcessing: boolean;
+}
+
+// Actions pour le flux KYC
+export interface KYCFlowActions {
+  initializeFlow: (config: KYCFlowConfig) => void;
+  nextElement: () => void;
+  previousElement: () => void;
+  goToElement: (elementId: string) => void;
+  updateElementData: (elementId: string, data: any) => void;
+  validateElement: (elementId: string) => boolean;
+  submitFlow: () => Promise<void>;
+  resetFlow: () => void;
+}
+
+// Hook pour le flux KYC
+export interface UseKYCFlowReturn {
+  state: KYCFlowState;
+  actions: KYCFlowActions;
+  currentElement: KYCElement | null;
+  progress: number;
+  canGoNext: boolean;
+  canGoPrevious: boolean;
+  isComplete: boolean;
+}
+
+// ===== TYPES FOR ORIENTATION VIDEO PROCESSING =====
+
+// Orientation types for liveness detection
+export type OrientationType = 'center' | 'left' | 'right';
+
+// Individual orientation capture result
+export interface OrientationCapture {
+  captured: boolean;
+  frame: number | null;
+}
+
+// Complete orientation video processing result
+export interface OrientationVideoResult {
+  center: OrientationCapture;
+  right: OrientationCapture;
+  left: OrientationCapture;
+}
+
+// Orientation video processing request
+export interface OrientationVideoRequest {
+  file: string; // Base64 encoded video or file path
+}
+
+// Orientation video processing response
+export interface OrientationVideoResponse {
+  success: boolean;
+  data?: OrientationVideoResult;
+  error?: KYCError;
+  message?: string;
+}
+
+// Configuration for orientation video capture
+export interface OrientationVideoConfig {
+  duration: number; // Duration in seconds
+  orientations: OrientationType[];
+  instructions: Record<OrientationType, string>;
+  showPreview: boolean;
+  allowRetake: boolean;
+  maxRetakes: number;
+  quality: number;
+  aspectRatio: number;
+}
+
+// State for orientation video capture
+export interface OrientationVideoState {
+  isRecording: boolean;
+  currentOrientation: OrientationType | null;
+  recordedVideo: string | null;
+  processingResult: OrientationVideoResult | null;
+  isProcessing: boolean;
+  error: string | null;
+  retakeCount: number;
+}
+
+// Actions for orientation video capture
+export interface OrientationVideoActions {
+  startRecording: () => void;
+  stopRecording: () => void;
+  processVideo: () => Promise<OrientationVideoResult>;
+  retake: () => void;
+  reset: () => void;
+  setCurrentOrientation: (orientation: OrientationType) => void;
+}
+
+// ===== NOUVEAUX TYPES POUR TEMPLATE JSON =====
+
+// Types pour les labels et instructions multilingues
+export interface LocalizedText {
+  en: string;
+  fr: string;
+  [key: string]: string; // Support pour d'autres langues
+}
+
+// Configuration UI pour les composants
+export interface ComponentUI {
+  icon?: string;
+  themeColor?: string;
+  buttonText: LocalizedText;
+  backgroundColor?: string;
+  textColor?: string;
+  borderRadius?: number;
+}
+
+// Types de documents gouvernementaux supportés
+export type GovernmentDocumentType =
+  | 'id_card'
+  | 'passport'
+  | 'drivers_license'
+  | 'residence_permit'
+  | 'national_id'
+  | 'voter_id'
+  | 'military_id'
+  | 'student_id'
+  | 'work_permit'
+  | 'other';
+
+// Configuration spécifique pour chaque type de composant
+export interface IDCardConfig {
+  sides: string[];
+  allowed_formats: string[];
+  max_size_mb: number;
+  document_types: GovernmentDocumentType[]; // Types de documents disponibles
+  bbox_configs: Record<GovernmentDocumentType, {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+    borderColor?: string;
+    borderWidth?: number;
+    cornerRadius?: number;
+  }>;
+}
+
+
+export interface SelfieConfig {
+  liveness_check: boolean;
+  max_attempts: number;
+  orientations: ('front' | 'left' | 'right')[]; // Tableau d'orientations à capturer
+}
+
+export interface FileUploadConfig {
+  allowed_formats: string[];
+  max_size_mb: number;
+  required: boolean;
+}
+
+export interface LocationConfig {
+  accuracy: string;
+  required: boolean;
+}
+
+export interface CountrySelectionConfig {
+  allowed_countries: string[];
+  default_country: string;
+  required: boolean;
+}
+
+// Union type pour toutes les configurations
+export type ComponentConfig =
+  | IDCardConfig
+  | SelfieConfig
+  | FileUploadConfig
+  | LocationConfig
+  | CountrySelectionConfig;
+
+// Nouveau type de composant basé sur le template JSON
+export interface TemplateComponent {
+  id: number;
+  type: 'id_card' | 'selfie' | 'file_upload' | 'location' | 'country_selection';
+  order: number;
+  templateId?: number;
+  labels: LocalizedText;
+  instructions: LocalizedText;
+  ui: ComponentUI;
+  config: ComponentConfig;
+}
+
+// Template KYC complet
+export interface KYCTemplate {
+  id: number;
+  name: LocalizedText;
+  description: LocalizedText;
+  version: string;
+  components: TemplateComponent[];
+}
+
+// État pour le template KYC
+export interface TemplateState {
+  template: KYCTemplate;
+  currentComponentIndex: number;
+  completedComponents: number[];
+  componentData: Record<number, any>;
+  errors: Record<number, string>;
+  isProcessing: boolean;
+  currentLanguage: string;
+  showCustomStepper: boolean;
+}
+
+// Actions pour le template KYC
+export interface TemplateActions {
+  initializeTemplate: (template: KYCTemplate) => void;
+  nextComponent: () => void;
+  previousComponent: () => void;
+  goToComponent: (componentId: number) => void;
+  updateComponentData: (componentId: number, data: any) => void;
+  validateComponent: (componentId: number) => boolean;
+  submitTemplate: () => Promise<void>;
+  resetTemplate: () => void;
+  setLanguage: (language: string) => void;
+  showCustomStepper: (show: boolean) => void;
+}
+
+// Hook pour le template KYC
+export interface UseTemplateReturn {
+  state: TemplateState;
+  actions: TemplateActions;
+  currentComponent: TemplateComponent | null;
+  progress: number;
+  canGoNext: boolean;
+  canGoPrevious: boolean;
+  isComplete: boolean;
+  getLocalizedText: (text: LocalizedText) => string;
+} 

package/src/types/nativewind.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="nativewind/types" />
+