@umituz/react-native-auth 3.6.71 → 3.6.73

package/src/presentation/hooks/useAuthBottomSheet.ts

@@ -1,11 +1,15 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Platform } from "react-native";
 import type { BottomSheetModalRef } from "@umituz/react-native-design-system";
 import { useAuthModalStore } from "../stores/authModalStore";
 import { useAuth } from "../hooks/useAuth";
 import { useGoogleAuth, type GoogleAuthConfig } from "./useGoogleAuth";
 import { useAppleAuth } from "./useAppleAuth";
 import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
+import {
+  useAuthTransitions,
+  executeAfterAuth,
+} from "../utils/authTransition.util";
+import { determineEnabledProviders } from "../utils/socialAuthHandler.util";
 
 export interface SocialAuthConfiguration {
   google?: GoogleAuthConfig;
@@ -22,7 +26,7 @@ interface UseAuthBottomSheetParams {
 
 export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
   const { socialConfig, onGoogleSignIn, onAppleSignIn, onAuthSuccess } = params;
-  
+
   const modalRef = useRef<BottomSheetModalRef>(null);
   const [googleLoading, setGoogleLoading] = useState(false);
   const [appleLoading, setAppleLoading] = useState(false);
@@ -37,37 +41,14 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
 
   // Determine enabled providers
   const providers = useMemo<SocialAuthProvider[]>(() => {
-    const result: SocialAuthProvider[] = [];
-
-    if (Platform.OS === "ios" && socialConfig?.apple?.enabled && appleAvailable) {
-      result.push("apple");
-    }
-
-    if (googleConfigured) {
-      result.push("google");
-    }
-
-    return result;
-  }, [socialConfig?.apple?.enabled, appleAvailable, googleConfigured]);
+    return determineEnabledProviders(socialConfig, appleAvailable, googleConfigured);
+  }, [socialConfig, appleAvailable, googleConfigured]);
 
   // Handle visibility sync with modalRef
   useEffect(() => {
-    if (__DEV__) {
-      console.log('[useAuthBottomSheet] Visibility changed:', {
-        isVisible,
-        hasModalRef: !!modalRef.current,
-        modalRefMethods: modalRef.current ? Object.keys(modalRef.current) : [],
-      });
-    }
     if (isVisible) {
-      if (__DEV__) {
-        console.log('[useAuthBottomSheet] Calling present()');
-      }
       modalRef.current?.present();
     } else {
-      if (__DEV__) {
-        console.log('[useAuthBottomSheet] Calling dismiss()');
-      }
       modalRef.current?.dismiss();
     }
   }, [isVisible]);
@@ -82,61 +63,24 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
     handleDismiss();
   }, [handleDismiss]);
 
-  const prevIsAuthenticatedRef = useRef(isAuthenticated);
-  const prevIsVisibleRef = useRef(isVisible);
-  const prevIsAnonymousRef = useRef(isAnonymous);
-
-  useEffect(() => {
-    const justAuthenticated = !prevIsAuthenticatedRef.current && isAuthenticated;
-    const justConvertedFromAnonymous = prevIsAnonymousRef.current && !isAnonymous && isAuthenticated;
-
-    if (__DEV__) {
-      console.log("[useAuthBottomSheet] Auth state effect:", {
-        isAuthenticated,
-        isAnonymous,
-        isVisible,
-        prevIsAuthenticated: prevIsAuthenticatedRef.current,
-        prevIsAnonymous: prevIsAnonymousRef.current,
-        justAuthenticated,
-        justConvertedFromAnonymous,
-        willClose: (justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous,
-      });
-    }
-
-    let timeoutId: NodeJS.Timeout | undefined;
-
-    if ((justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous) {
-      if (__DEV__) {
-        console.log("[useAuthBottomSheet] Auto-closing due to successful authentication transition", {
-          justAuthenticated,
-          justConvertedFromAnonymous,
+  // Handle auth transitions
+  useAuthTransitions(
+    { isAuthenticated, isAnonymous, isVisible },
+    (result) => {
+      if (result.shouldClose) {
+        modalRef.current?.dismiss();
+        hideAuthModal();
+        onAuthSuccess?.();
+
+        const timeoutId = executeAfterAuth(() => {
+          executePendingCallback();
         });
-      }
-      // Close modal and hide first
-      modalRef.current?.dismiss();
-      hideAuthModal();
-      // Notify auth success
-      onAuthSuccess?.();
-      // Execute callback with delay to ensure auth state has propagated
-      timeoutId = setTimeout(() => {
-        if (__DEV__) {
-          console.log("[useAuthBottomSheet] Executing pending callback after auth");
-        }
-        executePendingCallback();
-      }, 100);
-    }
 
-    prevIsAuthenticatedRef.current = isAuthenticated;
-    prevIsVisibleRef.current = isVisible;
-    prevIsAnonymousRef.current = isAnonymous;
-
-    // Cleanup timeout on unmount or dependency change
-    return () => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+        // Cleanup timeout on unmount
+        return () => clearTimeout(timeoutId);
       }
-    };
-  }, [isAuthenticated, isVisible, isAnonymous, executePendingCallback, hideAuthModal, onAuthSuccess]);
+    }
+  );
 
   const handleNavigateToRegister = useCallback(() => {
     setMode("register");

package/src/presentation/hooks/useGoogleAuth.ts

@@ -87,9 +87,6 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
           .catch((error) => {
             const errorMessage = error instanceof Error ? error.message : "Firebase sign-in failed";
             setGoogleError(errorMessage);
-            if (__DEV__) {
-              console.error("[useGoogleAuth] Firebase sign-in failed:", error);
-            }
           })
           .finally(() => {
             setIsLoading(false);

package/src/presentation/hooks/useLoginForm.ts

@@ -1,7 +1,7 @@
 import { useState, useCallback } from "react";
 import { useAuth } from "./useAuth";
 import { getAuthErrorLocalizationKey, resolveErrorMessage } from "../utils/getAuthErrorMessage";
-import { validateEmail, validatePasswordForLogin } from "../../infrastructure/utils/AuthValidation";
+import { validateLoginForm } from "../utils/form/formValidation.util";
 import { alertService } from "@umituz/react-native-design-system";
 
 export interface LoginFormTranslations {
@@ -42,45 +42,44 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     return resolveErrorMessage(key, translations?.errors);
   }, [translations]);
 
+  const clearErrors = useCallback(() => {
+    setEmailError(null);
+    setPasswordError(null);
+    setLocalError(null);
+  }, []);
+
   const handleEmailChange = useCallback(
     (text: string) => {
       setEmail(text);
-      if (emailError) setEmailError(null);
-      if (localError) setLocalError(null);
+      if (emailError || localError) clearErrors();
     },
-    [emailError, localError],
+    [emailError, localError, clearErrors],
   );
 
   const handlePasswordChange = useCallback(
     (text: string) => {
       setPassword(text);
-      if (passwordError) setPasswordError(null);
-      if (localError) setLocalError(null);
+      if (passwordError || localError) clearErrors();
     },
-    [passwordError, localError],
+    [passwordError, localError, clearErrors],
   );
 
   const handleSignIn = useCallback(async () => {
-    setEmailError(null);
-    setPasswordError(null);
-    setLocalError(null);
-
-    let hasError = false;
+    clearErrors();
 
-    const emailResult = validateEmail(email.trim());
-    if (!emailResult.isValid && emailResult.error) {
-      setEmailError(getErrorMessage(emailResult.error));
-      hasError = true;
-    }
+    const validation = validateLoginForm(
+      { email: email.trim(), password },
+      getErrorMessage
+    );
 
-    const passwordResult = validatePasswordForLogin(password);
-    if (!passwordResult.isValid && passwordResult.error) {
-      setPasswordError(getErrorMessage(passwordResult.error));
-      hasError = true;
+    if (!validation.isValid) {
+      for (const error of validation.errors) {
+        if (error.field === "email") setEmailError(error.message);
+        if (error.field === "password") setPasswordError(error.message);
+      }
+      return;
     }
 
-    if (hasError) return;
-
     try {
       await signIn(email.trim(), password);
 
@@ -92,18 +91,15 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
       }
     } catch (err: unknown) {
       const localizationKey = getAuthErrorLocalizationKey(err);
-      const errorMessage = getErrorMessage(localizationKey);
-      setLocalError(errorMessage);
+      setLocalError(getErrorMessage(localizationKey));
     }
-  }, [email, password, signIn, translations, getErrorMessage]);
+  }, [email, password, signIn, translations, getErrorMessage, clearErrors]);
 
   const handleContinueAnonymously = useCallback(async () => {
     try {
       await continueAnonymously();
-    } catch (error) {
-      if (__DEV__) {
-        console.warn("[useLoginForm] Continue anonymously failed:", error);
-      }
+    } catch {
+      // Silently fail - anonymous mode is optional
     }
   }, [continueAnonymously]);
 

package/src/presentation/hooks/useProfileEdit.ts

@@ -1,88 +1,80 @@
 /**
- * useProfileEdit Hook
+ * Profile Edit Hook
  * Simple profile editing with form state management
  * Apps provide image picker and backend update logic
  */
 
 import { useState, useCallback } from "react";
-import { validateEmail } from "../../infrastructure/utils/AuthValidation";
+import { validateProfileForm } from "../utils/form/formValidation.util";
 
 export interface ProfileEditFormState {
-    displayName: string;
-    email: string;
-    photoURL: string | null;
-    isModified: boolean;
+  displayName: string;
+  email: string;
+  photoURL: string | null;
+  isModified: boolean;
 }
 
 export interface UseProfileEditReturn {
-    formState: ProfileEditFormState;
-    setDisplayName: (value: string) => void;
-    setEmail: (value: string) => void;
-    setPhotoURL: (value: string | null) => void;
-    resetForm: (initial: Partial<ProfileEditFormState>) => void;
-    validateForm: () => { isValid: boolean; errors: string[] };
+  formState: ProfileEditFormState;
+  setDisplayName: (value: string) => void;
+  setEmail: (value: string) => void;
+  setPhotoURL: (value: string | null) => void;
+  resetForm: (initial: Partial<ProfileEditFormState>) => void;
+  validateForm: () => { isValid: boolean; errors: string[] };
 }
 
 export const useProfileEdit = (
-    initialState: Partial<ProfileEditFormState> = {},
+  initialState: Partial<ProfileEditFormState> = {},
 ): UseProfileEditReturn => {
-    const [formState, setFormState] = useState<ProfileEditFormState>({
-        displayName: initialState.displayName || "",
-        email: initialState.email || "",
-        photoURL: initialState.photoURL || null,
-        isModified: false,
-    });
-
-    const setDisplayName = useCallback((value: string) => {
-        setFormState((prev) => ({ ...prev, displayName: value, isModified: true }));
-    }, []);
-
-    const setEmail = useCallback((value: string) => {
-        setFormState((prev) => ({ ...prev, email: value, isModified: true }));
-    }, []);
-
-    const setPhotoURL = useCallback((value: string | null) => {
-        setFormState((prev) => ({ ...prev, photoURL: value, isModified: true }));
-    }, []);
+  const [formState, setFormState] = useState<ProfileEditFormState>({
+    displayName: initialState.displayName || "",
+    email: initialState.email || "",
+    photoURL: initialState.photoURL || null,
+    isModified: false,
+  });
 
-    const resetForm = useCallback((initial: Partial<ProfileEditFormState>) => {
-        setFormState({
-            displayName: initial.displayName || "",
-            email: initial.email || "",
-            photoURL: initial.photoURL || null,
-            isModified: false,
-        });
-    }, []);
+  const setDisplayName = useCallback((value: string) => {
+    setFormState((prev) => ({ ...prev, displayName: value, isModified: true }));
+  }, []);
 
-    const validateForm = useCallback((): {
-        isValid: boolean;
-        errors: string[];
-    } => {
-        const errors: string[] = [];
+  const setEmail = useCallback((value: string) => {
+    setFormState((prev) => ({ ...prev, email: value, isModified: true }));
+  }, []);
 
-        if (!formState.displayName.trim()) {
-            errors.push("Display name is required");
-        }
+  const setPhotoURL = useCallback((value: string | null) => {
+    setFormState((prev) => ({ ...prev, photoURL: value, isModified: true }));
+  }, []);
 
-        if (formState.email) {
-            const emailResult = validateEmail(formState.email);
-            if (!emailResult.isValid && emailResult.error) {
-                errors.push(emailResult.error);
-            }
-        }
+  const resetForm = useCallback((initial: Partial<ProfileEditFormState>) => {
+    setFormState({
+      displayName: initial.displayName || "",
+      email: initial.email || "",
+      photoURL: initial.photoURL || null,
+      isModified: false,
+    });
+  }, []);
 
-        return {
-            isValid: errors.length === 0,
-            errors,
-        };
-    }, [formState]);
+  const validateForm = useCallback((): {
+    isValid: boolean;
+    errors: string[];
+  } => {
+    const result = validateProfileForm({
+      displayName: formState.displayName,
+      email: formState.email,
+    });
 
     return {
-        formState,
-        setDisplayName,
-        setEmail,
-        setPhotoURL,
-        resetForm,
-        validateForm,
+      isValid: result.isValid,
+      errors: result.errors.map((e) => e.message),
     };
+  }, [formState]);
+
+  return {
+    formState,
+    setDisplayName,
+    setEmail,
+    setPhotoURL,
+    resetForm,
+    validateForm,
+  };
 };

package/src/presentation/hooks/useRegisterForm.ts

@@ -1,16 +1,22 @@
 import { useState, useCallback, useMemo } from "react";
 import {
-  validateEmail,
   validatePasswordForRegister,
-  validatePasswordConfirmation,
+  type PasswordRequirements,
 } from "../../infrastructure/utils/AuthValidation";
 import { DEFAULT_PASSWORD_CONFIG } from "../../domain/value-objects/AuthConfig";
 import { useAuth } from "./useAuth";
 import { getAuthErrorLocalizationKey, resolveErrorMessage } from "../utils/getAuthErrorMessage";
-import type { PasswordRequirements } from "../../infrastructure/utils/AuthValidation";
+import { validateRegisterForm, errorsToFieldErrors } from "../utils/form/formValidation.util";
 import { alertService } from "@umituz/react-native-design-system";
 import { clearFieldErrors, clearFieldError } from "../utils/form/formErrorUtils";
 
+export type FieldErrors = {
+  displayName?: string;
+  email?: string;
+  password?: string;
+  confirmPassword?: string;
+};
+
 export interface RegisterFormTranslations {
   successTitle: string;
   signUpSuccess: string;
@@ -26,12 +32,7 @@ export interface UseRegisterFormResult {
   email: string;
   password: string;
   confirmPassword: string;
-  fieldErrors: {
-    displayName?: string;
-    email?: string;
-    password?: string;
-    confirmPassword?: string;
-  };
+  fieldErrors: FieldErrors;
   localError: string | null;
   loading: boolean;
   passwordRequirements: PasswordRequirements;
@@ -53,12 +54,7 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
   const [password, setPassword] = useState("");
   const [confirmPassword, setConfirmPassword] = useState("");
   const [localError, setLocalError] = useState<string | null>(null);
-  const [fieldErrors, setFieldErrors] = useState<{
-    displayName?: string;
-    email?: string;
-    password?: string;
-    confirmPassword?: string;
-  }>({});
+  const [fieldErrors, setFieldErrors] = useState<FieldErrors>({});
 
   const getErrorMessage = useCallback((key: string) => {
     return resolveErrorMessage(key, translations?.errors);
@@ -76,49 +72,51 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     return password.length > 0 && password === confirmPassword;
   }, [password, confirmPassword]);
 
+  const clearFormErrors = useCallback(() => {
+    setLocalError(null);
+    setFieldErrors({});
+  }, []);
+
   const handleDisplayNameChange = useCallback((text: string) => {
     setDisplayName(text);
     clearFieldError(setFieldErrors, "displayName");
-    setLocalError(null);
-  }, []);
+    if (localError) setLocalError(null);
+  }, [localError]);
 
   const handleEmailChange = useCallback((text: string) => {
     setEmail(text);
     clearFieldError(setFieldErrors, "email");
-    setLocalError(null);
-  }, []);
+    if (localError) setLocalError(null);
+  }, [localError]);
 
   const handlePasswordChange = useCallback((text: string) => {
     setPassword(text);
     clearFieldErrors(setFieldErrors, ["password", "confirmPassword"]);
-    setLocalError(null);
-  }, []);
+    if (localError) setLocalError(null);
+  }, [localError]);
 
   const handleConfirmPasswordChange = useCallback((text: string) => {
     setConfirmPassword(text);
     clearFieldError(setFieldErrors, "confirmPassword");
-    setLocalError(null);
-  }, []);
+    if (localError) setLocalError(null);
+  }, [localError]);
 
   const handleSignUp = useCallback(async () => {
-    setLocalError(null);
-    setFieldErrors({});
-
-    const emailResult = validateEmail(email.trim());
-    if (!emailResult.isValid && emailResult.error) {
-      setFieldErrors((prev) => ({ ...prev, email: getErrorMessage(emailResult.error!) }));
-      return;
-    }
-
-    const passwordResult = validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG);
-    if (!passwordResult.isValid && passwordResult.error) {
-      setFieldErrors((prev) => ({ ...prev, password: getErrorMessage(passwordResult.error!) }));
-      return;
-    }
-
-    const confirmResult = validatePasswordConfirmation(password, confirmPassword);
-    if (!confirmResult.isValid && confirmResult.error) {
-      setFieldErrors((prev) => ({ ...prev, confirmPassword: getErrorMessage(confirmResult.error!) }));
+    clearFormErrors();
+
+    const validation = validateRegisterForm(
+      {
+        displayName: displayName.trim() || undefined,
+        email: email.trim(),
+        password,
+        confirmPassword,
+      },
+      getErrorMessage,
+      DEFAULT_PASSWORD_CONFIG
+    );
+
+    if (!validation.isValid) {
+      setFieldErrors(errorsToFieldErrors(validation.errors));
       return;
     }
 
@@ -130,10 +128,9 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
       }
     } catch (err: unknown) {
       const localizationKey = getAuthErrorLocalizationKey(err);
-      const errorMessage = getErrorMessage(localizationKey);
-      setLocalError(errorMessage);
+      setLocalError(getErrorMessage(localizationKey));
     }
-  }, [displayName, email, password, confirmPassword, signUp, translations, getErrorMessage]);
+  }, [displayName, email, password, confirmPassword, signUp, translations, getErrorMessage, clearFormErrors]);
 
   const displayError = localError || error;
 

package/src/presentation/providers/AuthProvider.tsx

@@ -66,9 +66,6 @@ export function AuthProvider({ children, ErrorFallback = DefaultErrorFallback }:
       unsubscribe = initializeAuthListener();
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error("Unknown initialization error");
-      if (__DEV__) {
-        console.error("[AuthProvider] Initialization failed:", errorObj);
-      }
       setError(errorObj);
     }
 
@@ -76,10 +73,8 @@ export function AuthProvider({ children, ErrorFallback = DefaultErrorFallback }:
       if (unsubscribe) {
         try {
           unsubscribe();
-        } catch (cleanupError) {
-          if (__DEV__) {
-            console.warn("[AuthProvider] Cleanup failed:", cleanupError);
-          }
+        } catch {
+          // Silently fail - cleanup errors are handled elsewhere
         }
       }
     };

package/src/presentation/stores/authModalStore.ts

@@ -53,13 +53,6 @@ export const useAuthModalStore = createStore<AuthModalState, AuthModalActions>({
       callback?: () => void | Promise<void>,
       mode: AuthModalMode = "login",
     ) => {
-      if (__DEV__) {
-        console.log("[authModalStore] showAuthModal called:", {
-          mode,
-          hasCallback: !!callback,
-          currentVisible: get().isVisible,
-        });
-      }
       set({
         isVisible: true,
         mode,

package/src/presentation/stores/authStore.ts

@@ -45,36 +45,18 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
     }
     return { ...initialAuthState, ...state };
   },
-  actions: (set, get) => ({
+  actions: (set, _get) => ({
     setFirebaseUser: (firebaseUser) => {
-      const prevState = get();
       const user = firebaseUser ? mapToAuthUser(firebaseUser) : null;
       const isAnonymous = firebaseUser?.isAnonymous ?? false;
-
-      if (__DEV__) {
-        console.log("[AuthStore] setFirebaseUser:", {
-          uid: firebaseUser?.uid ?? null,
-          isAnonymous,
-          prevIsAnonymous: prevState.isAnonymous,
-          hasUser: !!user,
-        });
-      }
-
       set({ firebaseUser, user, loading: false, isAnonymous });
     },
 
     setLoading: (loading) => {
-      if (__DEV__) {
-        console.log("[AuthStore] setLoading:", loading);
-      }
       set({ loading });
     },
 
     setIsAnonymous: (isAnonymous) => {
-      const { firebaseUser } = get();
-      if (__DEV__) {
-        console.log("[AuthStore] setIsAnonymous:", { isAnonymous, hasFirebaseUser: !!firebaseUser });
-      }
       // Only update the isAnonymous flag
       // The user object will be updated by setFirebaseUser when needed
       // This prevents inconsistencies between firebaseUser and user
@@ -82,23 +64,14 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
     },
 
     setError: (error) => {
-      if (__DEV__ && error) {
-        console.log("[AuthStore] setError:", error);
-      }
       set({ error });
     },
 
     setInitialized: (initialized) => {
-      if (__DEV__) {
-        console.log("[AuthStore] setInitialized:", initialized);
-      }
       set({ initialized });
     },
 
     reset: () => {
-      if (__DEV__) {
-        console.log("[AuthStore] reset");
-      }
       set(initialAuthState);
     },
   }),