@umituz/react-native-auth 4.3.62 → 4.3.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "4.3.62",
+  "version": "4.3.63",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -39,6 +39,40 @@ export { isEmpty, isEmptyEmail, isEmptyPassword, isEmptyName, isNotEmpty, hasCon
 export { safeCallback, safeCallbackSync } from './infrastructure/utils/safeCallback';
 
 
+// =============================================================================
+// CALCULATOR UTILITIES
+// =============================================================================
+
+export {
+  // Auth State Calculator
+  calculateUserId,
+  calculateHasFirebaseUser,
+  calculateIsAnonymous,
+  calculateIsAuthenticated,
+  calculateUserType,
+  calculateIsAuthReady,
+  calculateDerivedAuthState,
+  // Form Error Collection
+  collectFieldErrors,
+  extractFieldError,
+  hasFieldErrors,
+  getFirstErrorMessage,
+  // User Profile Calculator
+  calculateUserProfileDisplay,
+  calculateDisplayName,
+  hasUserAvatar,
+  getAvatarUrl,
+  // Password Strength Calculator
+  calculatePasswordRequirements,
+  calculatePasswordsMatch,
+  calculateConfirmationError,
+  calculatePasswordValidity,
+  calculatePasswordValidation,
+  hasMinLength,
+  calculatePasswordStrength,
+} from './infrastructure/utils/calculators';
+
+
 // =============================================================================
 // PRESENTATION LAYER - Hooks
 // =============================================================================
@@ -119,6 +153,7 @@ export {
   selectUserType,
   selectIsAuthReady,
   selectFirebaseUserId,
+  selectAuthState,
 } from './presentation/stores/auth.selectors';
 
 // =============================================================================

package/src/infrastructure/services/AuthEventService.ts

@@ -58,11 +58,12 @@ class AuthEventService {
   }
 
   addEventListener(event: string, listener: AuthEventListener): () => void {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, []);
+    let eventListeners = this.listeners.get(event);
+    if (!eventListeners) {
+      eventListeners = [];
+      this.listeners.set(event, eventListeners);
     }
 
-    const eventListeners = this.listeners.get(event)!;
     eventListeners.push(listener);
 
     // Return cleanup function

package/src/infrastructure/utils/calculators/authStateCalculator.ts

@@ -0,0 +1,92 @@
+/**
+ * Auth State Calculator
+ * Pure utility functions for deriving auth state from Firebase user
+ * These calculations are used in selectors and can be tested independently
+ */
+
+import type { AuthUser } from "../../../domain/entities/AuthUser";
+import type { UserType } from "../../../types/auth-store.types";
+
+interface FirebaseUserLike {
+  uid: string;
+  isAnonymous: boolean;
+}
+
+interface AuthStateInput {
+  firebaseUser: FirebaseUserLike | null;
+  user: AuthUser | null;
+  loading: boolean;
+  initialized: boolean;
+  error: string | null;
+}
+
+/**
+ * Calculate user ID from Firebase user
+ */
+export function calculateUserId(firebaseUser: FirebaseUserLike | null): string | null {
+  return firebaseUser?.uid ?? null;
+}
+
+/**
+ * Calculate if user has Firebase account
+ */
+export function calculateHasFirebaseUser(firebaseUser: FirebaseUserLike | null): boolean {
+  return !!firebaseUser;
+}
+
+/**
+ * Calculate if user is anonymous
+ */
+export function calculateIsAnonymous(firebaseUser: FirebaseUserLike | null): boolean {
+  return firebaseUser?.isAnonymous ?? false;
+}
+
+/**
+ * Calculate if user is authenticated (has Firebase user, not anonymous)
+ */
+export function calculateIsAuthenticated(firebaseUser: FirebaseUserLike | null): boolean {
+  const hasFirebaseUser = !!firebaseUser;
+  const isNotAnonymous = !firebaseUser?.isAnonymous;
+  return hasFirebaseUser && isNotAnonymous;
+}
+
+/**
+ * Calculate user type from Firebase user
+ */
+export function calculateUserType(firebaseUser: FirebaseUserLike | null): UserType {
+  if (!firebaseUser) {
+    return "none";
+  }
+  return firebaseUser.isAnonymous ? "anonymous" : "authenticated";
+}
+
+/**
+ * Calculate if auth is ready (initialized and not loading)
+ */
+export function calculateIsAuthReady(initialized: boolean, loading: boolean): boolean {
+  return initialized && !loading;
+}
+
+/**
+ * Calculate all derived auth state at once
+ * More efficient than calling individual functions multiple times
+ */
+export function calculateDerivedAuthState(input: AuthStateInput): {
+  userId: string | null;
+  hasFirebaseUser: boolean;
+  isAnonymous: boolean;
+  isAuthenticated: boolean;
+  userType: UserType;
+  isAuthReady: boolean;
+} {
+  const { firebaseUser, initialized, loading } = input;
+
+  return {
+    userId: calculateUserId(firebaseUser),
+    hasFirebaseUser: calculateHasFirebaseUser(firebaseUser),
+    isAnonymous: calculateIsAnonymous(firebaseUser),
+    isAuthenticated: calculateIsAuthenticated(firebaseUser),
+    userType: calculateUserType(firebaseUser),
+    isAuthReady: calculateIsAuthReady(initialized, loading),
+  };
+}

package/src/infrastructure/utils/calculators/formErrorCollection.ts

@@ -0,0 +1,56 @@
+/**
+ * Form Error Collection Utility
+ * Pure utility functions for collecting and extracting form errors
+ * Separates error collection logic from hooks for better testability
+ */
+
+import type { FormValidationError } from "../../../presentation/utils/form/validation/formValidation.types";
+
+/**
+ * Collect field errors from validation result
+ * Extracts error messages for specific fields
+ */
+export function collectFieldErrors(
+  errors: FormValidationError[],
+  fields: string[]
+): Record<string, string | null> {
+  const result: Record<string, string | null> = {};
+
+  for (const field of fields) {
+    const fieldError = errors.find((e) => e.field === field);
+    result[field] = fieldError?.message ?? null;
+  }
+
+  return result;
+}
+
+/**
+ * Extract single field error from validation result
+ */
+export function extractFieldError(
+  errors: FormValidationError[],
+  field: string
+): string | null {
+  const fieldError = errors.find((e) => e.field === field);
+  return fieldError?.message ?? null;
+}
+
+/**
+ * Check if validation has errors for specific fields
+ */
+export function hasFieldErrors(
+  errors: FormValidationError[],
+  fields: string[]
+): boolean {
+  return errors.some((error) => fields.includes(error.field));
+}
+
+/**
+ * Get first error message from validation result
+ */
+export function getFirstErrorMessage(errors: FormValidationError[]): string | null {
+  if (errors.length === 0) {
+    return null;
+  }
+  return errors[0].message ?? null;
+}

package/src/infrastructure/utils/calculators/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Calculator Utilities Index
+ * Centralized exports for all calculator utilities
+ */
+
+// Auth State Calculator
+export {
+  calculateUserId,
+  calculateHasFirebaseUser,
+  calculateIsAnonymous,
+  calculateIsAuthenticated,
+  calculateUserType,
+  calculateIsAuthReady,
+  calculateDerivedAuthState,
+} from "./authStateCalculator";
+
+// Form Error Collection
+export {
+  collectFieldErrors,
+  extractFieldError,
+  hasFieldErrors,
+  getFirstErrorMessage,
+} from "./formErrorCollection";
+
+// User Profile Calculator
+export {
+  calculateUserProfileDisplay,
+  calculateDisplayName,
+  hasUserAvatar,
+  getAvatarUrl,
+} from "./userProfileCalculator";
+
+// Password Strength Calculator
+export {
+  calculatePasswordRequirements,
+  calculatePasswordsMatch,
+  calculateConfirmationError,
+  calculatePasswordValidity,
+  calculatePasswordValidation,
+  hasMinLength,
+  calculatePasswordStrength,
+} from "./passwordStrengthCalculator";

package/src/infrastructure/utils/calculators/passwordStrengthCalculator.ts

@@ -0,0 +1,145 @@
+/**
+ * Password Strength Calculator Utility
+ * Pure utility functions for password validation and strength calculation
+ * Separates password logic from hooks for better testability
+ */
+
+import {
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+} from "../AuthValidation";
+import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
+import type { PasswordRequirements } from "../validation/types";
+
+interface PasswordValidationInput {
+  password: string;
+  confirmPassword: string;
+  config?: PasswordConfig;
+}
+
+interface PasswordValidationResult {
+  requirements: PasswordRequirements;
+  passwordsMatch: boolean;
+  isValid: boolean;
+  confirmationError: string | null;
+}
+
+/**
+ * Calculate password requirements from validation result
+ */
+export function calculatePasswordRequirements(
+  password: string,
+  config?: PasswordConfig
+): PasswordRequirements {
+  if (!password || !config) {
+    return { hasMinLength: false };
+  }
+
+  const result = validatePasswordForRegister(password, config);
+  return result.requirements;
+}
+
+/**
+ * Calculate if passwords match
+ * Explicitly converts to boolean to avoid type issues
+ */
+export function calculatePasswordsMatch(
+  password: string,
+  confirmPassword: string
+): boolean {
+  return !!(password && confirmPassword && password === confirmPassword);
+}
+
+/**
+ * Calculate password confirmation error
+ */
+export function calculateConfirmationError(
+  password: string,
+  confirmPassword: string
+): string | null {
+  if (!confirmPassword) {
+    return null;
+  }
+
+  const result = validatePasswordConfirmation(password, confirmPassword);
+  return result.error ?? null;
+}
+
+/**
+ * Calculate overall password validity
+ */
+export function calculatePasswordValidity(
+  requirements: PasswordRequirements,
+  passwordsMatch: boolean
+): boolean {
+  return requirements.hasMinLength && passwordsMatch;
+}
+
+/**
+ * Calculate all password validation state at once
+ * More efficient than calling individual functions
+ */
+export function calculatePasswordValidation(
+  input: PasswordValidationInput
+): PasswordValidationResult {
+  const { password, confirmPassword, config } = input;
+
+  // Calculate password requirements
+  const requirements = calculatePasswordRequirements(password, config);
+
+  // Calculate if passwords match
+  const passwordsMatch = calculatePasswordsMatch(password, confirmPassword);
+
+  // Calculate confirmation error
+  const confirmationError = calculateConfirmationError(password, confirmPassword);
+
+  // Calculate overall validity
+  const isValid = calculatePasswordValidity(requirements, passwordsMatch);
+
+  return {
+    requirements,
+    passwordsMatch,
+    isValid,
+    confirmationError,
+  };
+}
+
+/**
+ * Quick check if password meets minimum length requirement
+ */
+export function hasMinLength(password: string, minLength: number): boolean {
+  return password.length >= minLength;
+}
+
+/**
+ * Calculate password strength score (0-100)
+ * Can be extended for more sophisticated strength calculation
+ */
+export function calculatePasswordStrength(
+  password: string,
+  requirements: PasswordRequirements
+): number {
+  if (!password) return 0;
+
+  let score = 0;
+
+  // Base score for meeting minimum length
+  if (requirements.hasMinLength) {
+    score += 40;
+  }
+
+  // Additional points for length
+  if (password.length >= 8) score += 20;
+  if (password.length >= 12) score += 20;
+
+  // Additional points for variety (can be extended)
+  const hasLower = /[a-z]/.test(password);
+  const hasUpper = /[A-Z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  const hasSpecial = /[^a-zA-Z0-9]/.test(password);
+
+  const varietyCount = [hasLower, hasUpper, hasNumber, hasSpecial].filter(Boolean).length;
+  score += varietyCount * 5;
+
+  return Math.min(score, 100);
+}

package/src/infrastructure/utils/calculators/userProfileCalculator.ts

@@ -0,0 +1,77 @@
+/**
+ * User Profile Calculator Utility
+ * Pure utility functions for calculating user profile display data
+ * Separates profile calculation logic from hooks for better testability
+ */
+
+import type { AuthUser } from "../../../domain/entities/AuthUser";
+
+interface UserProfileDisplayParams {
+  anonymousDisplayName?: string;
+  accountRoute?: string;
+}
+
+interface UserProfileDisplayResult {
+  displayName: string;
+  userId: string;
+  isAnonymous: boolean;
+  avatarUrl?: string;
+  accountSettingsRoute?: string;
+}
+
+/**
+ * Calculate user profile display data
+ * Handles anonymous vs authenticated user display logic
+ */
+export function calculateUserProfileDisplay(
+  user: AuthUser,
+  params: UserProfileDisplayParams = {}
+): UserProfileDisplayResult {
+  const { anonymousDisplayName = "Anonymous User", accountRoute } = params;
+
+  if (user.isAnonymous) {
+    return {
+      displayName: anonymousDisplayName,
+      userId: user.uid,
+      isAnonymous: true,
+      accountSettingsRoute: accountRoute,
+    };
+  }
+
+  return {
+    displayName: user.displayName || user.email || anonymousDisplayName,
+    userId: user.uid,
+    isAnonymous: false,
+    avatarUrl: user.photoURL || undefined,
+    accountSettingsRoute: accountRoute,
+  };
+}
+
+/**
+ * Get display name for user
+ * Extracts display name calculation for reusability
+ */
+export function calculateDisplayName(
+  user: AuthUser,
+  anonymousDisplayName: string = "Anonymous User"
+): string {
+  if (user.isAnonymous) {
+    return anonymousDisplayName;
+  }
+
+  return user.displayName || user.email || anonymousDisplayName;
+}
+
+/**
+ * Check if user has avatar
+ */
+export function hasUserAvatar(user: AuthUser): boolean {
+  return !!user.photoURL;
+}
+
+/**
+ * Get avatar URL if available
+ */
+export function getAvatarUrl(user: AuthUser): string | undefined {
+  return user.photoURL || undefined;
+}

package/src/presentation/components/LoginForm.tsx

@@ -1,4 +1,4 @@
-import React, { useRef } from "react";
+import React, { useRef, memo } from "react";
 import { StyleSheet, TextInput } from "react-native";
 import { AtomicButton } from "@umituz/react-native-design-system/atoms";
 import { useLoginForm } from "../hooks/useLoginForm";
@@ -22,7 +22,7 @@ interface LoginFormProps {
   onNavigateToRegister: () => void;
 }
 
-export const LoginForm: React.FC<LoginFormProps> = ({
+export const LoginForm = memo<LoginFormProps>(({
   translations,
   onNavigateToRegister,
 }) => {
@@ -84,7 +84,7 @@ export const LoginForm: React.FC<LoginFormProps> = ({
       />
     </>
   );
-};
+});
 
 const styles = StyleSheet.create({
   signInButton: {
@@ -92,3 +92,5 @@ const styles = StyleSheet.create({
     marginBottom: 16,
   },
 });
+
+LoginForm.displayName = 'LoginForm';

package/src/presentation/components/RegisterForm.tsx

@@ -1,4 +1,4 @@
-import React, { useRef } from "react";
+import React, { useRef, memo } from "react";
 import { StyleSheet, TextInput } from "react-native";
 import { AtomicButton } from "@umituz/react-native-design-system/atoms";
 import { useRegisterForm } from "../hooks/useRegisterForm";
@@ -38,7 +38,7 @@ interface RegisterFormProps {
   onPrivacyPress?: () => void;
 }
 
-export const RegisterForm: React.FC<RegisterFormProps> = ({
+export const RegisterForm = memo<RegisterFormProps>(({
   translations,
   onNavigateToLogin,
   termsUrl,
@@ -149,10 +149,12 @@ export const RegisterForm: React.FC<RegisterFormProps> = ({
       />
     </>
   );
-};
+});
 
 const styles = StyleSheet.create({
   passwordInput: { marginBottom: 4 },
   confirmPasswordInput: { marginBottom: 4 },
   signUpButton: { minHeight: 52, marginBottom: 16, marginTop: 8 },
 });
+
+RegisterForm.displayName = 'RegisterForm';

package/src/presentation/hooks/useAuth.ts

@@ -1,22 +1,15 @@
 /**
  * useAuth Hook
  * React hook for authentication state management
+ * PERFORMANCE: Uses single batch selector to minimize re-renders
  */
 
 import { useCallback } from "react";
 import { useAuthStore } from "../stores/authStore";
 import {
-  selectUser,
-  selectLoading,
-  selectError,
+  selectAuthState,
   selectSetLoading,
   selectSetError,
-  selectIsAuthenticated,
-  selectHasFirebaseUser,
-  selectUserId,
-  selectUserType,
-  selectIsAnonymous,
-  selectIsAuthReady,
 } from "../stores/auth.selectors";
 import type { UserType } from "../../types/auth-store.types";
 import {
@@ -45,15 +38,9 @@ export interface UseAuthResult {
 }
 
 export function useAuth(): UseAuthResult {
-  const user = useAuthStore(selectUser);
-  const loading = useAuthStore(selectLoading);
-  const error = useAuthStore(selectError);
-  const isAuthenticated = useAuthStore(selectIsAuthenticated);
-  const hasFirebaseUser = useAuthStore(selectHasFirebaseUser);
-  const userId = useAuthStore(selectUserId);
-  const userType = useAuthStore(selectUserType);
-  const isAnonymous = useAuthStore(selectIsAnonymous);
-  const isAuthReady = useAuthStore(selectIsAuthReady);
+  // PERFORMANCE: Single batch selector instead of 10 separate selectors
+  // This reduces re-renders from 10x to 1x when auth state changes
+  const authState = useAuthStore(selectAuthState);
   const setLoading = useAuthStore(selectSetLoading);
   const setError = useAuthStore(selectSetError);
 
@@ -124,7 +111,7 @@ export function useAuth(): UseAuthResult {
   }, [setLoading, setError, anonymousModeMutation.mutateAsync]);
 
   return {
-    user, userId, userType, loading, isAuthReady, isAnonymous, isAuthenticated, hasFirebaseUser, error,
+    ...authState,
     signUp, signIn, signOut, continueAnonymously, setError,
   };
 }

package/src/presentation/hooks/useAuthBottomSheet.ts

@@ -38,9 +38,19 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
   const { signInWithApple, appleAvailable } = useAppleAuth();
 
   // Determine enabled providers
+  // PERFORMANCE: Memoize to prevent recalculation when config hasn't changed
   const providers = useMemo<SocialAuthProvider[]>(() => {
     return determineEnabledProviders(socialConfig, appleAvailable, googleConfigured);
-  }, [socialConfig, appleAvailable, googleConfigured]);
+  }, [
+    // Use deep comparison for socialConfig to avoid unnecessary recalculation
+    // when parent passes a new object reference with same values
+    socialConfig?.google?.iosClientId,
+    socialConfig?.google?.webClientId,
+    socialConfig?.google?.androidClientId,
+    socialConfig?.apple?.enabled,
+    appleAvailable,
+    googleConfigured,
+  ]);
 
   // Social auth loading states
   const [googleLoading, setGoogleLoading] = useState(false);

package/src/presentation/hooks/useAuthHandlers.ts

@@ -56,7 +56,7 @@ export const useAuthHandlers = (appInfo: AuthHandlersAppInfo, translations?: Aut
       }
       await Linking.openURL(url);
     } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         console.error("[useAuthHandlers] Failed to open app store:", error);
       }
       Alert.alert(translations?.common || "", translations?.failedToOpenAppStore || "");
@@ -67,7 +67,7 @@ export const useAuthHandlers = (appInfo: AuthHandlersAppInfo, translations?: Aut
     try {
       await signOut();
     } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         console.error("[useAuthHandlers] Sign out failed:", error);
       }
       AlertService.createErrorAlert(

package/src/presentation/hooks/useLoginForm.ts

@@ -6,6 +6,7 @@ import { useFormFields } from "../utils/form/useFormField.hook";
 import { sanitizeEmail } from "../../infrastructure/utils/validation/sanitization";
 import { useAuthErrorHandler } from "./useAuthErrorHandler";
 import { useLocalError } from "./useLocalError";
+import { extractFieldError } from "../../infrastructure/utils/calculators/formErrorCollection";
 
 interface LoginFormTranslations {
   successTitle: string;
@@ -44,7 +45,7 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     setEmailError(null);
     setPasswordError(null);
     setLocalError(null);
-  }, [setLocalError]);
+  }, [setLocalError, setEmailError, setPasswordError]);
 
   const { fields, updateField } = useFormFields(
     { email: "", password: "" },
@@ -79,11 +80,9 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
     );
 
     if (!validation.isValid) {
-      // Collect errors first to avoid potential state update batching issues
-      const emailErrorMsg = validation.errors.find(e => e.field === "email")?.message || null;
-      const passwordErrorMsg = validation.errors.find(e => e.field === "password")?.message || null;
-      setEmailError(emailErrorMsg);
-      setPasswordError(passwordErrorMsg);
+      // Use utility to collect field errors
+      setEmailError(extractFieldError(validation.errors, "email"));
+      setPasswordError(extractFieldError(validation.errors, "password"));
       return;
     }
 

package/src/presentation/hooks/useRegisterForm.ts

@@ -32,7 +32,7 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
   const clearFormErrors = useCallback(() => {
     setLocalError(null);
     setFieldErrors({});
-  }, []);
+  }, [setLocalError, setFieldErrors]);
 
   const { fields, updateField } = useFormFields(
     {

package/src/presentation/hooks/useUserProfile.ts

@@ -1,10 +1,12 @@
 /**
  * useUserProfile Hook
  * Returns profile data for display in settings or profile screens
+ * Uses userProfileCalculator utility for calculation logic
  */
 
 import { useMemo } from "react";
 import { useAuth } from "./useAuth";
+import { calculateUserProfileDisplay } from "../../infrastructure/utils/calculators/userProfileCalculator";
 
 export interface UserProfileData {
   displayName?: string;
@@ -24,29 +26,11 @@ export const useUserProfile = (
   params?: UseUserProfileParams,
 ): UserProfileData | undefined => {
   const { user } = useAuth();
-  const anonymousName = params?.anonymousDisplayName ?? "Anonymous User";
-  const accountRoute = params?.accountRoute;
 
   return useMemo(() => {
     if (!user) return undefined;
 
-    const isAnonymous = user.isAnonymous || false;
-
-    if (isAnonymous) {
-      return {
-        displayName: anonymousName,
-        userId: user.uid,
-        isAnonymous: true,
-        accountSettingsRoute: accountRoute,
-      };
-    }
-
-    return {
-      accountSettingsRoute: accountRoute,
-      displayName: user.displayName || user.email || anonymousName,
-      userId: user.uid,
-      isAnonymous: false,
-      avatarUrl: user.photoURL || undefined,
-    };
-  }, [user, anonymousName, accountRoute]);
+    // Delegate to utility function
+    return calculateUserProfileDisplay(user, params);
+  }, [user, params]);
 };

package/src/presentation/stores/auth.selectors.ts

@@ -1,10 +1,20 @@
 /**
  * Auth Store Selectors
  * Pure functions for deriving state from auth store
+ * Uses authStateCalculator for derived state calculations
  */
 
 import type { AuthState, AuthActions, UserType } from "../../types/auth-store.types";
 import type { AuthUser } from "../../domain/entities/AuthUser";
+import {
+  calculateUserId,
+  calculateHasFirebaseUser,
+  calculateIsAnonymous,
+  calculateIsAuthenticated,
+  calculateUserType,
+  calculateIsAuthReady,
+  calculateDerivedAuthState,
+} from "../../infrastructure/utils/calculators/authStateCalculator";
 
 // Combined store type for selectors
 type AuthStore = AuthState & AuthActions;
@@ -63,13 +73,15 @@ export const selectShowAuthModal = (state: { showAuthModal: (callback?: () => vo
 // =============================================================================
 // DERIVED SELECTORS
 // =============================================================================
+// Note: These selectors delegate to authStateCalculator utilities
+// for better separation of concerns and testability
 
 /**
  * Get current user ID
  * Uses firebaseUser as single source of truth
  */
 export const selectUserId = (state: AuthStore): string | null => {
-  return state.firebaseUser?.uid ?? null;
+  return calculateUserId(state.firebaseUser);
 };
 
 /**
@@ -77,13 +89,11 @@ export const selectUserId = (state: AuthStore): string | null => {
  * Uses firebaseUser as single source of truth
  */
 export const selectIsAuthenticated = (state: AuthStore): boolean => {
-  const hasFirebaseUser = !!state.firebaseUser;
-  const isNotAnonymous = !state.firebaseUser?.isAnonymous;
-  return hasFirebaseUser && isNotAnonymous;
+  return calculateIsAuthenticated(state.firebaseUser);
 };
 
 export const selectHasFirebaseUser = (state: AuthStore): boolean => {
-  return !!state.firebaseUser;
+  return calculateHasFirebaseUser(state.firebaseUser);
 };
 
 /**
@@ -91,7 +101,7 @@ export const selectHasFirebaseUser = (state: AuthStore): boolean => {
  * Uses firebaseUser as single source of truth
  */
 export const selectIsAnonymous = (state: AuthStore): boolean => {
-  return state.firebaseUser?.isAnonymous ?? false;
+  return calculateIsAnonymous(state.firebaseUser);
 };
 
 /**
@@ -99,17 +109,45 @@ export const selectIsAnonymous = (state: AuthStore): boolean => {
  * Derived from firebaseUser state
  */
 export const selectUserType = (state: AuthStore): UserType => {
-  if (!state.firebaseUser) {
-    return "none";
-  }
-
-  return state.firebaseUser.isAnonymous ? "anonymous" : "authenticated";
+  return calculateUserType(state.firebaseUser);
 };
 
 /**
  * Check if auth is ready (initialized and not loading)
  */
 export const selectIsAuthReady = (state: AuthStore): boolean => {
-  return state.initialized && !state.loading;
+  return calculateIsAuthReady(state.initialized, state.loading);
+};
+
+/**
+ * Batch selector - get all auth state at once to minimize re-renders
+ * More efficient than calling selectors individually
+ */
+export const selectAuthState = (state: AuthStore): {
+  user: AuthUser | null;
+  userId: string | null;
+  userType: UserType;
+  loading: boolean;
+  isAuthReady: boolean;
+  isAnonymous: boolean;
+  isAuthenticated: boolean;
+  hasFirebaseUser: boolean;
+  error: string | null;
+} => {
+  // Use calculateDerivedAuthState for batch calculation efficiency
+  const derivedState = calculateDerivedAuthState({
+    firebaseUser: state.firebaseUser,
+    user: state.user,
+    loading: state.loading,
+    initialized: state.initialized,
+    error: state.error,
+  });
+
+  return {
+    user: selectUser(state),
+    loading: selectLoading(state),
+    error: selectError(state),
+    ...derivedState,
+  };
 };
 

package/src/presentation/stores/authStore.ts

@@ -28,9 +28,12 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
     removeItem: (name) => storageService.removeItem(name),
   },
   version: 2,
+  // PERFORMANCE: Only persist essential flags
+  // Firebase handles user persistence, we only need anonymous mode and initialized state
   partialize: (state) => ({
     isAnonymous: state.isAnonymous,
     initialized: state.initialized,
+    loading: false, // Always restore as false to prevent loading state on app restart
   }),
   migrate: (persistedState: unknown) => {
     const state = (persistedState && typeof persistedState === "object" ? persistedState : {}) as Partial<AuthState>;

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

@@ -1,15 +1,13 @@
 /**
  * Password Validation Hook
  * Provides reusable password validation logic with requirements tracking
+ * PERFORMANCE: Single useMemo using passwordStrengthCalculator utility
  */
 
 import { useMemo } from "react";
-import {
-  validatePasswordForRegister,
-  validatePasswordConfirmation,
-} from "../../../infrastructure/utils/AuthValidation";
 import type { PasswordRequirements } from "../../../infrastructure/utils/validation/types";
 import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
+import { calculatePasswordValidation } from "../../../infrastructure/utils/calculators/passwordStrengthCalculator";
 
 interface UsePasswordValidationResult {
   passwordRequirements: PasswordRequirements;
@@ -34,40 +32,23 @@ export function usePasswordValidation(
   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,
-  };
+  // PERFORMANCE: Use utility function for batch calculation
+  const result = useMemo(() => {
+    const validation = calculatePasswordValidation({
+      password,
+      confirmPassword,
+      config: options?.passwordConfig,
+    });
+
+    // Map to expected return type
+    return {
+      passwordRequirements: validation.requirements,
+      passwordsMatch: validation.passwordsMatch,
+      isValid: validation.isValid,
+      confirmationError: validation.confirmationError,
+    };
+  }, [password, confirmPassword, options?.passwordConfig]);
+
+  return result;
 }