@umituz/react-native-auth 3.6.71 → 3.6.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.71",
+  "version": "3.6.73",
   "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

@@ -199,3 +199,4 @@ export {
 
 export { createAuthInitModule } from './init';
 export type { AuthInitModuleConfig } from './init/createAuthInitModule';
+

package/src/infrastructure/adapters/StorageProviderAdapter.ts

@@ -37,10 +37,7 @@ export class StorageProviderAdapter implements IStorageProvider {
       } else {
         throw new Error("Unsupported storage implementation");
       }
-    } catch (error) {
-      if (__DEV__) {
-        console.warn("[StorageProviderAdapter] Failed to get value for key:", key, error);
-      }
+    } catch {
       return null;
     }
   }

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -81,22 +81,11 @@ export class FirebaseAuthProvider implements IAuthProvider {
 
       // Convert anonymous user to permanent account
       if (currentUser && isAnonymous) {
-        if (__DEV__) {
-          console.log("[FirebaseAuthProvider] Converting anonymous user to authenticated:", {
-            anonymousId: currentUser.uid.slice(0, 8),
-          });
-        }
-
         // Reload user to refresh token before linking (prevents token-expired errors)
         try {
           await currentUser.reload();
-          if (__DEV__) {
-            console.log("[FirebaseAuthProvider] User reloaded successfully");
-          }
-        } catch (reloadError) {
-          if (__DEV__) {
-            console.log("[FirebaseAuthProvider] Reload failed, proceeding with link:", reloadError);
-          }
+        } catch {
+          // Reload failed, proceed with link anyway
         }
 
         const credential = EmailAuthProvider.credential(
@@ -105,19 +94,8 @@ export class FirebaseAuthProvider implements IAuthProvider {
         );
 
         userCredential = await linkWithCredential(currentUser, credential);
-
-        if (__DEV__) {
-          console.log("[FirebaseAuthProvider] Anonymous user converted successfully:", {
-            userId: userCredential.user.uid.slice(0, 8),
-            sameUser: currentUser.uid === userCredential.user.uid,
-          });
-        }
       } else {
         // Create new user
-        if (__DEV__) {
-          console.log("[FirebaseAuthProvider] Creating new user account");
-        }
-
         userCredential = await createUserWithEmailAndPassword(
           this.auth,
           credentials.email.trim(),
@@ -130,14 +108,9 @@ export class FirebaseAuthProvider implements IAuthProvider {
           await updateProfile(userCredential.user, {
             displayName: credentials.displayName.trim(),
           });
-        } catch (error) {
-          // Log the error but don't fail the entire sign-up process
-          // The account was created successfully, only the display name update failed
-          const errorMessage = error instanceof Error ? error.message : "Unknown error";
-          console.warn(
-            `[FirebaseAuthProvider] Account created but display name update failed: ${errorMessage}. ` +
-            "User can update their display name later from profile settings."
-          );
+        } catch {
+          // Silently fail - the account was created successfully,
+          // only the display name update failed. User can update it later.
         }
       }
 

package/src/infrastructure/repositories/AuthRepository.ts

@@ -36,11 +36,6 @@ export class AuthRepository implements IAuthRepository {
         const password = sanitizePassword(params.password);
         const displayName = params.displayName ? sanitizeName(params.displayName) : undefined;
 
-        // Log if display name was sanitized
-        if (__DEV__ && params.displayName && displayName && params.displayName !== displayName) {
-            console.warn("[AuthRepository] Display name was sanitized during sign up. Original:", params.displayName, "Sanitized:", displayName);
-        }
-
         // Validate email
         const emailResult = validateEmail(email);
         if (!emailResult.isValid) {

package/src/infrastructure/services/AnonymousModeService.ts

@@ -21,10 +21,7 @@ export class AnonymousModeService {
       const value = await storageProvider.get(this.storageKey);
       this.isAnonymousMode = value === "true";
       return this.isAnonymousMode;
-    } catch (error) {
-      if (__DEV__) {
-        console.warn("[AnonymousModeService] Storage load failed:", error);
-      }
+    } catch {
       return false;
     }
   }
@@ -33,10 +30,7 @@ export class AnonymousModeService {
     try {
       await storageProvider.set(this.storageKey, this.isAnonymousMode.toString());
       return true;
-    } catch (err) {
-      if (__DEV__) {
-        console.error("[AnonymousModeService] Storage save failed:", err);
-      }
+    } catch {
       return false;
     }
   }
@@ -46,10 +40,7 @@ export class AnonymousModeService {
       await storageProvider.remove(this.storageKey);
       this.isAnonymousMode = false;
       return true;
-    } catch (err) {
-      if (__DEV__) {
-        console.error("[AnonymousModeService] Storage clear failed:", err);
-      }
+    } catch {
       this.isAnonymousMode = false;
       return false;
     }
@@ -60,18 +51,13 @@ export class AnonymousModeService {
     if (provider?.getCurrentUser()) {
       try {
         await provider.signOut();
-      } catch (error) {
-        if (__DEV__) {
-          console.warn("[AnonymousModeService] Sign out failed during mode switch:", error);
-        }
+      } catch {
+        // Silently fail - sign out errors are handled elsewhere
       }
     }
 
     this.isAnonymousMode = true;
-    const saved = await this.save(storageProvider);
-    if (!saved && __DEV__) {
-      console.warn("[AnonymousModeService] Anonymous mode enabled but not persisted to storage. Mode will be lost on app restart.");
-    }
+    await this.save(storageProvider);
     emitAnonymousModeEnabled();
   }
 

package/src/infrastructure/services/AuthEventService.ts

@@ -92,10 +92,8 @@ export class AuthEventService {
       eventListeners.forEach((listener) => {
         try {
           listener(payload);
-        } catch (err) {
-          if (__DEV__) {
-            console.error("[AuthEventService] Listener error:", err);
-          }
+        } catch {
+          // Silently fail - listener errors should not break the event system
         }
       });
     }

package/src/infrastructure/services/initializeAuth.ts

@@ -65,9 +65,8 @@ async function doInitializeAuth(
   let authServiceInitFailed = false;
   try {
     await initializeAuthService(auth, authConfig, storageProvider);
-  } catch (error) {
+  } catch {
     authServiceInitFailed = true;
-    console.warn("[initializeAuth] Auth service init failed, continuing:", error);
   }
 
   const handleAuthStateChange = createAuthStateHandler(conversionState, {
@@ -78,18 +77,10 @@ async function doInitializeAuth(
   initializeAuthListener({
     autoAnonymousSignIn,
     onAuthStateChange: (user) => {
-      handleAuthStateChange(user).catch((err) => {
-        if (__DEV__) {
-          console.error("[initializeAuth] Auth state change handler error:", err);
-        }
-      });
+      void handleAuthStateChange(user);
     },
   });
 
-  if (authServiceInitFailed) {
-    console.warn("[initializeAuth] Auth service initialization failed. Some auth features may not work.");
-  }
-
   isInitialized = true;
   return { success: !authServiceInitFailed, auth };
 }

package/src/infrastructure/utils/AuthErrorMapper.ts

@@ -122,10 +122,6 @@ export function mapFirebaseAuthError(error: unknown): Error {
       );
 
     default:
-      // Log unknown errors in development for debugging
-      if (__DEV__ && code) {
-        console.warn(`[AuthErrorMapper] Unknown Firebase Auth code: ${code}`, error);
-      }
       return new AuthError(message, code || "AUTH_UNKNOWN_ERROR");
   }
 }

package/src/infrastructure/utils/authStateHandler.ts

@@ -35,10 +35,8 @@ export function createAuthStateHandler(
     if (conversion.isConversion && onUserConverted && state.current.previousUserId) {
       try {
         await onUserConverted(state.current.previousUserId, currentUserId);
-      } catch (error) {
-        if (__DEV__) {
-          console.warn("[AuthStateHandler] User conversion callback failed:", error);
-        }
+      } catch {
+        // Silently fail - conversion callback errors are handled elsewhere
       }
     }
 

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

@@ -72,17 +72,8 @@ async function performAnonymousSignIn(
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
             await anonymousAuthService.signInAnonymously(auth);
-
-            if (__DEV__) {
-                console.log("[AnonymousSignInHandler] Anonymous sign-in successful");
-            }
-
             return;
         } catch (error) {
-            if (__DEV__) {
-                console.warn(`[AnonymousSignInHandler] Attempt ${attempt + 1}/${maxRetries} failed:`, error);
-            }
-
             // If not last attempt, wait and retry
             if (attempt < maxRetries - 1) {
                 await new Promise(resolve => setTimeout(resolve, retryDelay));
@@ -110,9 +101,6 @@ export function createAnonymousSignInHandler(
 ): () => Promise<void> {
     return async () => {
         if (!auth) {
-            if (__DEV__) {
-                console.warn("[AnonymousSignInHandler] No auth instance");
-            }
             store.setFirebaseUser(null);
             store.setLoading(false);
             store.setInitialized(true);
@@ -125,21 +113,13 @@ export function createAnonymousSignInHandler(
             auth,
             {
                 onSignInStart: () => {
-                    if (__DEV__) {
-                        console.log("[AnonymousSignInHandler] Starting anonymous sign-in");
-                    }
+                    // Sign-in starting
                 },
                 onSignInSuccess: () => {
-                    if (__DEV__) {
-                        console.log("[AnonymousSignInHandler] Anonymous sign-in successful");
-                    }
                     // Listener will be triggered again with the new user
                     store.setFirebaseUser(null);
                 },
-                onSignInFailure: (error) => {
-                    if (__DEV__) {
-                        console.error("[AnonymousSignInHandler] All attempts failed:", error);
-                    }
+                onSignInFailure: () => {
                     store.setFirebaseUser(null);
                     store.setLoading(false);
                     store.setInitialized(true);

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

@@ -0,0 +1,144 @@
+/**
+ * Auth Listener Lifecycle Utilities
+ * Handles subscription and cleanup logic for auth listener
+ */
+
+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";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * 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);
+    }
+  }
+
+  const unsubscribe = onIdTokenChanged(auth, (user) => {
+    handleAuthStateChange(user, store, auth, autoAnonymousSignIn, onAuthStateChange);
+  });
+
+  setUnsubscribe(unsubscribe);
+}
+
+/**
+ * Handle auth state change from Firebase
+ */
+function handleAuthStateChange(
+  user: User | null,
+  store: Store,
+  auth: Auth,
+  autoAnonymousSignIn: boolean,
+  onAuthStateChange?: (user: User | null) => void
+): void {
+  if (!user && autoAnonymousSignIn) {
+    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);
+}
+
+/**
+ * Handle anonymous mode sign-in
+ */
+function handleAnonymousMode(store: Store, auth: Auth): void {
+  if (!startAnonymousSignIn()) {
+    return; // Already signing in
+  }
+
+  const handleAnonymousSignIn = createAnonymousSignInHandler(auth, store);
+
+  // Start sign-in without blocking
+  void (async () => {
+    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 () => {};
+}
+
+export function completeListenerSetup() {
+  completeInitialization();
+}

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

@@ -0,0 +1,125 @@
+/**
+ * Auth Listener State Management
+ * Manages the state of Firebase auth listener initialization and lifecycle
+ */
+
+export interface ListenerState {
+  initialized: boolean;
+  refCount: number;
+  initializationInProgress: boolean;
+  anonymousSignInInProgress: boolean;
+  unsubscribe: (() => void) | null;
+}
+
+const state: ListenerState = {
+  initialized: false,
+  refCount: 0,
+  initializationInProgress: false,
+  anonymousSignInInProgress: false,
+  unsubscribe: null,
+};
+
+/**
+ * Check if listener is initialized
+ */
+export function isListenerInitialized(): boolean {
+  return state.initialized;
+}
+
+/**
+ * Check if initialization is in progress
+ */
+export function isInitializationInProgress(): boolean {
+  return state.initializationInProgress;
+}
+
+/**
+ * Check if anonymous sign-in is in progress
+ */
+export function isAnonymousSignInInProgress(): boolean {
+  return state.anonymousSignInInProgress;
+}
+
+/**
+ * Get current reference count
+ */
+export function getRefCount(): number {
+  return state.refCount;
+}
+
+/**
+ * Mark initialization as started
+ */
+export function startInitialization(): boolean {
+  if (state.initializationInProgress) {
+    return false; // Already initializing
+  }
+  state.initializationInProgress = true;
+  return true;
+}
+
+/**
+ * Complete initialization
+ */
+export function completeInitialization(): void {
+  state.initializationInProgress = false;
+  state.initialized = true;
+  state.refCount = 1;
+}
+
+/**
+ * Set the unsubscribe function
+ */
+export function setUnsubscribe(fn: (() => void) | null): void {
+  state.unsubscribe = fn;
+}
+
+/**
+ * Increment reference count when a new subscriber joins
+ */
+export function incrementRefCount(): number {
+  state.refCount++;
+  return state.refCount;
+}
+
+/**
+ * Decrement reference count when a subscriber leaves
+ * Returns true if cleanup should be performed
+ */
+export function decrementRefCount(): { shouldCleanup: boolean; count: number } {
+  state.refCount--;
+  const shouldCleanup = state.refCount <= 0 && state.unsubscribe !== null;
+  return { shouldCleanup, count: state.refCount };
+}
+
+/**
+ * Mark anonymous sign-in as in progress
+ */
+export function startAnonymousSignIn(): boolean {
+  if (state.anonymousSignInInProgress) {
+    return false; // Already signing in
+  }
+  state.anonymousSignInInProgress = true;
+  return true;
+}
+
+/**
+ * Mark anonymous sign-in as complete
+ */
+export function completeAnonymousSignIn(): void {
+  state.anonymousSignInInProgress = false;
+}
+
+/**
+ * Reset all state (for testing)
+ */
+export function resetListenerState(): void {
+  if (state.unsubscribe) {
+    state.unsubscribe();
+  }
+  state.initialized = false;
+  state.refCount = 0;
+  state.initializationInProgress = false;
+  state.anonymousSignInInProgress = false;
+  state.unsubscribe = null;
+}

package/src/init/createAuthInitModule.ts

@@ -87,24 +87,12 @@ export function createAuthInitModule(
           autoAnonymousSignIn,
           storageProvider,
           onUserConverted: async (anonymousId: string, authenticatedId: string) => {
-            if (__DEV__) {
-              console.log('[createAuthInitModule] User converted:', {
-                anonymousId: anonymousId.slice(0, 8),
-                authenticatedId: authenticatedId.slice(0, 8),
-              });
-            }
-
             // Restore purchases after conversion (if callback provided)
             if (onRestorePurchases) {
               try {
                 await onRestorePurchases();
-                if (__DEV__) {
-                  console.log('[createAuthInitModule] Purchases restored');
-                }
-              } catch (error) {
-                if (__DEV__) {
-                  console.error('[createAuthInitModule] Restore failed:', error);
-                }
+              } catch {
+                // Silently fail - purchase restoration errors are handled elsewhere
               }
             }
 
@@ -115,15 +103,8 @@ export function createAuthInitModule(
           },
         });
 
-        if (__DEV__) {
-          console.log('[createAuthInitModule] Auth initialized');
-        }
-
         return true;
-      } catch (error) {
-        if (__DEV__) {
-          console.error('[createAuthInitModule] Error:', error);
-        }
+      } catch {
         return false;
       }
     },

package/src/presentation/components/AccountActions.tsx

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

package/src/presentation/components/AuthBottomSheet.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect } from "react";
+import React from "react";
 import { View, TouchableOpacity, ScrollView } from "react-native";
 import {
   useAppDesignTokens,
@@ -63,22 +63,6 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
     handleAppleSignIn,
   } = useAuthBottomSheet({ socialConfig, onGoogleSignIn, onAppleSignIn, onAuthSuccess });
 
-  useEffect(() => {
-    if (__DEV__) {
-      console.log("[AuthBottomSheet] Rendered with:", {
-        mode,
-        providersCount: providers.length,
-        hasModalRef: !!modalRef.current,
-        hasTermsUrl: !!termsUrl,
-        hasPrivacyUrl: !!privacyUrl,
-      });
-    }
-  }, [mode, providers.length, termsUrl, privacyUrl, modalRef]);
-
-  if (__DEV__) {
-    console.log("[AuthBottomSheet] Rendering...");
-  }
-
   return (
     <BottomSheetModal
       ref={modalRef}

package/src/presentation/hooks/useAccountManagement.ts

@@ -78,13 +78,6 @@ export const useAccountManagement = (
       throw new Error("Cannot delete anonymous account");
     }
 
-    if (__DEV__) {
-      console.log("[useAccountManagement] Starting delete account", {
-        userId: user.uid,
-        provider: user.provider,
-      });
-    }
-
     setIsDeletingAccount(true);
 
     try {

package/src/presentation/hooks/useAuth.ts

@@ -146,10 +146,8 @@ export function useAuth(): UseAuthResult {
       setLoading(true);
       await anonymousModeMutation.mutateAsync();
       setIsAnonymous(true);
-    } catch (error) {
-      if (__DEV__) {
-        console.warn("[useAuth] continueAnonymously failed:", error);
-      }
+    } catch {
+      // Silently fail - anonymous mode is optional
       setIsAnonymous(true);
     } finally {
       setLoading(false);