@umituz/react-native-auth 3.6.75 → 3.6.77

package/src/presentation/utils/authTransition.util.ts

@@ -22,11 +22,12 @@ export interface AuthTransitionResult {
  */
 export function useAuthTransitions(
   state: AuthTransitionState,
-  onTransition?: (result: AuthTransitionResult) => void
+  onTransition?: (result: AuthTransitionResult) => (() => void) | void
 ): void {
   const prevIsAuthenticatedRef = useRef(state.isAuthenticated);
   const prevIsAnonymousRef = useRef(state.isAnonymous);
   const prevIsVisibleRef = useRef(state.isVisible);
+  const cleanupRef = useRef<(() => void) | null>(null);
 
   useEffect(() => {
     const justAuthenticated = !prevIsAuthenticatedRef.current && state.isAuthenticated;
@@ -41,11 +42,21 @@ export function useAuthTransitions(
       shouldClose,
     };
 
-    onTransition?.(result);
+    // Call previous cleanup before running new transition
+    cleanupRef.current?.();
+
+    const cleanup = onTransition?.(result);
+    cleanupRef.current = cleanup ?? null;
 
     prevIsAuthenticatedRef.current = state.isAuthenticated;
     prevIsVisibleRef.current = state.isVisible;
     prevIsAnonymousRef.current = state.isAnonymous;
+
+    // Return cleanup function for useEffect
+    return () => {
+      cleanupRef.current?.();
+      cleanupRef.current = null;
+    };
   }, [state.isAuthenticated, state.isVisible, state.isAnonymous, onTransition]);
 }
 

package/src/presentation/utils/form/useFormField.hook.ts

@@ -0,0 +1,97 @@
+/**
+ * Shared Form Field Hook
+ * Provides reusable form field state management with automatic error clearing
+ */
+
+import { useCallback, useState } from "react";
+
+export interface UseFormFieldOptions {
+  clearLocalError?: () => void;
+  fieldsToClear?: string[];
+}
+
+export interface UseFormFieldResult {
+  value: string;
+  error: string | null;
+  setValue: (value: string) => void;
+  setError: (error: string | null) => void;
+  clearError: () => void;
+  handleChange: (text: string) => void;
+}
+
+/**
+ * Hook for managing a single form field with automatic error clearing
+ * @param initialValue - Initial field value
+ * @param setError - Function to set field error in parent state
+ * @param options - Additional options
+ * @returns Field state and handlers
+ */
+export function useFormField(
+  initialValue: string,
+  setError: (error: string | null) => void,
+  options?: UseFormFieldOptions
+): UseFormFieldResult {
+  const [value, setValue] = useState(initialValue);
+  const [error, setLocalError] = useState<string | null>(null);
+
+  const clearError = useCallback(() => {
+    setLocalError(null);
+    setError(null);
+    options?.clearLocalError?.();
+  }, [setError, options]);
+
+  const handleChange = useCallback(
+    (text: string) => {
+      setValue(text);
+      if (error || options?.clearLocalError) {
+        clearError();
+      }
+    },
+    [error, options, clearError]
+  );
+
+  return {
+    value,
+    error,
+    setValue,
+    setError: setLocalError,
+    clearError,
+    handleChange,
+  };
+}
+
+/**
+ * Hook for managing multiple form fields
+ * @param initialFields - Initial field values
+ * @param setFieldErrors - Function to set field errors in parent state
+ * @param options - Additional options
+ * @returns Field states and handlers
+ */
+export function useFormFields<T extends Record<string, string>>(
+  initialFields: T,
+  setFieldErrors: ((errors: Partial<Record<string, string>> | ((prev: Partial<Record<string, string>>) => Partial<Record<string, string>>)) => void) | null,
+  options?: UseFormFieldOptions
+) {
+  type FieldKey = keyof T;
+
+  const [fields, setFields] = useState<T>(initialFields);
+
+  const updateField = useCallback(
+    (field: FieldKey, value: string) => {
+      setFields((prev) => ({ ...prev, [field]: value }));
+      // Note: setFieldErrors is handled externally by form hooks
+      options?.clearLocalError?.();
+    },
+    [options]
+  );
+
+  const resetFields = useCallback(() => {
+    setFields(initialFields);
+  }, [initialFields]);
+
+  return {
+    fields,
+    updateField,
+    resetFields,
+  };
+}

package/src/presentation/utils/form/usePasswordValidation.hook.ts

@@ -0,0 +1,87 @@
+/**
+ * Password Validation Hook
+ * Provides reusable password validation logic with requirements tracking
+ */
+
+import { useMemo } from "react";
+import {
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+  type PasswordRequirements,
+  type ValidationResult,
+} from "../../../infrastructure/utils/AuthValidation";
+import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
+
+export interface UsePasswordValidationResult {
+  passwordRequirements: PasswordRequirements;
+  passwordsMatch: boolean;
+  isValid: boolean;
+  confirmationError: string | null;
+}
+
+export interface UsePasswordValidationOptions {
+  passwordConfig?: PasswordConfig;
+}
+
+/**
+ * Hook for password validation with requirements tracking
+ * @param password - Password value
+ * @param confirmPassword - Confirm password value
+ * @param options - Validation options
+ * @returns Password validation state
+ */
+export function usePasswordValidation(
+  password: string,
+  confirmPassword: string,
+  options?: UsePasswordValidationOptions
+): UsePasswordValidationResult {
+  const config = options?.passwordConfig;
+
+  const passwordRequirements = useMemo((): PasswordRequirements => {
+    if (!password || !config) {
+      return { hasMinLength: false };
+    }
+    const result = validatePasswordForRegister(password, config);
+    return result.requirements;
+  }, [password, config]);
+
+  const passwordsMatch = useMemo(() => {
+    if (!password || !confirmPassword) {
+      return false;
+    }
+    return password === confirmPassword;
+  }, [password, confirmPassword]);
+
+  const confirmationError = useMemo(() => {
+    if (!confirmPassword) {
+      return null;
+    }
+    const result = validatePasswordConfirmation(password, confirmPassword);
+    return result.error ?? null;
+  }, [password, confirmPassword]);
+
+  const isValid = useMemo(() => {
+    return passwordRequirements.hasMinLength && passwordsMatch;
+  }, [passwordRequirements, passwordsMatch]);
+
+  return {
+    passwordRequirements,
+    passwordsMatch,
+    isValid,
+    confirmationError,
+  };
+}
+
+/**
+ * Hook for login password validation (simpler, no requirements)
+ * @param password - Password value
+ * @returns Validation result
+ */
+export function useLoginPasswordValidation(password: string): ValidationResult {
+  return useMemo(() => {
+    if (!password || password.length === 0) {
+      return { isValid: false, error: "auth.validation.passwordRequired" };
+    }
+    return { isValid: true };
+  }, [password]);
+}

package/src/presentation/utils/getAuthErrorMessage.ts

@@ -32,52 +32,29 @@ export function getAuthErrorLocalizationKey(error: unknown): string {
   };
 
   // Check error name for specific error types
-  if (error.name === "AuthInvalidEmailError") {
-    return "auth.errors.invalidEmail";
-  }
-  if (error.name === "AuthWeakPasswordError") {
-    return "auth.errors.weakPassword";
-  }
-  if (error.name === "AuthUserNotFoundError") {
-    return "auth.errors.userNotFound";
-  }
-  if (error.name === "AuthWrongPasswordError") {
-    return "auth.errors.wrongPassword";
-  }
-  if (error.name === "AuthEmailAlreadyInUseError") {
-    return "auth.errors.emailAlreadyInUse";
-  }
-  if (error.name === "AuthNetworkError") {
-    return "auth.errors.networkError";
-  }
-  if (error.name === "AuthConfigurationError") {
-    return "auth.errors.configurationError";
-  }
-  if (error.name === "AuthInitializationError") {
-    return "auth.errors.authNotInitialized";
+  const errorNameMap: Record<string, string> = {
+    AuthInvalidEmailError: "auth.errors.invalidEmail",
+    AuthWeakPasswordError: "auth.errors.weakPassword",
+    AuthUserNotFoundError: "auth.errors.userNotFound",
+    AuthWrongPasswordError: "auth.errors.wrongPassword",
+    AuthEmailAlreadyInUseError: "auth.errors.emailAlreadyInUse",
+    AuthNetworkError: "auth.errors.networkError",
+    AuthConfigurationError: "auth.errors.configurationError",
+    AuthInitializationError: "auth.errors.authNotInitialized",
+  };
+
+  // First check by error name (most specific)
+  const mappedByName = errorNameMap[error.name];
+  if (mappedByName) {
+    return mappedByName;
   }
 
-  // Use code if available
+  // Then check by error code
   if (code && errorCodeMap[code]) {
     return errorCodeMap[code];
   }
 
-  // Check error message for specific patterns
-  const message = error.message.toLowerCase();
-  if (message.includes("too many requests")) {
-    return "auth.errors.tooManyRequests";
-  }
-  if (message.includes("user account has been disabled") || message.includes("user disabled")) {
-    return "auth.errors.userDisabled";
-  }
-  if (message.includes("not properly configured") || message.includes("configuration")) {
-    return "auth.errors.configurationError";
-  }
-  if (message.includes("not enabled") || message.includes("operation not allowed")) {
-    return "auth.errors.operationNotAllowed";
-  }
-
-  // Default to unknown error
+  // Default to unknown error - don't leak system information through error messages
   return "auth.errors.unknownError";
 }
 

package/src/presentation/utils/socialAuthHandler.util.ts

@@ -20,34 +20,24 @@ export interface SocialAuthConfig {
 }
 
 /**
- * Hook for managing social auth loading states
+ * Hook for managing a single social auth provider's loading state
+ * @returns Loading state and handler creator
  */
 export function useSocialAuthLoading() {
   const [googleLoading, setGoogleLoading] = useState(false);
   const [appleLoading, setAppleLoading] = useState(false);
 
-  const createGoogleHandler = useCallback(
-    (handler: () => Promise<void>) => {
+  const createHandler = useCallback(
+    (setter: (loading: boolean) => void, signInHandler?: () => Promise<void>) => {
       return async () => {
-        setGoogleLoading(true);
-        try {
-          await handler();
-        } finally {
-          setGoogleLoading(false);
+        if (!signInHandler) {
+          throw new Error("Sign-in handler not available");
         }
-      };
-    },
-    []
-  );
-
-  const createAppleHandler = useCallback(
-    (handler: () => Promise<void>) => {
-      return async () => {
-        setAppleLoading(true);
+        setter(true);
         try {
-          await handler();
+          await signInHandler();
         } finally {
-          setAppleLoading(false);
+          setter(false);
         }
       };
     },
@@ -59,8 +49,7 @@ export function useSocialAuthLoading() {
     appleLoading,
     setGoogleLoading,
     setAppleLoading,
-    createGoogleHandler,
-    createAppleHandler,
+    createHandler,
   };
 }
 
@@ -86,21 +75,15 @@ export function determineEnabledProviders(
 }
 
 /**
- * Create social auth handlers
+ * Select the appropriate sign-in handler from external and internal options
+ * @param externalHandler - External handler provided by parent
+ * @param internalHandler - Internal handler from auth hook
+ * @returns The selected handler or undefined
  */
-export function createSocialAuthHandlers(
-  googleSignIn: (() => Promise<void>) | undefined,
-  appleSignIn: (() => Promise<void>) | undefined,
-  internalGoogleHandler: (() => Promise<void>) | undefined,
-  internalAppleHandler: (() => Promise<void>) | undefined
-): SocialAuthHandlers {
-  const googleHandler = googleSignIn || internalGoogleHandler;
-  const appleHandler = appleSignIn || internalAppleHandler;
-
-  return {
-    googleLoading: false,
-    appleLoading: false,
-    handleGoogleSignIn: googleHandler || (async () => {}),
-    handleAppleSignIn: appleHandler || (async () => {}),
-  };
+export function selectSignInHandler(
+  externalHandler?: () => Promise<void>,
+  internalHandler?: () => Promise<void>
+): (() => Promise<void>) | undefined {
+  return externalHandler ?? internalHandler;
 }
+