@umituz/react-native-auth 1.6.8 → 1.7.0

package/src/presentation/hooks/useLoginForm.ts

@@ -0,0 +1,165 @@
+/**
+ * useLoginForm Hook
+ * Single Responsibility: Handle login form logic
+ */
+
+import { useState, useCallback } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+
+/**
+ * Validate email format
+ */
+function validateEmail(emailValue: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(emailValue);
+}
+
+export interface UseLoginFormResult {
+  email: string;
+  password: string;
+  emailError: string | null;
+  passwordError: string | null;
+  localError: string | null;
+  loading: boolean;
+  handleEmailChange: (text: string) => void;
+  handlePasswordChange: (text: string) => void;
+  handleSignIn: () => Promise<void>;
+  handleContinueAsGuest: () => Promise<void>;
+  displayError: string | null;
+}
+
+/**
+ * Hook for login form logic
+ */
+export function useLoginForm(): UseLoginFormResult {
+  const { t } = useLocalization();
+  const { signIn, loading, error, continueAsGuest } = useAuth();
+
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [emailError, setEmailError] = useState<string | null>(null);
+  const [passwordError, setPasswordError] = useState<string | null>(null);
+  const [localError, setLocalError] = useState<string | null>(null);
+
+  const handleEmailChange = useCallback((text: string) => {
+    setEmail(text);
+    if (emailError) setEmailError(null);
+    if (localError) setLocalError(null);
+  }, [emailError, localError]);
+
+  const handlePasswordChange = useCallback((text: string) => {
+    setPassword(text);
+    if (passwordError) setPasswordError(null);
+    if (localError) setLocalError(null);
+  }, [passwordError, localError]);
+
+  const handleSignIn = useCallback(async () => {
+    /* eslint-disable-next-line no-console */
+    if (__DEV__) {
+      console.log("[useLoginForm] handleSignIn called");
+    }
+    setEmailError(null);
+    setPasswordError(null);
+    setLocalError(null);
+
+    let hasError = false;
+
+    if (!email.trim()) {
+      setEmailError(t("auth.errors.invalidEmail"));
+      hasError = true;
+    } else if (!validateEmail(email.trim())) {
+      setEmailError(t("auth.errors.invalidEmail"));
+      hasError = true;
+    }
+
+    if (!password.trim()) {
+      setPasswordError(t("auth.errors.weakPassword"));
+      hasError = true;
+    } else if (password.length < 6) {
+      setPasswordError(t("auth.errors.weakPassword"));
+      hasError = true;
+    }
+
+    if (hasError) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Validation errors, returning early");
+      }
+      return;
+    }
+
+    try {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Calling signIn with email:", email.trim());
+      }
+      await signIn(email.trim(), password);
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] signIn completed successfully");
+      }
+    } catch (err: any) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.error("[useLoginForm] signIn error:", err);
+      }
+      const localizationKey = getAuthErrorLocalizationKey(err);
+      const errorMessage = t(localizationKey);
+      setLocalError(errorMessage);
+    }
+  }, [email, password, t, signIn]);
+
+  const handleContinueAsGuest = useCallback(async () => {
+    /* eslint-disable-next-line no-console */
+    if (__DEV__) {
+      console.log("========================================");
+      console.log("[useLoginForm] 🎯 Continue as Guest button PRESSED");
+      console.log("[useLoginForm] Current loading state:", loading);
+      console.log("[useLoginForm] Current error state:", error);
+      console.log("========================================");
+    }
+    
+    try {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] Calling continueAsGuest() function...");
+      }
+      
+      await continueAsGuest();
+      
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.log("[useLoginForm] ✅ continueAsGuest() completed successfully");
+        console.log("[useLoginForm] Current loading state after:", loading);
+      }
+    } catch (err) {
+      /* eslint-disable-next-line no-console */
+      if (__DEV__) {
+        console.error("[useLoginForm] ❌ ERROR in continueAsGuest:", err);
+        console.error("[useLoginForm] Error details:", {
+          message: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : undefined,
+        });
+      }
+    }
+  }, [continueAsGuest, loading, error]);
+
+  const displayError = localError || error;
+
+  return {
+    email,
+    password,
+    emailError,
+    passwordError,
+    localError,
+    loading,
+    handleEmailChange,
+    handlePasswordChange,
+    handleSignIn,
+    handleContinueAsGuest,
+    displayError,
+  };
+}
+

package/src/presentation/hooks/useRegisterForm.ts

@@ -0,0 +1,170 @@
+/**
+ * useRegisterForm Hook
+ * Single Responsibility: Handle register form logic
+ */
+
+import { useState, useCallback } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import {
+  validateEmail,
+  validatePassword,
+  validatePasswordConfirmation,
+  batchValidate,
+} from "@umituz/react-native-validation";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+
+export interface UseRegisterFormResult {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  fieldErrors: {
+    displayName?: string;
+    email?: string;
+    password?: string;
+    confirmPassword?: string;
+  };
+  localError: string | null;
+  loading: boolean;
+  handleDisplayNameChange: (text: string) => void;
+  handleEmailChange: (text: string) => void;
+  handlePasswordChange: (text: string) => void;
+  handleConfirmPasswordChange: (text: string) => void;
+  handleSignUp: () => Promise<void>;
+  displayError: string | null;
+}
+
+/**
+ * Hook for register form logic
+ */
+export function useRegisterForm(): UseRegisterFormResult {
+  const { t } = useLocalization();
+  const { signUp, loading, error } = useAuth();
+
+  const [displayName, setDisplayName] = useState("");
+  const [email, setEmail] = useState("");
+  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 handleDisplayNameChange = useCallback((text: string) => {
+    setDisplayName(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.displayName) {
+        delete next.displayName;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleEmailChange = useCallback((text: string) => {
+    setEmail(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.email) {
+        delete next.email;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handlePasswordChange = useCallback((text: string) => {
+    setPassword(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.password) {
+        delete next.password;
+      }
+      if (next.confirmPassword) {
+        delete next.confirmPassword;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleConfirmPasswordChange = useCallback((text: string) => {
+    setConfirmPassword(text);
+    setFieldErrors((prev) => {
+      const next = { ...prev };
+      if (next.confirmPassword) {
+        delete next.confirmPassword;
+      }
+      return next;
+    });
+    if (localError) setLocalError(null);
+  }, [localError]);
+
+  const handleSignUp = useCallback(async () => {
+    setLocalError(null);
+    setFieldErrors({});
+
+    const validationResult = batchValidate([
+      {
+        field: "email",
+        validator: () => validateEmail(email.trim()),
+      },
+      {
+        field: "password",
+        validator: () =>
+          validatePassword(password, {
+            minLength: 6,
+            requireUppercase: false,
+            requireLowercase: false,
+            requireNumber: false,
+          }),
+      },
+      {
+        field: "confirmPassword",
+        validator: () =>
+          validatePasswordConfirmation(password, confirmPassword),
+      },
+    ]);
+
+    if (!validationResult.isValid) {
+      setFieldErrors(validationResult.errors);
+      return;
+    }
+
+    try {
+      await signUp(
+        email.trim(),
+        password,
+        displayName.trim() || undefined,
+      );
+    } catch (err: any) {
+      const localizationKey = getAuthErrorLocalizationKey(err);
+      const errorMessage = t(localizationKey);
+      setLocalError(errorMessage);
+    }
+  }, [displayName, email, password, confirmPassword, signUp, t]);
+
+  const displayError = localError || error;
+
+  return {
+    displayName,
+    email,
+    password,
+    confirmPassword,
+    fieldErrors,
+    localError,
+    loading,
+    handleDisplayNameChange,
+    handleEmailChange,
+    handlePasswordChange,
+    handleConfirmPasswordChange,
+    handleSignUp,
+    displayError,
+  };
+}
+