@umituz/react-native-auth 3.6.51 → 3.6.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.51",
+  "version": "3.6.52",
   "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/infrastructure/adapters/StorageProviderAdapter.ts

@@ -9,11 +9,10 @@ import type { IStorageProvider } from "../types/Storage.types";
  * Interface that describes the shape of common storage implementations
  * to avoid using 'any' and resolve lint errors.
  */
-interface StorageLike {
+export interface StorageLike {
   getString?: (
     key: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    defaultValue?: any
+    defaultValue?: string | null
   ) => Promise<{ value: string | null } | null>;
   getItem?: (key: string) => Promise<string | null>;
   setString?: (key: string, value: string) => Promise<void>;
@@ -24,8 +23,8 @@ interface StorageLike {
 export class StorageProviderAdapter implements IStorageProvider {
   private storage: StorageLike;
 
-  constructor(storage: unknown) {
-    this.storage = storage as StorageLike;
+  constructor(storage: StorageLike) {
+    this.storage = storage;
   }
 
   async get(key: string): Promise<string | null> {
@@ -62,6 +61,6 @@ export class StorageProviderAdapter implements IStorageProvider {
   }
 }
 
-export function createStorageProvider(storage: unknown): IStorageProvider {
+export function createStorageProvider(storage: StorageLike): IStorageProvider {
   return new StorageProviderAdapter(storage);
 }

package/src/infrastructure/adapters/UIProviderAdapter.ts

@@ -8,13 +8,10 @@ import type { IUIProvider } from "../types/UI.types";
 
 export class UIProviderAdapter implements IUIProvider {
   private theme: DesignTokens | null = null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private localization: any = null;
+  private localization: Record<string, unknown> | null = null;
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(theme?: DesignTokens, localization?: any) {
+  constructor(theme?: DesignTokens, localization?: Record<string, unknown>) {
     this.theme = theme || null;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     this.localization = localization || null;
   }
 
@@ -22,8 +19,7 @@ export class UIProviderAdapter implements IUIProvider {
     return this.theme;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  getLocalization(): any {
+  getLocalization(): Record<string, unknown> | null {
     return this.localization;
   }
 
@@ -31,9 +27,7 @@ export class UIProviderAdapter implements IUIProvider {
     this.theme = theme;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  updateLocalization(localization: any): void {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  updateLocalization(localization: Record<string, unknown>): void {
     this.localization = localization;
   }
 }
@@ -43,8 +37,7 @@ export class UIProviderAdapter implements IUIProvider {
  */
 export function createUIProvider(
   theme?: DesignTokens,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  localization?: any
+  localization?: Record<string, unknown>
 ): IUIProvider {
   return new UIProviderAdapter(theme, localization);
-}
+}

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -14,7 +14,6 @@ import {
   type Auth,
 } from "firebase/auth";
 
-declare const __DEV__: boolean;
 import type {
   IAuthProvider,
   AuthCredentials,
@@ -37,8 +36,6 @@ export class FirebaseAuthProvider implements IAuthProvider {
     if (!this.auth) {
       throw new Error("Firebase Auth instance must be provided");
     }
-    // Satisfy require-await
-    await Promise.resolve();
   }
 
   setAuth(auth: Auth): void {
@@ -169,7 +166,7 @@ export class FirebaseAuthProvider implements IAuthProvider {
   onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
     if (!this.auth) {
       callback(null);
-      return () => { };
+      return () => {};
     }
 
     return onAuthStateChanged(this.auth, (user) => {

package/src/infrastructure/repositories/AuthRepository.ts

@@ -20,6 +20,7 @@ import {
     validateDisplayName,
 } from "../utils/AuthValidation";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
+import { sanitizeEmail, sanitizeName, sanitizePassword } from "../utils/validation/sanitization";
 
 export class AuthRepository implements IAuthRepository {
     private provider: IAuthProvider;
@@ -31,50 +32,50 @@ export class AuthRepository implements IAuthRepository {
     }
 
     async signUp(params: SignUpParams): Promise<AuthUser> {
+        const email = sanitizeEmail(params.email);
+        const password = sanitizePassword(params.password);
+        const displayName = params.displayName ? sanitizeName(params.displayName) : undefined;
+
         // Validate email
-        const emailResult = validateEmail(params.email);
+        const emailResult = validateEmail(email);
         if (!emailResult.isValid) {
             throw new AuthInvalidEmailError(emailResult.error);
         }
 
         // Validate display name if provided
-        if (params.displayName) {
-            const nameResult = validateDisplayName(params.displayName);
+        if (displayName) {
+            const nameResult = validateDisplayName(displayName);
             if (!nameResult.isValid) {
                 throw new AuthValidationError(nameResult.error || "Invalid name", "displayName");
             }
         }
 
         // Validate password strength for registration
-        const passwordResult = validatePasswordForRegister(params.password, this.config.password);
+        const passwordResult = validatePasswordForRegister(password, this.config.password);
         if (!passwordResult.isValid) {
             throw new AuthWeakPasswordError(passwordResult.error);
         }
 
-        return this.provider.signUp({
-            email: params.email,
-            password: params.password,
-            displayName: params.displayName,
-        });
+        return this.provider.signUp({ email, password, displayName });
     }
 
     async signIn(params: SignInParams): Promise<AuthUser> {
+        const email = sanitizeEmail(params.email);
+        const password = sanitizePassword(params.password);
+
         // Validate email format
-        const emailResult = validateEmail(params.email);
+        const emailResult = validateEmail(email);
         if (!emailResult.isValid) {
             throw new AuthInvalidEmailError(emailResult.error);
         }
 
         // For login, only check if password is provided (no strength requirements)
-        const passwordResult = validatePasswordForLogin(params.password);
+        const passwordResult = validatePasswordForLogin(password);
         if (!passwordResult.isValid) {
             throw new AuthValidationError(passwordResult.error || "Password is required", "password");
         }
 
-        return this.provider.signIn({
-            email: params.email,
-            password: params.password,
-        });
+        return this.provider.signIn({ email, password });
     }
 
     async signOut(): Promise<void> {

package/src/infrastructure/services/AnonymousModeService.ts

@@ -21,7 +21,10 @@ export class AnonymousModeService {
       const value = await storageProvider.get(this.storageKey);
       this.isAnonymousMode = value === "true";
       return this.isAnonymousMode;
-    } catch {
+    } catch (error) {
+      if (__DEV__) {
+        console.warn("[AnonymousModeService] Storage load failed:", error);
+      }
       return false;
     }
   }
@@ -29,16 +32,20 @@ export class AnonymousModeService {
   private async save(storageProvider: IStorageProvider): Promise<void> {
     try {
       await storageProvider.set(this.storageKey, this.isAnonymousMode.toString());
-    } catch {
-      // Silently fail storage operations
+    } catch (err) {
+      if (__DEV__) {
+        console.error("[AnonymousModeService] Storage save failed:", err);
+      }
     }
   }
 
   async clear(storageProvider: IStorageProvider): Promise<void> {
     try {
       await storageProvider.remove(this.storageKey);
-    } catch {
-      // Silently fail storage operations
+    } catch (err) {
+      if (__DEV__) {
+        console.error("[AnonymousModeService] Storage clear failed:", err);
+      }
     }
     this.isAnonymousMode = false;
   }
@@ -48,8 +55,10 @@ export class AnonymousModeService {
     if (provider?.getCurrentUser()) {
       try {
         await provider.signOut();
-      } catch {
-        // Ignore sign out errors when switching to anonymous mode
+      } catch (error) {
+        if (__DEV__) {
+          console.warn("[AnonymousModeService] Sign out failed during mode switch:", error);
+        }
       }
     }
 

package/src/infrastructure/services/AuthEventService.ts

@@ -88,8 +88,10 @@ export class AuthEventService {
       eventListeners.forEach((listener) => {
         try {
           listener(payload);
-        } catch {
-          // Silent fail for listener errors
+        } catch (err) {
+          if (__DEV__) {
+            console.error("[AuthEventService] Listener error:", err);
+          }
         }
       });
     }

package/src/infrastructure/services/AuthService.ts

@@ -45,10 +45,9 @@ export class AuthService implements IAuthService {
     let provider: IAuthProvider;
 
     if ("currentUser" in providerOrAuth) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth as any);
+      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth as Auth);
       await firebaseProvider.initialize();
-      provider = firebaseProvider as unknown as IAuthProvider;
+      provider = firebaseProvider;
     } else {
       provider = providerOrAuth;
       await provider.initialize();

package/src/infrastructure/services/UserDocumentService.ts

@@ -24,8 +24,6 @@ export type {
   UserDocumentExtras,
 } from "./UserDocument.types";
 
-declare const __DEV__: boolean;
-
 let userDocumentConfig: UserDocumentConfig = {};
 
 export function configureUserDocumentService(config: UserDocumentConfig): void {
@@ -37,7 +35,7 @@ export async function ensureUserDocument(
   extras?: UserDocumentExtras,
 ): Promise<boolean> {
   const db = getFirestore();
-  if (!db || !user.uid) return false;
+  if (!db || !user.uid || user.uid.trim().length === 0) return false;
 
   try {
     let allExtras = extras || {};
@@ -60,8 +58,7 @@ export async function ensureUserDocument(
     await setDoc(userRef, docData, { merge: true });
     return true;
   } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
+    if (__DEV__) {
       console.error("[UserDocumentService] Failed:", error);
     }
     return false;
@@ -80,7 +77,10 @@ export async function markUserDeleted(userId: string): Promise<boolean> {
       updatedAt: serverTimestamp(),
     }, { merge: true });
     return true;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.error("[UserDocumentService] markUserDeleted failed:", error);
+    }
     return false;
   }
 }

package/src/infrastructure/services/initializeAuth.ts

@@ -27,6 +27,7 @@ export interface InitializeAuthOptions {
 }
 
 let isInitialized = false;
+let initializationPromise: Promise<{ success: boolean; auth: Auth | null }> | null = null;
 const conversionState: { current: ConversionState } = {
   current: { previousUserId: null, wasAnonymous: false },
 };
@@ -40,6 +41,21 @@ export async function initializeAuth(
   if (isInitialized) {
     return { success: true, auth: getFirebaseAuth() };
   }
+  // Prevent race condition: return existing promise if initialization is in progress
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = doInitializeAuth(options);
+  try {
+    return await initializationPromise;
+  } finally {
+    initializationPromise = null;
+  }
+}
+
+async function doInitializeAuth(
+  options: InitializeAuthOptions
+): Promise<{ success: boolean; auth: Auth | null }> {
 
   const {
     userCollection = "users",
@@ -63,8 +79,10 @@ export async function initializeAuth(
 
   try {
     await initializeAuthService(auth, authConfig, storageProvider);
-  } catch {
-    // Continue without email/password auth
+  } catch (error) {
+    if (__DEV__) {
+      console.warn("[initializeAuth] Auth service init failed, continuing:", error);
+    }
   }
 
   const handleAuthStateChange = createAuthStateHandler(conversionState, {
@@ -74,7 +92,13 @@ export async function initializeAuth(
 
   initializeAuthListener({
     autoAnonymousSignIn,
-    onAuthStateChange: (user) => void handleAuthStateChange(user),
+    onAuthStateChange: (user) => {
+      handleAuthStateChange(user).catch((err) => {
+        if (__DEV__) {
+          console.error("[initializeAuth] Auth state change handler error:", err);
+        }
+      });
+    },
   });
 
   isInitialized = true;

package/src/infrastructure/types/UI.types.ts

@@ -7,6 +7,5 @@ import type { DesignTokens } from "@umituz/react-native-design-system";
 
 export interface IUIProvider {
   getTheme(): DesignTokens | null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  getLocalization(): any;
+  getLocalization(): Record<string, unknown> | null;
 }

package/src/infrastructure/utils/AuthErrorMapper.ts

@@ -49,11 +49,6 @@ export function mapFirebaseAuthError(error: unknown): Error {
       return new AuthWrongPasswordError();
 
     case "auth/invalid-credential":
-      return new AuthError(
-        "Invalid email or password. Please check your credentials.",
-        "AUTH_INVALID_CREDENTIAL"
-      );
-
     case "auth/invalid-login-credentials":
       return new AuthError(
         "Invalid email or password. Please check your credentials.",

package/src/infrastructure/utils/AuthValidation.ts

@@ -33,7 +33,6 @@ export function validatePasswordForLogin(password: string): ValidationResult {
 export function validatePasswordForRegister(
   password: string,
   config: PasswordConfig,
-  _validationConfig: ValidationConfig = DEFAULT_VAL_CONFIG
 ): PasswordStrengthResult {
   const req: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,

package/src/infrastructure/utils/UserMapper.ts

@@ -6,7 +6,7 @@
 import type { AuthUser, AuthProviderType } from "../../domain/entities/AuthUser";
 
 interface ProviderData {
-  providerId: string;
+  providerId: string | null;
 }
 
 interface FirebaseUserLike {
@@ -16,7 +16,7 @@ interface FirebaseUserLike {
   isAnonymous: boolean;
   emailVerified: boolean;
   photoURL: string | null;
-  providerData?: ProviderData[];
+  providerData?: (ProviderData | null)[];
 }
 
 /**
@@ -32,13 +32,13 @@ function extractProvider(user: FirebaseUserLike): AuthProviderType {
     return "unknown";
   }
 
-  const googleProvider = providerData.find((p) => p.providerId === "google.com");
+  const googleProvider = providerData.find((p) => p?.providerId === "google.com");
   if (googleProvider) return "google.com";
 
-  const appleProvider = providerData.find((p) => p.providerId === "apple.com");
+  const appleProvider = providerData.find((p) => p?.providerId === "apple.com");
   if (appleProvider) return "apple.com";
 
-  const passwordProvider = providerData.find((p) => p.providerId === "password");
+  const passwordProvider = providerData.find((p) => p?.providerId === "password");
   if (passwordProvider) return "password";
 
   return "unknown";

package/src/infrastructure/utils/authStateHandler.ts

@@ -36,8 +36,10 @@ export function createAuthStateHandler(
     if (conversion.isConversion && onUserConverted && state.current.previousUserId) {
       try {
         await onUserConverted(state.current.previousUserId, currentUserId);
-      } catch {
-        // Migration failed but don't block user flow
+      } catch (error) {
+        if (__DEV__) {
+          console.warn("[AuthStateHandler] User conversion callback failed:", error);
+        }
       }
     }
 

package/src/infrastructure/utils/userDocumentBuilder.util.ts

@@ -16,7 +16,7 @@ export function getSignUpMethod(user: UserDocumentUser): string | undefined {
   if (user.isAnonymous) return "anonymous";
   if (user.email) {
     const providerData = (
-      user as unknown as { providerData?: { providerId: string }[] }
+      user as unknown as { providerData?: { providerId: string | null }[] }
     ).providerData;
     if (providerData && providerData.length > 0) {
       const providerId = providerData[0]?.providerId;

package/src/init/createAuthInitModule.ts

@@ -7,8 +7,6 @@ import type { InitModule } from '@umituz/react-native-design-system';
 import { initializeAuth } from '../infrastructure/services/initializeAuth';
 import type { InitializeAuthOptions } from '../infrastructure/services/initializeAuth';
 
-declare const __DEV__: boolean;
-
 export interface AuthInitModuleConfig {
   /**
    * Firestore collection name for user documents
@@ -104,7 +102,7 @@ export function createAuthInitModule(
           collectExtras,
           storageProvider,
           onUserConverted: async (anonymousId: string, authenticatedId: string) => {
-            if (typeof __DEV__ !== 'undefined' && __DEV__) {
+            if (__DEV__) {
               console.log('[createAuthInitModule] User converted:', {
                 anonymousId: anonymousId.slice(0, 8),
                 authenticatedId: authenticatedId.slice(0, 8),
@@ -115,11 +113,11 @@ export function createAuthInitModule(
             if (onRestorePurchases) {
               try {
                 await onRestorePurchases();
-                if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                if (__DEV__) {
                   console.log('[createAuthInitModule] Purchases restored');
                 }
               } catch (error) {
-                if (typeof __DEV__ !== 'undefined' && __DEV__) {
+                if (__DEV__) {
                   console.error('[createAuthInitModule] Restore failed:', error);
                 }
               }
@@ -132,13 +130,13 @@ export function createAuthInitModule(
           },
         });
 
-        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        if (__DEV__) {
           console.log('[createAuthInitModule] Auth initialized');
         }
 
         return true;
       } catch (error) {
-        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        if (__DEV__) {
           console.error('[createAuthInitModule] Error:', error);
         }
         return false;

package/src/presentation/components/AccountActions.tsx

@@ -59,8 +59,10 @@ export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
           onPress: async () => {
             try {
               await onLogout();
-            } catch {
-              // Silent error handling
+            } catch (error) {
+              if (__DEV__) {
+                console.error("[AccountActions] Logout failed:", error);
+              }
             }
           },
         },

package/src/presentation/components/AuthBottomSheet.tsx

@@ -13,8 +13,6 @@ import { RegisterForm, type RegisterFormTranslations } from "./RegisterForm";
 import { SocialLoginButtons, type SocialLoginButtonsTranslations } from "./SocialLoginButtons";
 import { styles } from "./AuthBottomSheet.styles";
 
-declare const __DEV__: boolean;
-
 export interface AuthBottomSheetTranslations {
   close: string;
   signIn: string;

package/src/presentation/hooks/useAppleAuth.ts

@@ -36,8 +36,7 @@ export function useAppleAuth(): UseAppleAuthResult {
       return { success: false, error: "Apple Sign-In is not available" };
     }
 
-    const result = await signInWithApple();
-    return result;
+    return signInWithApple();
   }, [appleAvailable, signInWithApple]);
 
   return {

package/src/presentation/hooks/useAuth.ts

@@ -141,7 +141,10 @@ export function useAuth(): UseAuthResult {
       setLoading(true);
       await anonymousModeMutation.mutateAsync();
       setIsAnonymous(true);
-    } catch {
+    } catch (error) {
+      if (__DEV__) {
+        console.warn("[useAuth] continueAnonymously failed:", error);
+      }
       setIsAnonymous(true);
     } finally {
       setLoading(false);

package/src/presentation/hooks/useAuthBottomSheet.ts

@@ -7,8 +7,6 @@ import { useGoogleAuth, type GoogleAuthConfig } from "./useGoogleAuth";
 import { useAppleAuth } from "./useAppleAuth";
 import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
 
-declare const __DEV__: boolean;
-
 export interface SocialAuthConfiguration {
   google?: GoogleAuthConfig;
   apple?: { enabled: boolean };
@@ -92,7 +90,7 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
     const justAuthenticated = !prevIsAuthenticatedRef.current && isAuthenticated;
     const justConvertedFromAnonymous = prevIsAnonymousRef.current && !isAnonymous && isAuthenticated;
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
+    if (__DEV__) {
       console.log("[useAuthBottomSheet] Auth state effect:", {
         isAuthenticated,
         isAnonymous,
@@ -106,7 +104,7 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
     }
 
     if ((justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         console.log("[useAuthBottomSheet] Auto-closing due to successful authentication transition", {
           justAuthenticated,
           justConvertedFromAnonymous,
@@ -119,7 +117,7 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
       onAuthSuccess?.();
       // Execute callback with delay to ensure auth state has propagated
       setTimeout(() => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
+        if (__DEV__) {
           console.log("[useAuthBottomSheet] Executing pending callback after auth");
         }
         executePendingCallback();

package/src/presentation/hooks/useGoogleAuth.ts

@@ -71,8 +71,10 @@ export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
       if (idToken) {
         setIsLoading(true);
         signInWithGoogleToken(idToken)
-          .catch(() => {
-            // Silent error handling
+          .catch((error) => {
+            if (__DEV__) {
+              console.error("[useGoogleAuth] Firebase sign-in failed:", error);
+            }
           })
           .finally(() => {
             setIsLoading(false);

package/src/presentation/hooks/useLoginForm.ts

@@ -100,8 +100,10 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
   const handleContinueAnonymously = useCallback(async () => {
     try {
       await continueAnonymously();
-    } catch {
-      // Silent fail
+    } catch (error) {
+      if (__DEV__) {
+        console.warn("[useLoginForm] Continue anonymously failed:", error);
+      }
     }
   }, [continueAnonymously]);
 

package/src/presentation/hooks/useRegisterForm.ts

@@ -122,19 +122,19 @@ export function useRegisterForm(config?: UseRegisterFormConfig): UseRegisterForm
 
     const emailResult = validateEmail(email.trim());
     if (!emailResult.isValid && emailResult.error) {
-      setFieldErrors((prev) => ({ ...prev, email: getErrorMessage(emailResult.error as string) }));
+      setFieldErrors((prev) => ({ ...prev, email: getErrorMessage(emailResult.error!) }));
       return;
     }
 
     const passwordResult = validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG);
     if (!passwordResult.isValid && passwordResult.error) {
-      setFieldErrors((prev) => ({ ...prev, password: getErrorMessage(passwordResult.error as string) }));
+      setFieldErrors((prev) => ({ ...prev, password: getErrorMessage(passwordResult.error!) }));
       return;
     }
 
     const confirmResult = validatePasswordConfirmation(password, confirmPassword);
     if (!confirmResult.isValid && confirmResult.error) {
-      setFieldErrors((prev) => ({ ...prev, confirmPassword: getErrorMessage(confirmResult.error as string) }));
+      setFieldErrors((prev) => ({ ...prev, confirmPassword: getErrorMessage(confirmResult.error!) }));
       return;
     }
 

package/src/presentation/hooks/useSocialLogin.ts

@@ -80,8 +80,7 @@ export function useSocialLogin(config?: UseSocialLoginConfig): UseSocialLoginRes
       return { success: false, error: "Apple Sign-In is not available" };
     }
 
-    const result = await firebaseSignInWithApple();
-    return result;
+    return firebaseSignInWithApple();
   }, [appleAvailable, firebaseSignInWithApple]);
 
   return {

package/src/presentation/stores/authModalStore.ts

@@ -53,7 +53,7 @@ export const useAuthModalStore = createStore<AuthModalState, AuthModalActions>({
       callback?: () => void | Promise<void>,
       mode: AuthModalMode = "login",
     ) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (__DEV__) {
         console.log("[authModalStore] showAuthModal called:", {
           mode,
           hasCallback: !!callback,

package/src/presentation/stores/authStore.ts

@@ -72,7 +72,7 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
     initialized: state.initialized,
   }),
   migrate: (persistedState: unknown, version: number) => {
-    const state = persistedState as Partial<AuthState>;
+    const state = (persistedState && typeof persistedState === "object" ? persistedState : {}) as Partial<AuthState>;
     if (version < 2) {
       return {
         ...initialAuthState,
@@ -80,7 +80,7 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
         initialized: state.initialized ?? false,
       };
     }
-    return { ...initialAuthState, ...state } as AuthState;
+    return { ...initialAuthState, ...state };
   },
   actions: (set, get) => ({
     setFirebaseUser: (firebaseUser) => {

package/src/presentation/stores/initializeAuthListener.ts

@@ -13,7 +13,8 @@ import { useAuthStore } from "./authStore";
 import { getAuthService } from "../../infrastructure/services/AuthService";
 import type { AuthListenerOptions } from "../../types/auth-store.types";
 
-declare const __DEV__: boolean;
+const MAX_ANONYMOUS_RETRIES = 2;
+const ANONYMOUS_RETRY_DELAY_MS = 1000;
 
 let listenerInitialized = false;
 // Reference counter for multiple subscribers
@@ -106,10 +107,7 @@ export function initializeAuthListener(
       store.setLoading(true);
 
       void (async () => {
-        const MAX_RETRIES = 2;
-        const RETRY_DELAY_MS = 1000;
-
-        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        for (let attempt = 0; attempt <= MAX_ANONYMOUS_RETRIES; attempt++) {
           try {
             await anonymousAuthService.signInAnonymously(auth);
             if (__DEV__) {
@@ -123,8 +121,8 @@ export function initializeAuthListener(
             }
 
             // If not last attempt, wait and retry
-            if (attempt < MAX_RETRIES) {
-              await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+            if (attempt < MAX_ANONYMOUS_RETRIES) {
+              await new Promise(resolve => setTimeout(resolve, ANONYMOUS_RETRY_DELAY_MS));
               continue;
             }