@umituz/react-native-auth 3.6.85 → 3.6.87

package/src/infrastructure/utils/listener/listenerLifecycle.util.ts

@@ -1,159 +1,26 @@
 /**
- * Auth Listener Lifecycle Utilities
- * Handles subscription and cleanup logic for auth listener
+ * Auth Listener Lifecycle - Main Export
+ * Re-exports all listener lifecycle utilities from modular files
  */
 
-import type { Auth, User } from "firebase/auth";
-import type { AuthActions } from "../../../types/auth-store.types";
-import { createAnonymousSignInHandler } from "./anonymousSignInHandler";
-import {
-  isListenerInitialized,
-  completeInitialization,
-  setUnsubscribe,
-  incrementRefCount,
-  decrementRefCount,
-  startAnonymousSignIn,
-  completeAnonymousSignIn,
-  resetListenerState,
-} from "./listenerState.util";
-import { onIdTokenChanged } from "firebase/auth";
-import { getAuthService } from "../../../infrastructure/services/AuthService";
+// Cleanup handlers
+export {
+  createUnsubscribeHandler,
+  handleExistingInitialization,
+  handleInitializationInProgress,
+} from "./cleanupHandlers";
 
-type Store = AuthActions & { isAnonymous: boolean };
+// Setup listener
+export { setupAuthListener } from "./setupListener";
 
-/**
- * Create unsubscribe function that decrements ref count
- */
-export function createUnsubscribeHandler(): () => void {
-  return () => {
-    const { shouldCleanup } = decrementRefCount();
-
-    if (shouldCleanup) {
-      resetListenerState();
-    }
-  };
-}
-
-/**
- * Return existing unsubscribe if already initialized
- * Returns null if initialization is in progress
- */
-export function handleExistingInitialization(): (() => void) | null {
-  if (!isListenerInitialized()) {
-    return null;
-  }
-
-  incrementRefCount();
-  return createUnsubscribeHandler();
-}
-
-/**
- * Return no-op if initialization is in progress
- */
-export function handleInitializationInProgress(): () => void {
-  return () => {
-    // No-op - handled by initial initialization
-  };
-}
-
-/**
- * Setup Firebase auth listener
- */
-export function setupAuthListener(
-  auth: Auth,
-  store: Store,
-  autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
-): void {
-  const service = getAuthService();
-
-  if (service) {
-    const isAnonymous = service.getIsAnonymousMode();
-    if (isAnonymous) {
-      store.setIsAnonymous(true);
-    }
-  }
-
-  try {
-    const unsubscribe = onIdTokenChanged(auth, (user) => {
-      handleAuthStateChange(user, store, auth, autoAnonymousSignIn, onAuthStateChange);
-    });
+// Auth state handler
+export { handleAuthStateChange } from "./authStateHandler";
 
-    setUnsubscribe(unsubscribe);
-  } catch (error) {
-    // If listener setup fails, ensure we clean up and mark as initialized
-    console.error("[AuthListener] Failed to setup auth listener:", error);
-    completeInitialization();
-    store.setLoading(false);
-    store.setInitialized(true);
-    store.setError("Failed to initialize authentication listener");
-    throw error;
-  }
-}
-
-/**
- * Handle auth state change from Firebase
- */
-function handleAuthStateChange(
-  user: User | null,
-  store: Store,
-  auth: Auth,
-  autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
-): void {
-  try {
-    if (!user && autoAnonymousSignIn) {
-      // Start anonymous sign-in without blocking
-      void handleAnonymousMode(store, auth);
-      store.setFirebaseUser(null);
-      completeInitialization();
-      return;
-    }
-
-    store.setFirebaseUser(user);
-    store.setInitialized(true);
-
-    // Handle conversion from anonymous
-    if (user && !user.isAnonymous && store.isAnonymous) {
-      store.setIsAnonymous(false);
-    }
-
-    onAuthStateChange?.(user);
-  } catch (error) {
-    console.error("[AuthListener] Error handling auth state change:", error);
-    // Ensure we don't leave the app in a bad state
-    store.setInitialized(true);
-    store.setLoading(false);
-  }
-}
-
-/**
- * Handle anonymous mode sign-in
- */
-async function handleAnonymousMode(store: Store, auth: Auth): Promise<void> {
-  if (!startAnonymousSignIn()) {
-    return; // Already signing in
-  }
-
-  const handleAnonymousSignIn = createAnonymousSignInHandler(auth, store);
-
-  try {
-    await handleAnonymousSignIn();
-  } finally {
-    completeAnonymousSignIn();
-  }
-}
-
-/**
- * Handle case where Firebase auth is not available
- */
-export function handleNoFirebaseAuth(store: Store): () => void {
-  completeInitialization();
-  store.setLoading(false);
-  store.setInitialized(true);
-  return () => {};
-}
+// Anonymous mode handler
+export { handleAnonymousMode } from "./anonymousHandler";
 
-export function completeListenerSetup() {
-  completeInitialization();
-}
+// Initialization handlers
+export {
+  handleNoFirebaseAuth,
+  completeListenerSetup,
+} from "./initializationHandlers";

package/src/infrastructure/utils/listener/listenerState.util.ts

@@ -8,6 +8,7 @@ export interface ListenerState {
   refCount: number;
   initializationInProgress: boolean;
   anonymousSignInInProgress: boolean;
+  cleanupInProgress: boolean;
   unsubscribe: (() => void) | null;
 }
 
@@ -16,6 +17,7 @@ const state: ListenerState = {
   refCount: 0,
   initializationInProgress: false,
   anonymousSignInInProgress: false,
+  cleanupInProgress: false,
   unsubscribe: null,
 };
 
@@ -60,11 +62,16 @@ export function startInitialization(): boolean {
 
 /**
  * Complete initialization
+ * If refCount is 0, set to 1 (first subscriber)
+ * Otherwise, keep existing refCount from concurrent subscribers
  */
 export function completeInitialization(): void {
   state.initializationInProgress = false;
   state.initialized = true;
-  state.refCount = 1;
+  // Only set refCount to 1 if it's still 0 (no concurrent subscribers)
+  if (state.refCount === 0) {
+    state.refCount = 1;
+  }
 }
 
 /**
@@ -85,10 +92,20 @@ export function incrementRefCount(): number {
 /**
  * Decrement reference count when a subscriber leaves
  * Returns true if cleanup should be performed
+ * Uses cleanupInProgress flag to prevent concurrent cleanup attempts
  */
 export function decrementRefCount(): { shouldCleanup: boolean; count: number } {
   state.refCount--;
-  const shouldCleanup = state.refCount <= 0 && state.unsubscribe !== null;
+  const shouldCleanup =
+    state.refCount <= 0 &&
+    state.unsubscribe !== null &&
+    !state.cleanupInProgress;
+
+  // If cleanup should happen, mark as in progress to prevent concurrent cleanup
+  if (shouldCleanup) {
+    state.cleanupInProgress = true;
+  }
+
   return { shouldCleanup, count: state.refCount };
 }
 
@@ -111,7 +128,7 @@ export function completeAnonymousSignIn(): void {
 }
 
 /**
- * Reset all state (for testing)
+ * Reset all state (for testing and cleanup)
  */
 export function resetListenerState(): void {
   if (state.unsubscribe) {
@@ -121,5 +138,6 @@ export function resetListenerState(): void {
   state.refCount = 0;
   state.initializationInProgress = false;
   state.anonymousSignInInProgress = false;
+  state.cleanupInProgress = false;
   state.unsubscribe = null;
 }

package/src/infrastructure/utils/listener/setupListener.ts

@@ -0,0 +1,63 @@
+/**
+ * Setup Auth Listener
+ * Configures Firebase auth listener with timeout protection
+ */
+
+import type { Auth, User } from "firebase/auth";
+import { onIdTokenChanged } from "firebase/auth";
+import type { AuthActions } from "../../../types/auth-store.types";
+import { getAuthService } from "../../services/AuthService";
+import { completeInitialization, setUnsubscribe } from "./listenerState.util";
+import { handleAuthStateChange } from "./authStateHandler";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Setup Firebase auth listener with timeout protection
+ */
+export function setupAuthListener(
+  auth: Auth,
+  store: Store,
+  autoAnonymousSignIn: boolean,
+  onAuthStateChange?: (user: User | null) => void
+): void {
+  const service = getAuthService();
+
+  if (service) {
+    const isAnonymous = service.getIsAnonymousMode();
+    if (isAnonymous) {
+      store.setIsAnonymous(true);
+    }
+  }
+
+  // Safety timeout: if listener doesn't trigger within 10 seconds, mark as initialized
+  let hasTriggered = false;
+  const timeout = setTimeout(() => {
+    if (!hasTriggered) {
+      console.warn("[AuthListener] Auth listener timeout - marking as initialized");
+      store.setInitialized(true);
+      store.setLoading(false);
+    }
+  }, 10000);
+
+  try {
+    const unsubscribe = onIdTokenChanged(auth, (user) => {
+      if (!hasTriggered) {
+        hasTriggered = true;
+        clearTimeout(timeout);
+      }
+      handleAuthStateChange(user, store, auth, autoAnonymousSignIn, onAuthStateChange);
+    });
+
+    setUnsubscribe(unsubscribe);
+  } catch (error) {
+    clearTimeout(timeout);
+    // If listener setup fails, ensure we clean up and mark as initialized
+    console.error("[AuthListener] Failed to setup auth listener:", error);
+    completeInitialization();
+    store.setLoading(false);
+    store.setInitialized(true);
+    store.setError("Failed to initialize authentication listener");
+    throw error;
+  }
+}

package/src/presentation/hooks/registerForm/registerFormHandlers.ts

@@ -0,0 +1,57 @@
+/**
+ * Register Form Change Handlers
+ * Input field change handlers with error clearing
+ */
+
+import { useCallback } from "react";
+import type { FieldErrors } from "./useRegisterForm.types";
+import { clearFieldError, clearFieldErrors } from "../../utils/form/formErrorUtils";
+
+export function useRegisterFormHandlers(
+  updateField: (field: string, value: string) => void,
+  setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,
+  clearLocalError: () => void
+) {
+  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 handleConfirmPasswordChange = useCallback(
+    (text: string) => {
+      updateField("confirmPassword", text);
+      clearFieldError(setFieldErrors, "confirmPassword");
+      clearLocalError();
+    },
+    [updateField, clearLocalError]
+  );
+
+  return {
+    handleDisplayNameChange,
+    handleEmailChange,
+    handlePasswordChange,
+    handleConfirmPasswordChange,
+  };
+}

package/src/presentation/hooks/registerForm/registerFormSubmit.ts

@@ -0,0 +1,64 @@
+/**
+ * Register Form Submit Logic
+ * Handles form validation and sign-up submission
+ */
+
+import { useCallback } from "react";
+import { alertService } from "@umituz/react-native-design-system";
+import { DEFAULT_PASSWORD_CONFIG } from "../../../domain/value-objects/AuthConfig";
+import {
+  validateRegisterForm,
+  errorsToFieldErrors,
+} from "../../utils/form/formValidation.util";
+import { getAuthErrorLocalizationKey } from "../../utils/getAuthErrorMessage";
+import type { FieldErrors, RegisterFormTranslations } from "./useRegisterForm.types";
+
+interface RegisterFormFields {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+export function useRegisterFormSubmit(
+  fields: RegisterFormFields,
+  signUp: (email: string, password: string, displayName?: string) => Promise<void>,
+  setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,
+  setLocalError: React.Dispatch<React.SetStateAction<string | null>>,
+  clearFormErrors: () => void,
+  getErrorMessage: (key: string) => string,
+  translations?: RegisterFormTranslations
+) {
+  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, setFieldErrors, setLocalError]);
+
+  return { handleSignUp };
+}

package/src/presentation/hooks/registerForm/useRegisterForm.types.ts

@@ -0,0 +1,39 @@
+/**
+ * Register Form Types
+ * Type definitions for register form hook
+ */
+
+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;
+}
+
+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;
+}

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,
   };