@transfergratis/react-native-sdk 0.1.3 → 0.1.5

package/src/hooks/useI18n.ts

@@ -0,0 +1,53 @@
+import { useCallback, useEffect, useState } from 'react';
+import {  setLocale, getCurrentLocale, getAvailableLocales, translate, translatePlural } from '../i18n';
+
+export interface UseI18nReturn {
+  t: (key: string, options?: any) => string;
+  tPlural: (key: string, count: number, options?: any) => string;
+  locale: string;
+  setLocale: (locale: string) => void;
+  availableLocales: string[];
+  isRTL: boolean;
+}
+
+export const useI18n = (): UseI18nReturn => {
+  const [locale, setCurrentLocale] = useState(getCurrentLocale());
+  const [isRTL, setIsRTL] = useState(false);
+
+  // Update locale state when i18n locale changes
+  useEffect(() => {
+    const updateLocale = () => {
+      setCurrentLocale(getCurrentLocale());
+      // Check if current locale is RTL (Arabic, Hebrew, etc.)
+      setIsRTL(['ar', 'he', 'fa', 'ur'].includes(getCurrentLocale()));
+    };
+
+    // Listen for locale changes (if i18n supports events)
+    updateLocale();
+  }, []);
+
+  const handleSetLocale = useCallback((newLocale: string) => {
+    setLocale(newLocale);
+    setCurrentLocale(newLocale);
+    setIsRTL(['ar', 'he', 'fa', 'ur'].includes(newLocale));
+  }, []);
+
+  const t = useCallback((key: string, options?: any) => {
+    return translate(key, options);
+  }, [locale]);
+
+  const tPlural = useCallback((key: string, count: number, options?: any) => {
+    return translatePlural(key, count, options);
+  }, [locale]);
+
+  return {
+    t,
+    tPlural,
+    locale,
+    setLocale: handleSetLocale,
+    availableLocales: getAvailableLocales(),
+    isRTL,
+  };
+};
+
+export default useI18n;

package/src/hooks/useOrientationVideo.ts

@@ -6,7 +6,7 @@ import {
   OrientationVideoResult,
   OrientationType 
 } from '../types/KYC.types';
-import KYCService from '../modules/api/KYCService';
+import kycService from '../modules/api/KYCService';
 
 export interface UseOrientationVideoReturn {
   state: OrientationVideoState;
@@ -15,7 +15,7 @@ export interface UseOrientationVideoReturn {
 }
 
 export const useOrientationVideo = (
-  kycService: KYCService,
+  
   config?: Partial<OrientationVideoConfig>
 ): UseOrientationVideoReturn => {
   const defaultConfig: OrientationVideoConfig = {

package/src/hooks/useRealtimeVerifier.ts

@@ -0,0 +1,128 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export type CaptureFunction = () => Promise<{ success: boolean; uri?: string; error?: string }>;
+export type VerifyFunction = (uri: string) => Promise<boolean>;
+
+export interface RealtimeVerifierConfig {
+  intervalMs?: number; // default 5000
+  maxAttempts?: number; // default Infinity
+  stopOnError?: boolean; // default false
+}
+
+export interface RealtimeVerifierState {
+  isRunning: boolean;
+  attempts: number;
+  lastError?: string | null;
+  verifiedUri?: string | null;
+}
+
+export interface RealtimeVerifierControls {
+  start: () => void;
+  stop: () => void;
+  reset: () => void;
+}
+
+export function useRealtimeVerifier(
+  capture: CaptureFunction,
+  verify: VerifyFunction,
+  config?: RealtimeVerifierConfig,
+): { state: RealtimeVerifierState; controls: RealtimeVerifierControls } {
+  const { intervalMs = 5000, maxAttempts = Number.POSITIVE_INFINITY, stopOnError = false } = config || {};
+
+  const [state, setState] = useState<RealtimeVerifierState>({
+    isRunning: false,
+    attempts: 0,
+    lastError: null,
+    verifiedUri: null,
+  });
+
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const runningRef = useRef<boolean>(false);
+  const attemptsRef = useRef<number>(0);
+
+  const tick = useCallback(async () => {
+    if (!runningRef.current) return;
+    if (attemptsRef.current >= maxAttempts) {
+      runningRef.current = false;
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+        timerRef.current = null;
+      }
+      setState(prev => ({ ...prev, isRunning: false }));
+      return;
+    }
+
+    attemptsRef.current += 1;
+    setState(prev => ({ ...prev, attempts: attemptsRef.current }));
+
+    try {
+      const captureResult = await capture();
+      if (!captureResult.success || !captureResult.uri) {
+        if (stopOnError) {
+          throw new Error(captureResult.error || 'Capture failed');
+        }
+        setState(prev => ({ ...prev, lastError: captureResult.error || 'Capture failed' }));
+        return;
+      }
+
+      const ok = await verify(captureResult.uri);
+      if (ok) {
+        runningRef.current = false;
+        if (timerRef.current) {
+          clearInterval(timerRef.current);
+          timerRef.current = null;
+        }
+        setState(prev => ({ ...prev, isRunning: false, verifiedUri: captureResult.uri, lastError: null }));
+      }
+    } catch (err: any) {
+      const message = err?.message || 'Unknown error';
+      if (stopOnError) {
+        runningRef.current = false;
+        if (timerRef.current) {
+          clearInterval(timerRef.current);
+          timerRef.current = null;
+        }
+        setState(prev => ({ ...prev, isRunning: false, lastError: message }));
+        return;
+      }
+      setState(prev => ({ ...prev, lastError: message }));
+    }
+  }, [capture, verify, maxAttempts, stopOnError]);
+
+  const start = useCallback(() => {
+    if (runningRef.current) return;
+    runningRef.current = true;
+    setState(prev => ({ ...prev, isRunning: true, lastError: null }));
+    // Fire immediately, then every interval
+    tick();
+    timerRef.current = setInterval(tick, intervalMs);
+  }, [intervalMs, tick]);
+
+  const stop = useCallback(() => {
+    runningRef.current = false;
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    setState(prev => ({ ...prev, isRunning: false }));
+  }, []);
+
+  const reset = useCallback(() => {
+    attemptsRef.current = 0;
+    setState({ isRunning: false, attempts: 0, lastError: null, verifiedUri: null });
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+      }
+    };
+  }, []);
+
+  return { state, controls: { start, stop, reset } };
+}
+
+export default useRealtimeVerifier;
+
+