@umituz/react-native-auth 3.2.11 → 3.2.12

package/src/infrastructure/services/AuthService.ts

@@ -11,14 +11,14 @@ import type { AuthUser } from "../../domain/entities/AuthUser";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import { DEFAULT_AUTH_CONFIG } from "../../domain/value-objects/AuthConfig";
 import { AuthRepository } from "../repositories/AuthRepository";
-import { GuestModeService } from "./GuestModeService";
+import { AnonymousModeService } from "./AnonymousModeService";
 import { authEventService } from "./AuthEventService";
 import { authTracker } from "../utils/auth-tracker.util";
 import type { IStorageProvider } from "./AuthPackage";
 
 export class AuthService implements IAuthService {
   private repository!: AuthRepository;
-  private guestModeService: GuestModeService;
+  private anonymousModeService: AnonymousModeService;
   private storageProvider?: IStorageProvider;
   private initialized: boolean = false;
   private config: AuthConfig;
@@ -29,19 +29,9 @@ export class AuthService implements IAuthService {
       ...config,
       password: { ...DEFAULT_AUTH_CONFIG.password, ...config.password },
     };
-    // Initialize with a dummy provider effectively, or null?
-    // AuthRepository needs a provider. We can't init it without one.
-    // We'll initialize it properly in initialize()
-    // For now we can cast null or strict init check.
-    // Better: Allow repository to be nullable or initialize with a dummy/proxy.
-    // To satisfy strict TS, let's delay repository creation or create a NotInitializedProvider.
-    // But since initialize() sets it up, we can use a ! or optional.
-
-    this.guestModeService = new GuestModeService();
-    this.storageProvider = storageProvider;
 
-    // We can't instantiate AuthRepository yet if we don't have provider.
-    // So we'll have to keep it optional or allow late init.
+    this.anonymousModeService = new AnonymousModeService();
+    this.storageProvider = storageProvider;
   }
 
   private get repositoryInstance(): AuthRepository {
@@ -54,7 +44,6 @@ export class AuthService implements IAuthService {
 
     let provider: IAuthProvider;
 
-    // Check if it's a Firebase Auth instance (has currentUser property)
     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);
@@ -68,7 +57,7 @@ export class AuthService implements IAuthService {
     this.repository = new AuthRepository(provider, this.config);
 
     if (this.storageProvider) {
-      await this.guestModeService.load(this.storageProvider);
+      await this.anonymousModeService.load(this.storageProvider);
     }
     this.initialized = true;
   }
@@ -81,7 +70,7 @@ export class AuthService implements IAuthService {
     authTracker.logOperationStarted("Sign up", { email: params.email });
     try {
       const user = await this.repositoryInstance.signUp(params);
-      await this.clearGuestModeIfNeeded();
+      await this.clearAnonymousModeIfNeeded();
       authTracker.logOperationSuccess("Sign up", { userId: user.uid });
       authEventService.emitUserAuthenticated(user.uid);
       return user;
@@ -95,7 +84,7 @@ export class AuthService implements IAuthService {
     authTracker.logOperationStarted("Sign in", { email: params.email });
     try {
       const user = await this.repositoryInstance.signIn(params);
-      await this.clearGuestModeIfNeeded();
+      await this.clearAnonymousModeIfNeeded();
       authTracker.logOperationSuccess("Sign in", { userId: user.uid });
       authEventService.emitUserAuthenticated(user.uid);
       return user;
@@ -109,7 +98,7 @@ export class AuthService implements IAuthService {
     authTracker.logOperationStarted("Sign out");
     try {
       await this.repositoryInstance.signOut();
-      await this.clearGuestModeIfNeeded();
+      await this.clearAnonymousModeIfNeeded();
       authTracker.logOperationSuccess("Sign out");
     } catch (error) {
       authTracker.logOperationError("sign-out", error);
@@ -117,35 +106,35 @@ export class AuthService implements IAuthService {
     }
   }
 
-  private async clearGuestModeIfNeeded(): Promise<void> {
-    if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-      await this.guestModeService.clear(this.storageProvider);
+  private async clearAnonymousModeIfNeeded(): Promise<void> {
+    if (this.anonymousModeService.getIsAnonymousMode() && this.storageProvider) {
+      await this.anonymousModeService.clear(this.storageProvider);
     }
   }
 
-  async setGuestMode(): Promise<void> {
+  async setAnonymousMode(): Promise<void> {
     if (!this.storageProvider) {
-      throw new Error("Storage provider is required for guest mode");
+      throw new Error("Storage provider is required for anonymous mode");
     }
-    await this.guestModeService.enable(this.storageProvider);
+    await this.anonymousModeService.enable(this.storageProvider);
   }
 
   getCurrentUser(): AuthUser | null {
     if (!this.initialized) return null;
-    return this.guestModeService.getIsGuestMode() ? null : this.repositoryInstance.getCurrentUser();
+    return this.anonymousModeService.getIsAnonymousMode() ? null : this.repositoryInstance.getCurrentUser();
   }
 
-  getIsGuestMode(): boolean {
-    return this.guestModeService.getIsGuestMode();
+  getIsAnonymousMode(): boolean {
+    return this.anonymousModeService.getIsAnonymousMode();
   }
 
   onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
-    const wrappedCallback = this.guestModeService.wrapAuthStateCallback(callback);
+    const wrappedCallback = this.anonymousModeService.wrapAuthStateCallback(callback);
     return this.repositoryInstance.onAuthStateChange(wrappedCallback);
   }
 
   getConfig(): AuthConfig { return this.config; }
-  getGuestModeService(): GuestModeService { return this.guestModeService; }
+  getAnonymousModeService(): AnonymousModeService { return this.anonymousModeService; }
 }
 
 let authServiceInstance: AuthService | null = null;

package/src/infrastructure/storage/{GuestModeStorage.ts → AnonymousModeStorage.ts}

@@ -1,14 +1,14 @@
 /**
- * Guest Mode Storage
- * Single Responsibility: Manage guest mode persistence
+ * Anonymous Mode Storage
+ * Single Responsibility: Manage anonymous mode persistence
  */
 
 import { getAuthPackage } from "../services/AuthPackage";
 
-export async function loadGuestMode(storageKey?: string): Promise<boolean> {
+export async function loadAnonymousMode(storageKey?: string): Promise<boolean> {
   try {
     const packageConfig = getAuthPackage()?.getConfig();
-    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    const key = storageKey ?? packageConfig?.storageKeys.anonymousMode ?? "@auth_anonymous_mode";
 
     const storageProvider = getAuthPackage()?.getStorageProvider();
     if (!storageProvider) return false;
@@ -20,15 +20,15 @@ export async function loadGuestMode(storageKey?: string): Promise<boolean> {
   }
 }
 
-export async function saveGuestMode(isGuest: boolean, storageKey?: string): Promise<void> {
+export async function saveAnonymousMode(isAnonymous: boolean, storageKey?: string): Promise<void> {
   try {
     const packageConfig = getAuthPackage()?.getConfig();
-    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    const key = storageKey ?? packageConfig?.storageKeys.anonymousMode ?? "@auth_anonymous_mode";
 
     const storageProvider = getAuthPackage()?.getStorageProvider();
     if (!storageProvider) return;
 
-    if (isGuest) {
+    if (isAnonymous) {
       await storageProvider.set(key, "true");
     } else {
       await storageProvider.remove(key);
@@ -38,10 +38,10 @@ export async function saveGuestMode(isGuest: boolean, storageKey?: string): Prom
   }
 }
 
-export async function clearGuestMode(storageKey?: string): Promise<void> {
+export async function clearAnonymousMode(storageKey?: string): Promise<void> {
   try {
     const packageConfig = getAuthPackage()?.getConfig();
-    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    const key = storageKey ?? packageConfig?.storageKeys.anonymousMode ?? "@auth_anonymous_mode";
 
     const storageProvider = getAuthPackage()?.getStorageProvider();
     if (!storageProvider) return;

package/src/infrastructure/utils/AuthEventEmitter.ts

@@ -9,6 +9,6 @@ export function emitUserAuthenticated(userId: string): void {
   DeviceEventEmitter.emit("user-authenticated", { userId });
 }
 
-export function emitGuestModeEnabled(): void {
-  DeviceEventEmitter.emit("guest-mode-enabled");
+export function emitAnonymousModeEnabled(): void {
+  DeviceEventEmitter.emit("anonymous-mode-enabled");
 }

package/src/presentation/components/AuthBottomSheet.tsx

@@ -52,7 +52,7 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
 
   const { isVisible, mode, hideAuthModal, setMode, executePendingCallback, clearPendingCallback } =
     useAuthModalStore();
-  const { isAuthenticated, isGuest } = useAuth();
+  const { isAuthenticated, isAnonymous } = useAuth();
 
   useEffect(() => {
     if (isVisible) {
@@ -63,11 +63,11 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
   }, [isVisible]);
 
   useEffect(() => {
-    if (isAuthenticated && !isGuest && isVisible) {
+    if (isAuthenticated && !isAnonymous && isVisible) {
       hideAuthModal();
       executePendingCallback();
     }
-  }, [isAuthenticated, isGuest, isVisible, hideAuthModal, executePendingCallback]);
+  }, [isAuthenticated, isAnonymous, isVisible, hideAuthModal, executePendingCallback]);
 
   const handleDismiss = useCallback(() => {
     hideAuthModal();

package/src/presentation/hooks/mutations/useAuthMutations.ts

@@ -38,12 +38,12 @@ export const useSignOutMutation = () => {
     });
 };
 
-export const useGuestModeMutation = () => {
+export const useAnonymousModeMutation = () => {
     return useMutation({
         mutationFn: async (): Promise<void> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
-            return service.setGuestMode();
+            return service.setAnonymousMode();
         },
     });
 };

package/src/presentation/hooks/useAuth.ts

@@ -11,11 +11,10 @@ import {
   useAuthStore,
   selectUser,
   selectLoading,
-  selectIsGuest,
   selectError,
   selectSetLoading,
   selectSetError,
-  selectSetIsGuest,
+  selectSetIsAnonymous,
   selectIsAuthenticated,
   selectUserId,
   selectUserType,
@@ -27,7 +26,7 @@ import {
   useSignInMutation,
   useSignUpMutation,
   useSignOutMutation,
-  useGuestModeMutation,
+  useAnonymousModeMutation,
 } from "./mutations/useAuthMutations";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 
@@ -42,11 +41,9 @@ export interface UseAuthResult {
   loading: boolean;
   /** Whether auth is ready (initialized and not loading) */
   isAuthReady: boolean;
-  /** Whether user is in guest mode */
-  isGuest: boolean;
   /** Whether user is anonymous */
   isAnonymous: boolean;
-  /** Whether user is authenticated (not guest, not anonymous) */
+  /** Whether user is authenticated (not anonymous) */
   isAuthenticated: boolean;
   /** Current error message */
   error: string | null;
@@ -56,8 +53,8 @@ export interface UseAuthResult {
   signIn: (email: string, password: string) => Promise<void>;
   /** Sign out function */
   signOut: () => Promise<void>;
-  /** Continue as guest function */
-  continueAsGuest: () => Promise<void>;
+  /** Continue anonymously function */
+  continueAnonymously: () => Promise<void>;
   /** Set error manually (for form validation, etc.) */
   setError: (error: string | null) => void;
 }
@@ -72,7 +69,6 @@ export function useAuth(): UseAuthResult {
   // State from store - using typed selectors
   const user = useAuthStore(selectUser);
   const loading = useAuthStore(selectLoading);
-  const isGuest = useAuthStore(selectIsGuest);
   const error = useAuthStore(selectError);
   const isAuthenticated = useAuthStore(selectIsAuthenticated);
   const userId = useAuthStore(selectUserId);
@@ -83,13 +79,13 @@ export function useAuth(): UseAuthResult {
   // Actions from store - using typed selectors
   const setLoading = useAuthStore(selectSetLoading);
   const setError = useAuthStore(selectSetError);
-  const setIsGuest = useAuthStore(selectSetIsGuest);
+  const setIsAnonymous = useAuthStore(selectSetIsAnonymous);
 
   // Mutations
   const signInMutation = useSignInMutation();
   const signUpMutation = useSignUpMutation();
   const signOutMutation = useSignOutMutation();
-  const guestModeMutation = useGuestModeMutation();
+  const anonymousModeMutation = useAnonymousModeMutation();
 
   const signUp = useCallback(
     async (email: string, password: string, displayName?: string) => {
@@ -97,9 +93,7 @@ export function useAuth(): UseAuthResult {
         setLoading(true);
         setError(null);
         await signUpMutation.mutateAsync({ email, password, displayName });
-        if (isGuest) {
-          setIsGuest(false);
-        }
+        setIsAnonymous(false);
       } catch (err: unknown) {
         const errorMessage = err instanceof Error ? err.message : "Sign up failed";
         setError(errorMessage);
@@ -108,7 +102,7 @@ export function useAuth(): UseAuthResult {
         setLoading(false);
       }
     },
-    [isGuest, setIsGuest, setLoading, setError, signUpMutation]
+    [setIsAnonymous, setLoading, setError, signUpMutation]
   );
 
   const signIn = useCallback(
@@ -117,9 +111,7 @@ export function useAuth(): UseAuthResult {
         setLoading(true);
         setError(null);
         await signInMutation.mutateAsync({ email, password });
-        if (isGuest) {
-          setIsGuest(false);
-        }
+        setIsAnonymous(false);
       } catch (err: unknown) {
         const errorMessage = err instanceof Error ? err.message : "Sign in failed";
         setError(errorMessage);
@@ -128,7 +120,7 @@ export function useAuth(): UseAuthResult {
         setLoading(false);
       }
     },
-    [isGuest, setIsGuest, setLoading, setError, signInMutation]
+    [setIsAnonymous, setLoading, setError, signInMutation]
   );
 
   const signOut = useCallback(async () => {
@@ -140,17 +132,17 @@ export function useAuth(): UseAuthResult {
     }
   }, [setLoading, signOutMutation]);
 
-  const continueAsGuest = useCallback(async () => {
+  const continueAnonymously = useCallback(async () => {
     try {
       setLoading(true);
-      await guestModeMutation.mutateAsync();
-      setIsGuest(true);
+      await anonymousModeMutation.mutateAsync();
+      setIsAnonymous(true);
     } catch {
-      setIsGuest(true);
+      setIsAnonymous(true);
     } finally {
       setLoading(false);
     }
-  }, [setIsGuest, setLoading, guestModeMutation]);
+  }, [setIsAnonymous, setLoading, anonymousModeMutation]);
 
   return {
     user,
@@ -158,14 +150,13 @@ export function useAuth(): UseAuthResult {
     userType,
     loading,
     isAuthReady,
-    isGuest,
     isAnonymous,
     isAuthenticated,
     error,
     signUp,
     signIn,
     signOut,
-    continueAsGuest,
+    continueAnonymously,
     setError,
   };
 }

package/src/presentation/hooks/useAuthRequired.ts

@@ -22,7 +22,7 @@ import { useAuthModalStore } from "../stores/authModalStore";
 import { selectShowAuthModal } from "../stores/auth.selectors";
 
 export interface UseAuthRequiredResult {
-  /** Whether user is authenticated (not guest, not anonymous) */
+  /** Whether user is authenticated (not anonymous) */
   isAllowed: boolean;
   /** Whether auth is still loading */
   isLoading: boolean;

package/src/presentation/hooks/useLoginForm.ts

@@ -19,13 +19,13 @@ export interface UseLoginFormResult {
   handleEmailChange: (text: string) => void;
   handlePasswordChange: (text: string) => void;
   handleSignIn: () => Promise<void>;
-  handleContinueAsGuest: () => Promise<void>;
+  handleContinueAnonymously: () => Promise<void>;
   displayError: string | null;
 }
 
 export function useLoginForm(): UseLoginFormResult {
   const { t } = useLocalization();
-  const { signIn, loading, error, continueAsGuest } = useAuth();
+  const { signIn, loading, error, continueAnonymously } = useAuth();
 
   const [email, setEmail] = useState("");
   const [password, setPassword] = useState("");
@@ -81,13 +81,13 @@ export function useLoginForm(): UseLoginFormResult {
     }
   }, [email, password, t, signIn]);
 
-  const handleContinueAsGuest = useCallback(async () => {
+  const handleContinueAnonymously = useCallback(async () => {
     try {
-      await continueAsGuest();
+      await continueAnonymously();
     } catch {
-      // Silent fail - guest mode should always work
+      // Silent fail - anonymous mode should always work
     }
-  }, [continueAsGuest]);
+  }, [continueAnonymously]);
 
   const displayError = localError || error;
 
@@ -101,7 +101,7 @@ export function useLoginForm(): UseLoginFormResult {
     handleEmailChange,
     handlePasswordChange,
     handleSignIn,
-    handleContinueAsGuest,
+    handleContinueAnonymously,
     displayError,
   };
 }

package/src/presentation/hooks/useUserProfile.ts

@@ -6,7 +6,7 @@
 
 import { useMemo } from "react";
 import { useAuth } from "./useAuth";
-import { generateGuestName, type GuestNameConfig } from "../../domain/utils/guestNameGenerator";
+import { generateAnonymousName, type AnonymousNameConfig } from "../../domain/utils/anonymousNameGenerator";
 
 export interface UserProfileData {
     displayName?: string;
@@ -17,9 +17,9 @@ export interface UserProfileData {
 }
 
 export interface UseUserProfileParams {
-    guestDisplayName?: string;
+    anonymousDisplayName?: string;
     accountRoute?: string;
-    guestNameConfig?: GuestNameConfig;
+    anonymousNameConfig?: AnonymousNameConfig;
 }
 
 export const useUserProfile = (
@@ -27,9 +27,9 @@ export const useUserProfile = (
 ): UserProfileData | undefined => {
     const { user } = useAuth();
 
-    const guestName = params?.guestDisplayName;
+    const anonymousName = params?.anonymousDisplayName;
     const accountRoute = params?.accountRoute;
-    const nameConfig = params?.guestNameConfig;
+    const nameConfig = params?.anonymousNameConfig;
 
     return useMemo(() => {
         if (!user) {
@@ -40,7 +40,7 @@ export const useUserProfile = (
 
         if (isAnonymous) {
             return {
-                displayName: generateGuestName(user.uid, nameConfig),
+                displayName: generateAnonymousName(user.uid, nameConfig),
                 userId: user.uid,
                 isAnonymous: true,
                 accountSettingsRoute: accountRoute,
@@ -49,10 +49,10 @@ export const useUserProfile = (
 
         return {
             accountSettingsRoute: accountRoute,
-            displayName: user.displayName || user.email || guestName,
+            displayName: user.displayName || user.email || anonymousName,
             userId: user.uid,
             isAnonymous: false,
             avatarUrl: user.photoURL || undefined,
         };
-    }, [user, guestName, accountRoute, nameConfig]);
+    }, [user, anonymousName, accountRoute, nameConfig]);
 };

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

@@ -24,9 +24,9 @@ export const selectUser = (state: AuthStore): AuthUser | null => state.user;
 export const selectLoading = (state: AuthStore): boolean => state.loading;
 
 /**
- * Select guest mode
+ * Select anonymous mode (state flag)
  */
-export const selectIsGuest = (state: AuthStore): boolean => state.isGuest;
+export const selectIsAnonymousState = (state: AuthStore): boolean => state.isAnonymous;
 
 /**
  * Select error
@@ -54,9 +54,9 @@ export const selectSetLoading = (state: AuthStore) => state.setLoading;
 export const selectSetError = (state: AuthStore) => state.setError;
 
 /**
- * Select setIsGuest action
+ * Select setIsAnonymous action
  */
-export const selectSetIsGuest = (state: AuthStore) => state.setIsGuest;
+export const selectSetIsAnonymous = (state: AuthStore) => state.setIsAnonymous;
 
 /**
  * Select showAuthModal action (from authModalStore)
@@ -77,10 +77,10 @@ export const selectUserId = (state: AuthStore): string | null => {
 };
 
 /**
- * Check if user is authenticated (not guest, not anonymous)
+ * Check if user is authenticated (not anonymous)
  */
 export const selectIsAuthenticated = (state: AuthStore): boolean => {
-  return !!state.user && !state.isGuest && !state.user.isAnonymous;
+  return !!state.user && !state.isAnonymous && !state.user.isAnonymous;
 };
 
 /**

package/src/presentation/stores/authStore.ts

@@ -14,12 +14,12 @@ import { initialAuthState } from "../../types/auth-store.types";
 import {
   selectUser,
   selectLoading,
-  selectIsGuest,
+  selectIsAnonymousState,
   selectError,
   selectFirebaseUserId,
   selectSetLoading,
   selectSetError,
-  selectSetIsGuest,
+  selectSetIsAnonymous,
   selectUserId,
   selectIsAuthenticated,
   selectIsAnonymous,
@@ -34,12 +34,12 @@ export type { AuthState, AuthActions, UserType };
 export {
   selectUser,
   selectLoading,
-  selectIsGuest,
+  selectIsAnonymousState,
   selectError,
   selectFirebaseUserId,
   selectSetLoading,
   selectSetError,
-  selectSetIsGuest,
+  selectSetIsAnonymous,
   selectUserId,
   selectIsAuthenticated,
   selectIsAnonymous,
@@ -62,21 +62,21 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
   name: "auth-store",
   initialState: initialAuthState,
   persist: true,
-  version: 1,
+  version: 2,
   partialize: (state) => ({
-    isGuest: state.isGuest,
+    isAnonymous: state.isAnonymous,
     initialized: state.initialized,
   }),
   actions: (set, get) => ({
     setFirebaseUser: (firebaseUser) => {
-      const { isGuest } = get();
+      const { isAnonymous } = get();
 
       let user: AuthUser | null = null;
 
       if (firebaseUser) {
         if (!firebaseUser.isAnonymous) {
           user = mapToAuthUser(firebaseUser);
-        } else if (!isGuest) {
+        } else if (!isAnonymous) {
           user = mapToAuthUser(firebaseUser);
         }
       }
@@ -85,24 +85,25 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
         firebaseUser,
         user,
         loading: false,
+        isAnonymous: firebaseUser?.isAnonymous ?? false,
       });
     },
 
     setLoading: (loading) => set({ loading }),
 
-    setIsGuest: (isGuest) => {
+    setIsAnonymous: (isAnonymous) => {
       const { firebaseUser } = get();
 
       let user: AuthUser | null = null;
       if (firebaseUser) {
         if (!firebaseUser.isAnonymous) {
           user = mapToAuthUser(firebaseUser);
-        } else if (!isGuest) {
+        } else if (!isAnonymous) {
           user = mapToAuthUser(firebaseUser);
         }
       }
 
-      set({ isGuest, user });
+      set({ isAnonymous, user });
     },
 
     setError: (error) => set({ error }),
@@ -138,13 +139,6 @@ export function getIsAuthenticated(): boolean {
   return selectIsAuthenticated(useAuthStore.getState());
 }
 
-/**
- * Check if guest without hook
- */
-export function getIsGuest(): boolean {
-  return useAuthStore.getState().isGuest;
-}
-
 /**
  * Check if anonymous without hook
  */

package/src/presentation/stores/initializeAuthListener.ts

@@ -44,9 +44,9 @@ export function initializeAuthListener(
 
   const service = getAuthService();
   if (service) {
-    const isGuest = service.getIsGuestMode();
-    if (isGuest) {
-      store.setIsGuest(true);
+    const isAnonymous = service.getIsAnonymousMode();
+    if (isAnonymous) {
+      store.setIsAnonymous(true);
     }
   }
 
@@ -84,8 +84,8 @@ export function initializeAuthListener(
     store.setFirebaseUser(user);
     store.setInitialized(true);
 
-    if (user && !user.isAnonymous && store.isGuest) {
-      store.setIsGuest(false);
+    if (user && !user.isAnonymous && store.isAnonymous) {
+      store.setIsAnonymous(false);
     }
 
     // Call optional callback

package/src/types/auth-store.types.ts

@@ -21,8 +21,8 @@ export interface AuthState {
   firebaseUser: User | null;
   /** Loading state during auth operations */
   loading: boolean;
-  /** Guest mode (user skipped authentication) */
-  isGuest: boolean;
+  /** Anonymous mode (user using anonymous auth) */
+  isAnonymous: boolean;
   /** Error message from last auth operation */
   error: string | null;
   /** Whether auth listener has initialized */
@@ -37,8 +37,8 @@ export interface AuthActions {
   setFirebaseUser: (user: User | null) => void;
   /** Set loading state */
   setLoading: (loading: boolean) => void;
-  /** Set guest mode */
-  setIsGuest: (isGuest: boolean) => void;
+  /** Set anonymous mode */
+  setIsAnonymous: (isAnonymous: boolean) => void;
   /** Set error message */
   setError: (error: string | null) => void;
   /** Mark as initialized */
@@ -54,7 +54,7 @@ export const initialAuthState: AuthState = {
   user: null,
   firebaseUser: null,
   loading: true,
-  isGuest: false,
+  isAnonymous: false,
   error: null,
   initialized: false,
 };