@umituz/react-native-auth 3.2.0 → 3.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "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",
@@ -43,7 +43,9 @@
     "@umituz/react-native-storage": "*",
     "@umituz/react-native-tanstack": "*",
     "@umituz/react-native-validation": "*",
+    "expo-auth-session": ">=5.0.0",
     "expo-linear-gradient": ">=13.0.0",
+    "expo-web-browser": ">=12.0.0",
     "firebase": ">=11.0.0",
     "react": ">=18.2.0",
     "react-native": ">=0.74.0",
@@ -68,7 +70,7 @@
     "@types/react": "~19.1.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
-    "@umituz/react-native-design-system": "^2.5.1",
+    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-design-system-theme": "*",
     "@umituz/react-native-firebase": "^1.13.27",
     "@umituz/react-native-haptics": "*",
@@ -86,8 +88,10 @@
     "expo-device": "^8.0.10",
     "expo-file-system": "^19.0.21",
     "expo-haptics": "^15.0.8",
+    "expo-auth-session": "^5.0.0",
     "expo-linear-gradient": "^13.0.0",
     "expo-sharing": "^14.0.8",
+    "expo-web-browser": "^12.0.0",
     "firebase": "^11.0.0",
     "react": "~19.1.0",
     "react-native": "~0.81.5",

package/src/index.ts

@@ -135,6 +135,15 @@ export type { UseProfileUpdateReturn } from './presentation/hooks/useProfileUpda
 export { useProfileEdit } from './presentation/hooks/useProfileEdit';
 export type { UseProfileEditReturn, ProfileEditFormState } from './presentation/hooks/useProfileEdit';
 
+export { useSocialLogin } from './presentation/hooks/useSocialLogin';
+export type { UseSocialLoginConfig, UseSocialLoginResult } from './presentation/hooks/useSocialLogin';
+
+export { useGoogleAuth } from './presentation/hooks/useGoogleAuth';
+export type { UseGoogleAuthResult, GoogleAuthConfig as GoogleAuthHookConfig } from './presentation/hooks/useGoogleAuth';
+
+export { useAppleAuth } from './presentation/hooks/useAppleAuth';
+export type { UseAppleAuthResult } from './presentation/hooks/useAppleAuth';
+
 export type { UserProfile, UpdateProfileParams } from './domain/entities/UserProfile';
 
 // Domain Utils - Guest Names
@@ -175,6 +184,11 @@ export { PasswordMatchIndicator } from './presentation/components/PasswordMatchI
 export type { PasswordMatchIndicatorProps } from './presentation/components/PasswordMatchIndicator';
 export { AuthBottomSheet } from './presentation/components/AuthBottomSheet';
 export type { AuthBottomSheetProps } from './presentation/components/AuthBottomSheet';
+export { AuthBottomSheetWrapper } from './presentation/components/AuthBottomSheetWrapper';
+export type {
+  AuthBottomSheetWrapperProps,
+  SocialAuthConfiguration,
+} from './presentation/components/AuthBottomSheetWrapper';
 export { SocialLoginButtons } from './presentation/components/SocialLoginButtons';
 export type { SocialLoginButtonsProps } from './presentation/components/SocialLoginButtons';
 export { ProfileSection } from './presentation/components/ProfileSection';
@@ -193,6 +207,7 @@ export {
   useAuthStore,
   initializeAuthListener,
   resetAuthListener,
+  isAuthListenerInitialized,
   selectIsAuthenticated,
   selectUserId,
   selectIsAnonymous,
@@ -205,7 +220,8 @@ export {
   getIsAnonymous,
 } from './presentation/stores/authStore';
 
-export type { UserType } from './presentation/stores/authStore';
+export type { UserType, AuthState, AuthActions } from './presentation/stores/authStore';
+export type { AuthListenerOptions } from './types/auth-store.types';
 
 // =============================================================================
 // PRESENTATION LAYER - Utilities

package/src/infrastructure/services/AuthService.ts

@@ -146,7 +146,6 @@ export class AuthService implements IAuthService {
 
   getConfig(): AuthConfig { return this.config; }
   getGuestModeService(): GuestModeService { return this.guestModeService; }
-  getRepository(): AuthRepository { return this.repositoryInstance; }
 }
 
 let authServiceInstance: AuthService | null = null;

package/src/presentation/components/AuthBottomSheetWrapper.tsx

@@ -0,0 +1,115 @@
+/**
+ * AuthBottomSheetWrapper Component
+ * Self-contained auth modal with integrated social login
+ *
+ * This wrapper component combines AuthBottomSheet with social auth hooks,
+ * providing a complete authentication solution for apps.
+ *
+ * Usage:
+ * ```tsx
+ * <AuthBottomSheetWrapper
+ *   termsUrl="https://myapp.com/terms"
+ *   privacyUrl="https://myapp.com/privacy"
+ *   socialConfig={{
+ *     google: { webClientId: '...', iosClientId: '...' },
+ *     apple: { enabled: true }
+ *   }}
+ * />
+ * ```
+ */
+
+import React, { useCallback, useMemo } from "react";
+import { Platform } from "react-native";
+import { AuthBottomSheet } from "./AuthBottomSheet";
+import { useGoogleAuth, type GoogleAuthConfig } from "../hooks/useGoogleAuth";
+import { useAppleAuth } from "../hooks/useAppleAuth";
+import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
+
+declare const __DEV__: boolean;
+
+export interface SocialAuthConfiguration {
+  google?: GoogleAuthConfig;
+  apple?: { enabled: boolean };
+}
+
+export interface AuthBottomSheetWrapperProps {
+  /** Terms of Service URL */
+  termsUrl?: string;
+  /** Privacy Policy URL */
+  privacyUrl?: string;
+  /** Called when Terms link is pressed (overrides default behavior) */
+  onTermsPress?: () => void;
+  /** Called when Privacy link is pressed (overrides default behavior) */
+  onPrivacyPress?: () => void;
+  /** Social auth configuration */
+  socialConfig?: SocialAuthConfiguration;
+}
+
+/**
+ * Self-contained auth bottom sheet with integrated social login
+ */
+export const AuthBottomSheetWrapper: React.FC<AuthBottomSheetWrapperProps> = ({
+  termsUrl,
+  privacyUrl,
+  onTermsPress,
+  onPrivacyPress,
+  socialConfig,
+}) => {
+  const { signInWithGoogle, googleConfigured } = useGoogleAuth(socialConfig?.google);
+  const { signInWithApple, appleAvailable } = useAppleAuth();
+
+  const providers = useMemo<SocialAuthProvider[]>(() => {
+    const result: SocialAuthProvider[] = [];
+
+    if (Platform.OS === "ios" && socialConfig?.apple?.enabled && appleAvailable) {
+      result.push("apple");
+    }
+
+    if (googleConfigured) {
+      result.push("google");
+    }
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[AuthBottomSheetWrapper] Enabled providers:", result);
+    }
+
+    return result;
+  }, [socialConfig?.apple?.enabled, appleAvailable, googleConfigured]);
+
+  const handleGoogleSignIn = useCallback(async () => {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[AuthBottomSheetWrapper] Google sign-in requested");
+    }
+    const result = await signInWithGoogle();
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[AuthBottomSheetWrapper] Google result:", result);
+    }
+  }, [signInWithGoogle]);
+
+  const handleAppleSignIn = useCallback(async () => {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[AuthBottomSheetWrapper] Apple sign-in requested");
+    }
+    const result = await signInWithApple();
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[AuthBottomSheetWrapper] Apple result:", result);
+    }
+  }, [signInWithApple]);
+
+  return (
+    <AuthBottomSheet
+      termsUrl={termsUrl}
+      privacyUrl={privacyUrl}
+      onTermsPress={onTermsPress}
+      onPrivacyPress={onPrivacyPress}
+      socialProviders={providers}
+      onGoogleSignIn={handleGoogleSignIn}
+      onAppleSignIn={handleAppleSignIn}
+    />
+  );
+};

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

@@ -13,8 +13,7 @@ export const useSignUpMutation = () => {
         mutationFn: async (params: SignUpParams): Promise<AuthUser> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
-            // Access repository directly
-            return service.getRepository().signUp(params);
+            return service.signUp(params);
         },
     });
 };
@@ -24,7 +23,7 @@ export const useSignInMutation = () => {
         mutationFn: async (params: SignInParams): Promise<AuthUser> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
-            return service.getRepository().signIn(params);
+            return service.signIn(params);
         },
     });
 };
@@ -34,7 +33,7 @@ export const useSignOutMutation = () => {
         mutationFn: async (): Promise<void> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
-            return service.getRepository().signOut();
+            return service.signOut();
         },
     });
 };

package/src/presentation/hooks/useAppleAuth.ts

@@ -0,0 +1,61 @@
+/**
+ * useAppleAuth Hook
+ * Handles Apple Sign-In using Firebase auth
+ *
+ * This is a convenience wrapper around useSocialAuth from Firebase package
+ * specifically for Apple authentication.
+ */
+
+import { useCallback } from "react";
+import { Platform } from "react-native";
+import {
+  useSocialAuth,
+  type SocialAuthResult,
+} from "@umituz/react-native-firebase";
+
+declare const __DEV__: boolean;
+
+export interface UseAppleAuthResult {
+  signInWithApple: () => Promise<SocialAuthResult>;
+  appleLoading: boolean;
+  appleAvailable: boolean;
+}
+
+/**
+ * Hook for Apple authentication
+ */
+export function useAppleAuth(): UseAppleAuthResult {
+  const { signInWithApple, appleLoading, appleAvailable } = useSocialAuth({
+    apple: { enabled: Platform.OS === "ios" },
+  });
+
+  const handleSignInWithApple = useCallback(async (): Promise<SocialAuthResult> => {
+    if (Platform.OS !== "ios") {
+      return { success: false, error: "Apple Sign-In is only available on iOS" };
+    }
+
+    if (!appleAvailable) {
+      return { success: false, error: "Apple Sign-In is not available" };
+    }
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useAppleAuth] Apple sign-in requested");
+    }
+
+    const result = await signInWithApple();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useAppleAuth] Apple sign-in result:", result);
+    }
+
+    return result;
+  }, [appleAvailable, signInWithApple]);
+
+  return {
+    signInWithApple: handleSignInWithApple,
+    appleLoading,
+    appleAvailable,
+  };
+}

package/src/presentation/hooks/useGoogleAuth.ts

@@ -0,0 +1,184 @@
+/**
+ * useGoogleAuth Hook
+ * Handles Google OAuth flow using expo-auth-session and Firebase auth
+ *
+ * This hook provides complete Google sign-in flow:
+ * 1. OAuth flow via expo-auth-session
+ * 2. Firebase authentication with the obtained token
+ */
+
+import { useState, useCallback, useEffect } from "react";
+import {
+  useSocialAuth,
+  type SocialAuthConfig,
+  type SocialAuthResult,
+} from "@umituz/react-native-firebase";
+
+declare const __DEV__: boolean;
+
+// Type declarations for expo-auth-session
+interface GoogleAuthRequestConfig {
+  iosClientId: string;
+  webClientId: string;
+  androidClientId: string;
+}
+
+interface AuthSessionAuthentication {
+  idToken?: string;
+  accessToken?: string;
+}
+
+interface AuthSessionResult {
+  type: "success" | "cancel" | "dismiss" | "error" | "locked";
+  authentication?: AuthSessionAuthentication;
+}
+
+interface AuthRequest {
+  promptAsync: () => Promise<AuthSessionResult>;
+}
+
+type UseAuthRequestReturn = [
+  AuthRequest | null,
+  AuthSessionResult | null,
+  () => Promise<AuthSessionResult>,
+];
+
+// Dynamic imports to handle optional dependencies
+type GoogleModule = { useAuthRequest: (config: GoogleAuthRequestConfig) => UseAuthRequestReturn };
+type WebBrowserModule = { maybeCompleteAuthSession: () => void };
+
+let Google: GoogleModule | null = null;
+let WebBrowser: WebBrowserModule | null = null;
+
+try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+  Google = require("expo-auth-session/providers/google") as GoogleModule;
+  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+  WebBrowser = require("expo-web-browser") as WebBrowserModule;
+  if (WebBrowser) {
+    WebBrowser.maybeCompleteAuthSession();
+  }
+} catch {
+  // expo-auth-session not available
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[useGoogleAuth] expo-auth-session not available");
+  }
+}
+
+export interface GoogleAuthConfig {
+  iosClientId?: string;
+  webClientId?: string;
+  androidClientId?: string;
+}
+
+export interface UseGoogleAuthResult {
+  signInWithGoogle: () => Promise<SocialAuthResult>;
+  googleLoading: boolean;
+  googleConfigured: boolean;
+}
+
+const PLACEHOLDER_CLIENT_ID = "000000000000-placeholder.apps.googleusercontent.com";
+
+/**
+ * Hook for Google authentication with expo-auth-session
+ */
+export function useGoogleAuth(config?: GoogleAuthConfig): UseGoogleAuthResult {
+  const [isLoading, setIsLoading] = useState(false);
+
+  const googleConfigured = !!(
+    config?.iosClientId ||
+    config?.webClientId ||
+    config?.androidClientId
+  );
+
+  const socialAuthConfig: SocialAuthConfig = {
+    google: config,
+    apple: { enabled: false },
+  };
+
+  const { signInWithGoogleToken, googleLoading: firebaseLoading } =
+    useSocialAuth(socialAuthConfig);
+
+  // Use Google auth request if available
+  const authRequest = Google?.useAuthRequest({
+    iosClientId: config?.iosClientId || PLACEHOLDER_CLIENT_ID,
+    webClientId: config?.webClientId || PLACEHOLDER_CLIENT_ID,
+    androidClientId: config?.androidClientId || PLACEHOLDER_CLIENT_ID,
+  });
+
+  const request = authRequest?.[0] ?? null;
+  const googleResponse = authRequest?.[1] ?? null;
+  const promptGoogleAsync = authRequest?.[2];
+
+  // Handle Google OAuth response
+  useEffect(() => {
+    if (googleResponse?.type === "success") {
+      const idToken = googleResponse.authentication?.idToken;
+      if (idToken) {
+        setIsLoading(true);
+        signInWithGoogleToken(idToken)
+          .catch((error: unknown) => {
+            if (__DEV__) {
+              // eslint-disable-next-line no-console
+              console.error("[useGoogleAuth] Firebase sign-in error:", error);
+            }
+          })
+          .finally(() => {
+            setIsLoading(false);
+          });
+      }
+    }
+  }, [googleResponse, signInWithGoogleToken]);
+
+  const signInWithGoogle = useCallback(async (): Promise<SocialAuthResult> => {
+    if (!Google || !promptGoogleAsync) {
+      return { success: false, error: "expo-auth-session is not available" };
+    }
+
+    if (!googleConfigured) {
+      return { success: false, error: "Google Sign-In is not configured" };
+    }
+
+    if (!request) {
+      return { success: false, error: "Google Sign-In not ready" };
+    }
+
+    setIsLoading(true);
+    try {
+      const result = await promptGoogleAsync();
+
+      if (result.type === "success" && result.authentication?.idToken) {
+        const firebaseResult = await signInWithGoogleToken(
+          result.authentication.idToken,
+        );
+
+        if (__DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[useGoogleAuth] Sign-in successful:", firebaseResult);
+        }
+
+        return firebaseResult;
+      }
+
+      if (result.type === "cancel") {
+        return { success: false, error: "Google Sign-In was cancelled" };
+      }
+
+      return { success: false, error: "Google Sign-In failed" };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Google sign-in failed",
+      };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [googleConfigured, request, promptGoogleAsync, signInWithGoogleToken]);
+
+  return {
+    signInWithGoogle,
+    googleLoading: isLoading || firebaseLoading,
+    googleConfigured,
+  };
+}

package/src/presentation/hooks/useSocialLogin.ts

@@ -0,0 +1,115 @@
+/**
+ * useSocialLogin Hook
+ * Provides unified social login functionality using Firebase package
+ *
+ * This hook wraps @umituz/react-native-firebase's useSocialAuth
+ * and provides a simple interface for social authentication.
+ *
+ * Usage:
+ * ```typescript
+ * const { signInWithGoogle, signInWithApple, googleLoading, appleLoading } = useSocialLogin({
+ *   google: { webClientId: '...', iosClientId: '...' },
+ *   apple: { enabled: true }
+ * });
+ * ```
+ */
+
+import { useCallback } from "react";
+import { Platform } from "react-native";
+import {
+  useSocialAuth,
+  type SocialAuthConfig,
+  type SocialAuthResult,
+} from "@umituz/react-native-firebase";
+
+declare const __DEV__: boolean;
+
+export interface UseSocialLoginConfig extends SocialAuthConfig {}
+
+export interface UseSocialLoginResult {
+  /** Sign in with Google (handles OAuth flow internally if configured) */
+  signInWithGoogle: () => Promise<SocialAuthResult>;
+  /** Sign in with Apple */
+  signInWithApple: () => Promise<SocialAuthResult>;
+  /** Whether Google sign-in is in progress */
+  googleLoading: boolean;
+  /** Whether Apple sign-in is in progress */
+  appleLoading: boolean;
+  /** Whether Google is configured */
+  googleConfigured: boolean;
+  /** Whether Apple is available */
+  appleAvailable: boolean;
+}
+
+/**
+ * Hook for social authentication
+ * Integrates with @umituz/react-native-firebase for Firebase auth
+ */
+export function useSocialLogin(config?: UseSocialLoginConfig): UseSocialLoginResult {
+  const {
+    signInWithApple: firebaseSignInWithApple,
+    googleLoading,
+    appleLoading,
+    googleConfigured,
+    appleAvailable,
+  } = useSocialAuth(config);
+
+  /**
+   * Sign in with Google
+   * Note: For full OAuth flow, use useGoogleAuth hook which handles
+   * expo-auth-session OAuth flow and Firebase authentication
+   */
+  const signInWithGoogle = useCallback((): Promise<SocialAuthResult> => {
+    if (!googleConfigured) {
+      return Promise.resolve({ success: false, error: "Google Sign-In is not configured" });
+    }
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useSocialLogin] Use useGoogleAuth hook for Google OAuth flow");
+    }
+
+    return Promise.resolve({
+      success: false,
+      error: "Use useGoogleAuth hook for Google OAuth flow",
+    });
+  }, [googleConfigured]);
+
+  /**
+   * Sign in with Apple (full flow handled by Firebase package)
+   */
+  const signInWithApple = useCallback(async (): Promise<SocialAuthResult> => {
+    if (Platform.OS !== "ios") {
+      return { success: false, error: "Apple Sign-In is only available on iOS" };
+    }
+
+    if (!appleAvailable) {
+      return { success: false, error: "Apple Sign-In is not available" };
+    }
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useSocialLogin] Apple sign-in requested");
+    }
+
+    const result = await firebaseSignInWithApple();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useSocialLogin] Apple sign-in result:", result);
+    }
+
+    return result;
+  }, [appleAvailable, firebaseSignInWithApple]);
+
+  return {
+    signInWithGoogle,
+    signInWithApple,
+    googleLoading,
+    appleLoading,
+    googleConfigured,
+    appleAvailable,
+  };
+}
+
+export { type SocialAuthConfig, type SocialAuthResult };

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

@@ -0,0 +1,48 @@
+/**
+ * Auth Store Selectors
+ * Pure functions for deriving state from auth store
+ */
+
+import type { AuthState, UserType } from "../../types/auth-store.types";
+
+/**
+ * Get current user ID
+ */
+export const selectUserId = (state: AuthState): string | null => {
+  return state.firebaseUser?.uid ?? state.user?.uid ?? null;
+};
+
+/**
+ * Check if user is authenticated (not guest, not anonymous)
+ */
+export const selectIsAuthenticated = (state: AuthState): boolean => {
+  return !!state.user && !state.isGuest && !state.user.isAnonymous;
+};
+
+/**
+ * Check if user is anonymous
+ */
+export const selectIsAnonymous = (state: AuthState): boolean => {
+  return state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
+};
+
+/**
+ * Get current user type
+ */
+export const selectUserType = (state: AuthState): UserType => {
+  if (!state.firebaseUser && !state.user) {
+    return "none";
+  }
+
+  const isAnonymous =
+    state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
+
+  return isAnonymous ? "anonymous" : "authenticated";
+};
+
+/**
+ * Check if auth is ready (initialized and not loading)
+ */
+export const selectIsAuthReady = (state: AuthState): boolean => {
+  return state.initialized && !state.loading;
+};

package/src/presentation/stores/authStore.ts

@@ -1,79 +1,50 @@
 /**
  * Auth Store
- * Centralized auth state management using Zustand with AsyncStorage persistence
+ * Centralized auth state management using Zustand with persistence
  *
  * Single source of truth for auth state across the app.
  * Firebase auth changes are synced via initializeAuthListener().
  */
 
 import { createStore } from "@umituz/react-native-storage";
-import { onAuthStateChanged, type User } from "firebase/auth";
-import { getFirebaseAuth } from "@umituz/react-native-firebase";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import { mapToAuthUser } from "../../infrastructure/utils/UserMapper";
-import { getAuthService } from "../../infrastructure/services/AuthService";
-
-declare const __DEV__: boolean;
-
-/**
- * User type classification
- */
-export type UserType = "authenticated" | "anonymous" | "none";
-
-// =============================================================================
-// STATE TYPES
-// =============================================================================
-
-interface AuthState {
-  /** Mapped AuthUser (null if not authenticated) */
-  user: AuthUser | null;
-  /** Raw Firebase user reference */
-  firebaseUser: User | null;
-  /** Loading state during auth operations */
-  loading: boolean;
-  /** Guest mode (user skipped authentication) */
-  isGuest: boolean;
-  /** Error message from last auth operation */
-  error: string | null;
-  /** Whether auth listener has initialized */
-  initialized: boolean;
-}
-
-interface AuthActions {
-  /** Update user from Firebase listener */
-  setFirebaseUser: (user: User | null) => void;
-  /** Set loading state */
-  setLoading: (loading: boolean) => void;
-  /** Set guest mode */
-  setIsGuest: (isGuest: boolean) => void;
-  /** Set error message */
-  setError: (error: string | null) => void;
-  /** Mark as initialized */
-  setInitialized: (initialized: boolean) => void;
-  /** Reset to initial state */
-  reset: () => void;
-}
-
-// =============================================================================
-// INITIAL STATE
-// =============================================================================
-
-const initialState: AuthState = {
-  user: null,
-  firebaseUser: null,
-  loading: true,
-  isGuest: false,
-  error: null,
-  initialized: false,
+import type { AuthState, AuthActions, UserType } from "../../types/auth-store.types";
+import { initialAuthState } from "../../types/auth-store.types";
+import {
+  selectUserId,
+  selectIsAuthenticated,
+  selectIsAnonymous,
+  selectUserType,
+  selectIsAuthReady,
+} from "./auth.selectors";
+
+// Re-export types for convenience
+export type { AuthState, AuthActions, UserType };
+
+// Re-export selectors
+export {
+  selectUserId,
+  selectIsAuthenticated,
+  selectIsAnonymous,
+  selectUserType,
+  selectIsAuthReady,
 };
 
+// Re-export listener functions
+export {
+  initializeAuthListener,
+  resetAuthListener,
+  isAuthListenerInitialized,
+} from "./initializeAuthListener";
+
 // =============================================================================
 // STORE
 // =============================================================================
 
 export const useAuthStore = createStore<AuthState, AuthActions>({
   name: "auth-store",
-  initialState,
+  initialState: initialAuthState,
   persist: true,
   version: 1,
   partialize: (state) => ({
@@ -122,56 +93,10 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
 
     setInitialized: (initialized) => set({ initialized }),
 
-    reset: () => set(initialState),
+    reset: () => set(initialAuthState),
   }),
 });
 
-// =============================================================================
-// SELECTORS
-// =============================================================================
-
-/**
- * Get current user ID
- */
-export const selectUserId = (state: AuthState): string | null => {
-  return state.firebaseUser?.uid ?? state.user?.uid ?? null;
-};
-
-/**
- * Check if user is authenticated (not guest, not anonymous)
- */
-export const selectIsAuthenticated = (state: AuthState): boolean => {
-  return !!state.user && !state.isGuest && !state.user.isAnonymous;
-};
-
-/**
- * Check if user is anonymous
- */
-export const selectIsAnonymous = (state: AuthState): boolean => {
-  return state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
-};
-
-/**
- * Get current user type
- */
-export const selectUserType = (state: AuthState): UserType => {
-  if (!state.firebaseUser && !state.user) {
-    return "none";
-  }
-
-  const isAnonymous =
-    state.firebaseUser?.isAnonymous ?? state.user?.isAnonymous ?? false;
-
-  return isAnonymous ? "anonymous" : "authenticated";
-};
-
-/**
- * Check if auth is ready (initialized and not loading)
- */
-export const selectIsAuthReady = (state: AuthState): boolean => {
-  return state.initialized && !state.loading;
-};
-
 // =============================================================================
 // NON-HOOK GETTERS
 // =============================================================================
@@ -210,64 +135,3 @@ export function getIsGuest(): boolean {
 export function getIsAnonymous(): boolean {
   return selectIsAnonymous(useAuthStore.getState());
 }
-
-// =============================================================================
-// LISTENER
-// =============================================================================
-
-let listenerInitialized = false;
-
-/**
- * Initialize Firebase auth listener
- * Call once in app root, returns unsubscribe function
- */
-export function initializeAuthListener(): () => void {
-  if (listenerInitialized) {
-    return () => {};
-  }
-
-  const auth = getFirebaseAuth();
-  const store = useAuthStore.getState();
-
-  if (!auth) {
-    store.setLoading(false);
-    store.setInitialized(true);
-    return () => {};
-  }
-
-  const service = getAuthService();
-  if (service) {
-    const isGuest = service.getIsGuestMode();
-    if (isGuest) {
-      store.setIsGuest(true);
-    }
-  }
-
-  listenerInitialized = true;
-
-  const unsubscribe = onAuthStateChanged(auth, (user) => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[authStore] Auth state changed:", user?.uid ?? "null");
-    }
-
-    store.setFirebaseUser(user);
-    store.setInitialized(true);
-
-    if (user && !user.isAnonymous && store.isGuest) {
-      store.setIsGuest(false);
-    }
-  });
-
-  return () => {
-    unsubscribe();
-    listenerInitialized = false;
-  };
-}
-
-/**
- * Reset listener state (for testing)
- */
-export function resetAuthListener(): void {
-  listenerInitialized = false;
-}

package/src/presentation/stores/initializeAuthListener.ts

@@ -0,0 +1,113 @@
+/**
+ * Auth Listener Initialization
+ * Sets up Firebase auth state listener with optional auto anonymous sign-in
+ */
+
+import { onAuthStateChanged } from "firebase/auth";
+import {
+  getFirebaseAuth,
+  anonymousAuthService,
+} from "@umituz/react-native-firebase";
+import { useAuthStore } from "./authStore";
+import { getAuthService } from "../../infrastructure/services/AuthService";
+import type { AuthListenerOptions } from "../../types/auth-store.types";
+
+declare const __DEV__: boolean;
+
+let listenerInitialized = false;
+
+/**
+ * Initialize Firebase auth listener
+ * Call once in app root, returns unsubscribe function
+ *
+ * @param options - Configuration options
+ * @param options.autoAnonymousSignIn - Enable auto anonymous sign-in (default: true)
+ * @param options.onAuthStateChange - Callback when auth state changes
+ */
+export function initializeAuthListener(
+  options: AuthListenerOptions = {}
+): () => void {
+  const { autoAnonymousSignIn = true, onAuthStateChange } = options;
+
+  if (listenerInitialized) {
+    return () => {};
+  }
+
+  const auth = getFirebaseAuth();
+  const store = useAuthStore.getState();
+
+  if (!auth) {
+    store.setLoading(false);
+    store.setInitialized(true);
+    return () => {};
+  }
+
+  const service = getAuthService();
+  if (service) {
+    const isGuest = service.getIsGuestMode();
+    if (isGuest) {
+      store.setIsGuest(true);
+    }
+  }
+
+  listenerInitialized = true;
+
+  const unsubscribe = onAuthStateChanged(auth, (user) => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[authStore] Auth state changed:", user?.uid ?? "null");
+    }
+
+    // Auto sign-in anonymously if no user and autoAnonymousSignIn is enabled
+    if (!user && autoAnonymousSignIn) {
+      void (async () => {
+        try {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[authStore] Auto signing in anonymously...");
+          }
+          await anonymousAuthService.signInAnonymously(auth);
+          // The listener will be called again with the new anonymous user
+        } catch (error) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.warn("[authStore] Auto anonymous sign-in failed:", error);
+          }
+          // Continue with null user if anonymous sign-in fails
+          store.setFirebaseUser(null);
+          store.setInitialized(true);
+        }
+      })();
+      return;
+    }
+
+    store.setFirebaseUser(user);
+    store.setInitialized(true);
+
+    if (user && !user.isAnonymous && store.isGuest) {
+      store.setIsGuest(false);
+    }
+
+    // Call optional callback
+    onAuthStateChange?.(user);
+  });
+
+  return () => {
+    unsubscribe();
+    listenerInitialized = false;
+  };
+}
+
+/**
+ * Reset listener state (for testing)
+ */
+export function resetAuthListener(): void {
+  listenerInitialized = false;
+}
+
+/**
+ * Check if listener is initialized
+ */
+export function isAuthListenerInitialized(): boolean {
+  return listenerInitialized;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * Auth Store Types
+ * Type definitions for auth state management
+ */
+
+import type { User } from "firebase/auth";
+import type { AuthUser } from "../domain/entities/AuthUser";
+
+/**
+ * User type classification
+ */
+export type UserType = "authenticated" | "anonymous" | "none";
+
+/**
+ * Auth state interface
+ */
+export interface AuthState {
+  /** Mapped AuthUser (null if not authenticated) */
+  user: AuthUser | null;
+  /** Raw Firebase user reference */
+  firebaseUser: User | null;
+  /** Loading state during auth operations */
+  loading: boolean;
+  /** Guest mode (user skipped authentication) */
+  isGuest: boolean;
+  /** Error message from last auth operation */
+  error: string | null;
+  /** Whether auth listener has initialized */
+  initialized: boolean;
+}
+
+/**
+ * Auth store actions interface
+ */
+export interface AuthActions {
+  /** Update user from Firebase listener */
+  setFirebaseUser: (user: User | null) => void;
+  /** Set loading state */
+  setLoading: (loading: boolean) => void;
+  /** Set guest mode */
+  setIsGuest: (isGuest: boolean) => void;
+  /** Set error message */
+  setError: (error: string | null) => void;
+  /** Mark as initialized */
+  setInitialized: (initialized: boolean) => void;
+  /** Reset to initial state */
+  reset: () => void;
+}
+
+/**
+ * Initial auth state
+ */
+export const initialAuthState: AuthState = {
+  user: null,
+  firebaseUser: null,
+  loading: true,
+  isGuest: false,
+  error: null,
+  initialized: false,
+};
+
+/**
+ * Auth listener initialization options
+ */
+export interface AuthListenerOptions {
+  /** Enable auto anonymous sign-in when no user is logged in */
+  autoAnonymousSignIn?: boolean;
+  /** Callback when auth state changes */
+  onAuthStateChange?: (user: User | null) => void;
+}