@umituz/react-native-auth 3.6.86 → 3.6.88

package/src/presentation/hooks/useRegisterForm.ts

@@ -1,47 +1,24 @@
+/**
+ * Register Form Hook
+ * Main hook that combines all register form logic
+ */
+
 import { useState, useCallback } from "react";
 import { DEFAULT_PASSWORD_CONFIG } from "../../domain/value-objects/AuthConfig";
 import { useAuth } from "./useAuth";
-import { getAuthErrorLocalizationKey, resolveErrorMessage } from "../utils/getAuthErrorMessage";
-import { validateRegisterForm, errorsToFieldErrors } from "../utils/form/formValidation.util";
-import { alertService } from "@umituz/react-native-design-system";
+import { resolveErrorMessage } from "../utils/getAuthErrorMessage";
 import { useFormFields } from "../utils/form/useFormField.hook";
 import { usePasswordValidation } from "../utils/form/usePasswordValidation.hook";
-import { clearFieldError, clearFieldErrors } from "../utils/form/formErrorUtils";
-
-export type FieldErrors = {
-  displayName?: string;
-  email?: string;
-  password?: string;
-  confirmPassword?: string;
-};
-
-export interface RegisterFormTranslations {
-  successTitle: string;
-  signUpSuccess: string;
-  errors: Record<string, string>;
-}
-
-export interface UseRegisterFormConfig {
-  translations: RegisterFormTranslations;
-}
+import { useRegisterFormHandlers } from "./registerForm/registerFormHandlers";
+import { useRegisterFormSubmit } from "./registerForm/registerFormSubmit";
+import type {
+  FieldErrors,
+  UseRegisterFormConfig,
+  UseRegisterFormResult,
+} from "./registerForm/useRegisterForm.types";
 
-export interface UseRegisterFormResult {
-  displayName: string;
-  email: string;
-  password: string;
-  confirmPassword: string;
-  fieldErrors: FieldErrors;
-  localError: string | null;
-  loading: boolean;
-  passwordRequirements: { hasMinLength: boolean };
-  passwordsMatch: boolean;
-  handleDisplayNameChange: (text: string) => void;
-  handleEmailChange: (text: string) => void;
-  handlePasswordChange: (text: string) => void;
-  handleConfirmPasswordChange: (text: string) => void;
-  handleSignUp: () => Promise<void>;
-  displayError: string | null;
-}
+// Re-export types for backward compatibility
+export type { FieldErrors, RegisterFormTranslations, UseRegisterFormConfig, UseRegisterFormResult } from "./registerForm/useRegisterForm.types";
 
 export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterFormResult {
   const { signUp, loading, error } = useAuth();
@@ -70,9 +47,12 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     { clearLocalError }
   );
 
-  const getErrorMessage = useCallback((key: string) => {
-    return resolveErrorMessage(key, translations?.errors);
-  }, [translations]);
+  const getErrorMessage = useCallback(
+    (key: string) => {
+      return resolveErrorMessage(key, translations?.errors);
+    },
+    [translations]
+  );
 
   const { passwordRequirements, passwordsMatch } = usePasswordValidation(
     fields.password,
@@ -80,73 +60,18 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     { passwordConfig: DEFAULT_PASSWORD_CONFIG }
   );
 
-  const handleDisplayNameChange = useCallback(
-    (text: string) => {
-      updateField("displayName", text);
-      clearFieldError(setFieldErrors, "displayName");
-      clearLocalError();
-    },
-    [updateField, clearLocalError]
-  );
-
-  const handleEmailChange = useCallback(
-    (text: string) => {
-      updateField("email", text);
-      clearFieldError(setFieldErrors, "email");
-      clearLocalError();
-    },
-    [updateField, clearLocalError]
-  );
-
-  const handlePasswordChange = useCallback(
-    (text: string) => {
-      updateField("password", text);
-      clearFieldErrors(setFieldErrors, ["password", "confirmPassword"]);
-      clearLocalError();
-    },
-    [updateField, clearLocalError]
-  );
+  const handlers = useRegisterFormHandlers(updateField, setFieldErrors, clearLocalError);
 
-  const handleConfirmPasswordChange = useCallback(
-    (text: string) => {
-      updateField("confirmPassword", text);
-      clearFieldError(setFieldErrors, "confirmPassword");
-      clearLocalError();
-    },
-    [updateField, clearLocalError]
+  const { handleSignUp } = useRegisterFormSubmit(
+    fields,
+    signUp,
+    setFieldErrors,
+    setLocalError,
+    clearFormErrors,
+    getErrorMessage,
+    translations
   );
 
-  const handleSignUp = useCallback(async () => {
-    clearFormErrors();
-
-    const validation = validateRegisterForm(
-      {
-        displayName: fields.displayName.trim() || undefined,
-        email: fields.email.trim(),
-        password: fields.password,
-        confirmPassword: fields.confirmPassword,
-      },
-      getErrorMessage,
-      DEFAULT_PASSWORD_CONFIG
-    );
-
-    if (!validation.isValid) {
-      setFieldErrors(errorsToFieldErrors(validation.errors));
-      return;
-    }
-
-    try {
-      await signUp(fields.email.trim(), fields.password, fields.displayName.trim() || undefined);
-
-      if (translations) {
-        alertService.success(translations.successTitle, translations.signUpSuccess);
-      }
-    } catch (err: unknown) {
-      const localizationKey = getAuthErrorLocalizationKey(err);
-      setLocalError(getErrorMessage(localizationKey));
-    }
-  }, [fields, signUp, translations, getErrorMessage, clearFormErrors, updateField]);
-
   const displayError = localError || error;
 
   return {
@@ -159,10 +84,7 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
     loading,
     passwordRequirements,
     passwordsMatch,
-    handleDisplayNameChange,
-    handleEmailChange,
-    handlePasswordChange,
-    handleConfirmPasswordChange,
+    ...handlers,
     handleSignUp,
     displayError,
   };

package/src/presentation/utils/form/formValidation.util.ts

@@ -1,117 +1,26 @@
 /**
- * Form Validation Utilities
- * Shared validation logic for all auth forms
+ * Form Validation - Main Export
+ * Re-exports all form validation utilities
  */
 
-import { useCallback } from "react";
-import {
-  validateEmail,
-  validatePasswordForLogin,
-  validatePasswordForRegister,
-  validatePasswordConfirmation,
-} from "../../../infrastructure/utils/AuthValidation";
-import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
-
-export interface FormValidationError {
-  field: string;
-  message: string;
-}
-
-export interface FormValidationResult {
-  isValid: boolean;
-  errors: FormValidationError[];
-}
-
-export interface LoginFormValues {
-  email: string;
-  password: string;
-}
-
-export interface RegisterFormValues {
-  displayName?: string;
-  email: string;
-  password: string;
-  confirmPassword: string;
-}
-
-export interface ProfileFormValues {
-  displayName: string;
-  email: string;
-}
-
-export function validateLoginForm(values: LoginFormValues, getErrorMessage: (key: string) => string): FormValidationResult {
-  const errors: FormValidationError[] = [];
-
-  const emailResult = validateEmail(values.email.trim());
-  if (!emailResult.isValid && emailResult.error) {
-    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
-  }
-
-  const passwordResult = validatePasswordForLogin(values.password);
-  if (!passwordResult.isValid && passwordResult.error) {
-    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
-
-export function validateRegisterForm(
-  values: RegisterFormValues,
-  getErrorMessage: (key: string) => string,
-  passwordConfig: PasswordConfig
-): FormValidationResult {
-  const errors: FormValidationError[] = [];
-
-  const emailResult = validateEmail(values.email.trim());
-  if (!emailResult.isValid && emailResult.error) {
-    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
-  }
-
-  const passwordResult = validatePasswordForRegister(values.password, passwordConfig);
-  if (!passwordResult.isValid && passwordResult.error) {
-    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
-  }
-
-  const confirmResult = validatePasswordConfirmation(values.password, values.confirmPassword);
-  if (!confirmResult.isValid && confirmResult.error) {
-    errors.push({ field: "confirmPassword", message: getErrorMessage(confirmResult.error) });
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
-
-export function validateProfileForm(values: ProfileFormValues): FormValidationResult {
-  const errors: FormValidationError[] = [];
-
-  if (!values.displayName.trim()) {
-    errors.push({ field: "displayName", message: "Display name is required" });
-  }
-
-  if (values.email) {
-    const emailResult = validateEmail(values.email);
-    if (!emailResult.isValid && emailResult.error) {
-      errors.push({ field: "email", message: emailResult.error });
-    }
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
-
-export function errorsToFieldErrors(errors: FormValidationError[]): Record<string, string> {
-  const result: Record<string, string> = {};
-  for (const error of errors) {
-    result[error.field] = error.message;
-  }
-  return result;
-}
-
-export function useFormValidation(getErrorMessage: (key: string) => string) {
-  const validateLogin = useCallback((values: LoginFormValues) => validateLoginForm(values, getErrorMessage), [getErrorMessage]);
-  const validateRegister = useCallback(
-    (values: RegisterFormValues, passwordConfig: PasswordConfig) => validateRegisterForm(values, getErrorMessage, passwordConfig),
-    [getErrorMessage]
-  );
-  const validateProfile = useCallback((values: ProfileFormValues) => validateProfileForm(values), []);
-
-  return { validateLogin, validateRegister, validateProfile, errorsToFieldErrors };
-}
+// Types
+export type {
+  FormValidationError,
+  FormValidationResult,
+  LoginFormValues,
+  RegisterFormValues,
+  ProfileFormValues,
+} from "./validation/formValidation.types";
+
+// Validators
+export {
+  validateLoginForm,
+  validateRegisterForm,
+  validateProfileForm,
+} from "./validation/formValidators";
+
+// Utilities
+export { errorsToFieldErrors } from "./validation/formValidation.utils";
+
+// Hook
+export { useFormValidation } from "./validation/formValidation.hook";

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

@@ -43,11 +43,11 @@ export function useFormField(
   const handleChange = useCallback(
     (text: string) => {
       setValue(text);
-      if (error || options?.clearLocalError) {
+      if (error) {
         clearError();
       }
     },
-    [error, options, clearError]
+    [error, clearError]
   );
 
   return {

package/src/presentation/utils/form/validation/formValidation.hook.ts

@@ -0,0 +1,30 @@
+/**
+ * Form Validation Hook
+ * React hook for form validation
+ */
+
+import { useCallback } from "react";
+import type { PasswordConfig } from "../../../../domain/value-objects/AuthConfig";
+import type { LoginFormValues, RegisterFormValues, ProfileFormValues } from "./formValidation.types";
+import { validateLoginForm, validateRegisterForm, validateProfileForm } from "./formValidators";
+import { errorsToFieldErrors } from "./formValidation.utils";
+
+export function useFormValidation(getErrorMessage: (key: string) => string) {
+  const validateLogin = useCallback(
+    (values: LoginFormValues) => validateLoginForm(values, getErrorMessage),
+    [getErrorMessage]
+  );
+
+  const validateRegister = useCallback(
+    (values: RegisterFormValues, passwordConfig: PasswordConfig) =>
+      validateRegisterForm(values, getErrorMessage, passwordConfig),
+    [getErrorMessage]
+  );
+
+  const validateProfile = useCallback(
+    (values: ProfileFormValues) => validateProfileForm(values, getErrorMessage),
+    [getErrorMessage]
+  );
+
+  return { validateLogin, validateRegister, validateProfile, errorsToFieldErrors };
+}

package/src/presentation/utils/form/validation/formValidation.types.ts

@@ -0,0 +1,31 @@
+/**
+ * Form Validation Types
+ * Type definitions for form validation
+ */
+
+export interface FormValidationError {
+  field: string;
+  message: string;
+}
+
+export interface FormValidationResult {
+  isValid: boolean;
+  errors: FormValidationError[];
+}
+
+export interface LoginFormValues {
+  email: string;
+  password: string;
+}
+
+export interface RegisterFormValues {
+  displayName?: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+export interface ProfileFormValues {
+  displayName: string;
+  email: string;
+}

package/src/presentation/utils/form/validation/formValidation.utils.ts

@@ -0,0 +1,17 @@
+/**
+ * Form Validation Utilities
+ * Helper functions for form validation
+ */
+
+import type { FormValidationError } from "./formValidation.types";
+
+/**
+ * Convert validation errors array to field errors object
+ */
+export function errorsToFieldErrors(errors: FormValidationError[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const error of errors) {
+    result[error.field] = error.message;
+  }
+  return result;
+}

package/src/presentation/utils/form/validation/formValidators.ts

@@ -0,0 +1,86 @@
+/**
+ * Form Validators
+ * Validation functions for different auth forms
+ */
+
+import {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+} from "../../../../infrastructure/utils/AuthValidation";
+import type { PasswordConfig } from "../../../../domain/value-objects/AuthConfig";
+import type {
+  FormValidationResult,
+  LoginFormValues,
+  RegisterFormValues,
+  ProfileFormValues,
+  FormValidationError,
+} from "./formValidation.types";
+
+export function validateLoginForm(
+  values: LoginFormValues,
+  getErrorMessage: (key: string) => string
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForLogin(values.password);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+export function validateRegisterForm(
+  values: RegisterFormValues,
+  getErrorMessage: (key: string) => string,
+  passwordConfig: PasswordConfig
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForRegister(values.password, passwordConfig);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  const confirmResult = validatePasswordConfirmation(values.password, values.confirmPassword);
+  if (!confirmResult.isValid && confirmResult.error) {
+    errors.push({ field: "confirmPassword", message: getErrorMessage(confirmResult.error) });
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+export function validateProfileForm(
+  values: ProfileFormValues,
+  getErrorMessage: (key: string) => string
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  if (!values.displayName || !values.displayName.trim()) {
+    errors.push({
+      field: "displayName",
+      message: getErrorMessage("auth.validation.displayNameRequired"),
+    });
+  }
+
+  if (values.email) {
+    const emailResult = validateEmail(values.email.trim());
+    if (!emailResult.isValid && emailResult.error) {
+      errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+    }
+  }
+
+  return { isValid: errors.length === 0, errors };
+}