@umituz/react-native-auth 1.12.0 → 2.0.2

package/lib/presentation/hooks/useAuthActions.js

@@ -0,0 +1,162 @@
+/**
+ * useAuthActions Hook
+ * Single Responsibility: Handle authentication actions
+ */
+import { useCallback } from "react";
+import { getAuthService } from "../../infrastructure/services/AuthService";
+/**
+ * Hook for authentication actions
+ */
+export function useAuthActions(state) {
+    const { isGuest, setIsGuest, setLoading, setError } = state;
+    const signUp = useCallback(async (email, password, displayName) => {
+        const service = getAuthService();
+        if (!service) {
+            const err = "Auth service is not initialized";
+            setError(err);
+            throw new Error(err);
+        }
+        try {
+            setLoading(true);
+            setError(null);
+            await service.signUp({ email, password, displayName });
+            if (isGuest) {
+                setIsGuest(false);
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : "Sign up failed";
+            setError(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isGuest, setIsGuest, setLoading, setError]);
+    const signIn = useCallback(async (email, password) => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+            console.log("[useAuthActions] signIn called with email:", email);
+        }
+        const service = getAuthService();
+        if (!service) {
+            const err = "Auth service is not initialized";
+            setError(err);
+            throw new Error(err);
+        }
+        try {
+            setLoading(true);
+            setError(null);
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] Calling service.signIn()");
+            }
+            await service.signIn({ email, password });
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] Service.signIn() completed successfully");
+            }
+            if (isGuest) {
+                /* eslint-disable-next-line no-console */
+                if (__DEV__) {
+                    console.log("[useAuthActions] Clearing guest mode after sign in");
+                }
+                setIsGuest(false);
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : "Sign in failed";
+            setError(errorMessage);
+            throw err;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [isGuest, setIsGuest, setLoading, setError]);
+    const signOut = useCallback(async () => {
+        const service = getAuthService();
+        if (!service) {
+            return;
+        }
+        try {
+            setLoading(true);
+            await service.signOut();
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [setLoading]);
+    const continueAsGuest = useCallback(async () => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+            console.log("========================================");
+            console.log("[useAuthActions] 🎯 continueAsGuest() CALLED");
+            console.log("[useAuthActions] Current state:", {
+                isGuest,
+                loading: state.loading,
+            });
+            console.log("========================================");
+        }
+        const service = getAuthService();
+        if (!service) {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] ⚠️ No service available, setting isGuest directly");
+            }
+            setIsGuest(true);
+            return;
+        }
+        try {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] Setting loading to true...");
+            }
+            setLoading(true);
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] 📞 Calling service.setGuestMode()...");
+            }
+            await service.setGuestMode();
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] ✅ Service.setGuestMode() completed successfully");
+                console.log("[useAuthActions] Setting isGuest to true...");
+            }
+            setIsGuest(true);
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] ✅ isGuest set to true");
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Failed to continue as guest";
+            setError(errorMessage);
+            if (__DEV__) {
+                console.error("[useAuthActions] ❌ ERROR in continueAsGuest:", error);
+                console.error("[useAuthActions] Error details:", {
+                    message: errorMessage,
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+            }
+            setIsGuest(true);
+        }
+        finally {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] Setting loading to false...");
+            }
+            setLoading(false);
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useAuthActions] ✅ continueAsGuest() FINISHED");
+                console.log("========================================");
+            }
+        }
+    }, [isGuest, setIsGuest, setLoading, state.loading]);
+    return {
+        signUp,
+        signIn,
+        signOut,
+        continueAsGuest,
+    };
+}

package/lib/presentation/hooks/useAuthState.d.ts

@@ -0,0 +1,19 @@
+/**
+ * useAuthState Hook
+ * Single Responsibility: Manage authentication state
+ */
+import type { AuthUser } from "../../domain/entities/AuthUser";
+export interface UseAuthStateResult {
+    user: AuthUser | null;
+    isAuthenticated: boolean;
+    isGuest: boolean;
+    loading: boolean;
+    error: string | null;
+    setError: (error: string | null) => void;
+    setIsGuest: (isGuest: boolean) => void;
+    setLoading: (loading: boolean) => void;
+}
+/**
+ * Hook for managing authentication state
+ */
+export declare function useAuthState(): UseAuthStateResult;

package/lib/presentation/hooks/useAuthState.js

@@ -0,0 +1,79 @@
+/**
+ * useAuthState Hook
+ * Single Responsibility: Manage authentication state
+ */
+import { useState, useEffect, useRef, useMemo } from "react";
+import { DeviceEventEmitter } from "react-native";
+import { getAuthService } from "../../infrastructure/services/AuthService";
+import { useFirebaseAuth } from "@umituz/react-native-firebase-auth";
+import { mapToAuthUser } from "../../infrastructure/utils/UserMapper";
+/**
+ * Hook for managing authentication state
+ */
+export function useAuthState() {
+    const { user: firebaseUser, loading: firebaseLoading } = useFirebaseAuth();
+    const [isGuest, setIsGuest] = useState(() => {
+        const service = getAuthService();
+        return service ? service.getIsGuestMode() : false;
+    });
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(false);
+    // Ref to track latest isGuest value for event handlers
+    const isGuestRef = useRef(isGuest);
+    // Memoize user to prevent new object reference on every render
+    const user = useMemo(() => {
+        if (isGuest)
+            return null;
+        return mapToAuthUser(firebaseUser);
+    }, [isGuest, firebaseUser?.uid]);
+    const isAuthenticated = !!user && !isGuest;
+    // Keep ref in sync with state
+    useEffect(() => {
+        isGuestRef.current = isGuest;
+    }, [isGuest]);
+    // Reset guest mode when user signs in
+    useEffect(() => {
+        if (firebaseUser && isGuest) {
+            setIsGuest(false);
+        }
+    }, [firebaseUser, isGuest]);
+    // Sync isGuest state with service on mount only
+    useEffect(() => {
+        const service = getAuthService();
+        if (service) {
+            const serviceIsGuest = service.getIsGuestMode();
+            if (serviceIsGuest !== isGuestRef.current) {
+                setIsGuest(serviceIsGuest);
+            }
+        }
+    }, []);
+    // Listen for auth events - subscribe once on mount
+    useEffect(() => {
+        const guestSubscription = DeviceEventEmitter.addListener("guest-mode-enabled", () => setIsGuest(true));
+        const authSubscription = DeviceEventEmitter.addListener("user-authenticated", () => {
+            if (isGuestRef.current) {
+                setIsGuest(false);
+            }
+        });
+        const errorSubscription = DeviceEventEmitter.addListener("auth-error", (payload) => {
+            if (payload?.error) {
+                setError(payload.error);
+            }
+        });
+        return () => {
+            guestSubscription.remove();
+            authSubscription.remove();
+            errorSubscription.remove();
+        };
+    }, []);
+    return {
+        user,
+        isAuthenticated,
+        isGuest,
+        loading: loading || firebaseLoading,
+        error,
+        setError,
+        setIsGuest,
+        setLoading,
+    };
+}

package/lib/presentation/hooks/useLoginForm.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useLoginForm Hook
+ * Single Responsibility: Handle login form logic
+ */
+export interface UseLoginFormResult {
+    email: string;
+    password: string;
+    emailError: string | null;
+    passwordError: string | null;
+    localError: string | null;
+    loading: boolean;
+    handleEmailChange: (text: string) => void;
+    handlePasswordChange: (text: string) => void;
+    handleSignIn: () => Promise<void>;
+    handleContinueAsGuest: () => Promise<void>;
+    displayError: string | null;
+}
+/**
+ * Hook for login form logic
+ */
+export declare function useLoginForm(): UseLoginFormResult;

package/lib/presentation/hooks/useLoginForm.js

@@ -0,0 +1,131 @@
+/**
+ * useLoginForm Hook
+ * Single Responsibility: Handle login form logic
+ */
+import { useState, useCallback } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+import { validateEmail } from "../../infrastructure/utils/AuthValidation";
+/**
+ * Hook for login form logic
+ */
+export function useLoginForm() {
+    const { t } = useLocalization();
+    const { signIn, loading, error, continueAsGuest } = useAuth();
+    const [email, setEmail] = useState("");
+    const [password, setPassword] = useState("");
+    const [emailError, setEmailError] = useState(null);
+    const [passwordError, setPasswordError] = useState(null);
+    const [localError, setLocalError] = useState(null);
+    const handleEmailChange = useCallback((text) => {
+        setEmail(text);
+        if (emailError)
+            setEmailError(null);
+        if (localError)
+            setLocalError(null);
+    }, [emailError, localError]);
+    const handlePasswordChange = useCallback((text) => {
+        setPassword(text);
+        if (passwordError)
+            setPasswordError(null);
+        if (localError)
+            setLocalError(null);
+    }, [passwordError, localError]);
+    const handleSignIn = useCallback(async () => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+            console.log("[useLoginForm] handleSignIn called");
+        }
+        setEmailError(null);
+        setPasswordError(null);
+        setLocalError(null);
+        let hasError = false;
+        const emailResult = validateEmail(email.trim());
+        if (!emailResult.isValid) {
+            setEmailError(t("auth.errors.invalidEmail"));
+            hasError = true;
+        }
+        if (!password.trim()) {
+            setPasswordError(t("auth.errors.weakPassword"));
+            hasError = true;
+        }
+        else if (password.length < 6) {
+            setPasswordError(t("auth.errors.weakPassword"));
+            hasError = true;
+        }
+        if (hasError) {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useLoginForm] Validation errors, returning early");
+            }
+            return;
+        }
+        try {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useLoginForm] Calling signIn with email:", email.trim());
+            }
+            await signIn(email.trim(), password);
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useLoginForm] signIn completed successfully");
+            }
+        }
+        catch (err) {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.error("[useLoginForm] signIn error:", err);
+            }
+            const localizationKey = getAuthErrorLocalizationKey(err);
+            const errorMessage = t(localizationKey);
+            setLocalError(errorMessage);
+        }
+    }, [email, password, t, signIn]);
+    const handleContinueAsGuest = useCallback(async () => {
+        /* eslint-disable-next-line no-console */
+        if (__DEV__) {
+            console.log("========================================");
+            console.log("[useLoginForm] 🎯 Continue as Guest button PRESSED");
+            console.log("[useLoginForm] Current loading state:", loading);
+            console.log("[useLoginForm] Current error state:", error);
+            console.log("========================================");
+        }
+        try {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useLoginForm] Calling continueAsGuest() function...");
+            }
+            await continueAsGuest();
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.log("[useLoginForm] ✅ continueAsGuest() completed successfully");
+                console.log("[useLoginForm] Current loading state after:", loading);
+            }
+        }
+        catch (err) {
+            /* eslint-disable-next-line no-console */
+            if (__DEV__) {
+                console.error("[useLoginForm] ❌ ERROR in continueAsGuest:", err);
+                console.error("[useLoginForm] Error details:", {
+                    message: err instanceof Error ? err.message : String(err),
+                    stack: err instanceof Error ? err.stack : undefined,
+                });
+            }
+        }
+    }, [continueAsGuest, loading, error]);
+    const displayError = localError || error;
+    return {
+        email,
+        password,
+        emailError,
+        passwordError,
+        localError,
+        loading,
+        handleEmailChange,
+        handlePasswordChange,
+        handleSignIn,
+        handleContinueAsGuest,
+        displayError,
+    };
+}

package/lib/presentation/hooks/useRegisterForm.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useRegisterForm Hook
+ * Single Responsibility: Handle register form logic
+ */
+import type { PasswordRequirements } from "../../infrastructure/utils/AuthValidation";
+export interface UseRegisterFormResult {
+    displayName: string;
+    email: string;
+    password: string;
+    confirmPassword: string;
+    fieldErrors: {
+        displayName?: string;
+        email?: string;
+        password?: string;
+        confirmPassword?: string;
+    };
+    localError: string | null;
+    loading: boolean;
+    passwordRequirements: PasswordRequirements;
+    passwordsMatch: boolean;
+    handleDisplayNameChange: (text: string) => void;
+    handleEmailChange: (text: string) => void;
+    handlePasswordChange: (text: string) => void;
+    handleConfirmPasswordChange: (text: string) => void;
+    handleSignUp: () => Promise<void>;
+    displayError: string | null;
+}
+/**
+ * Hook for register form logic
+ */
+export declare function useRegisterForm(): UseRegisterFormResult;

package/lib/presentation/hooks/useRegisterForm.js

@@ -0,0 +1,136 @@
+/**
+ * useRegisterForm Hook
+ * Single Responsibility: Handle register form logic
+ */
+import { useState, useCallback, useMemo } from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import { validateEmail, validatePasswordForRegister, validatePasswordConfirmation, } from "../../infrastructure/utils/AuthValidation";
+import { DEFAULT_PASSWORD_CONFIG } from "../../domain/value-objects/AuthConfig";
+import { useAuth } from "./useAuth";
+import { getAuthErrorLocalizationKey } from "../utils/getAuthErrorMessage";
+/**
+ * Hook for register form logic
+ */
+export function useRegisterForm() {
+    const { t } = useLocalization();
+    const { signUp, loading, error } = useAuth();
+    const [displayName, setDisplayName] = useState("");
+    const [email, setEmail] = useState("");
+    const [password, setPassword] = useState("");
+    const [confirmPassword, setConfirmPassword] = useState("");
+    const [localError, setLocalError] = useState(null);
+    const [fieldErrors, setFieldErrors] = useState({});
+    const passwordRequirements = useMemo(() => {
+        if (!password) {
+            return {
+                hasMinLength: false,
+                hasUppercase: false,
+                hasLowercase: false,
+                hasNumber: false,
+                hasSpecialChar: false,
+            };
+        }
+        const result = validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG);
+        return result.requirements;
+    }, [password]);
+    const passwordsMatch = useMemo(() => {
+        return password.length > 0 && password === confirmPassword;
+    }, [password, confirmPassword]);
+    const handleDisplayNameChange = useCallback((text) => {
+        setDisplayName(text);
+        setFieldErrors((prev) => {
+            const next = { ...prev };
+            if (next.displayName) {
+                delete next.displayName;
+            }
+            return next;
+        });
+        if (localError)
+            setLocalError(null);
+    }, [localError]);
+    const handleEmailChange = useCallback((text) => {
+        setEmail(text);
+        setFieldErrors((prev) => {
+            const next = { ...prev };
+            if (next.email) {
+                delete next.email;
+            }
+            return next;
+        });
+        if (localError)
+            setLocalError(null);
+    }, [localError]);
+    const handlePasswordChange = useCallback((text) => {
+        setPassword(text);
+        setFieldErrors((prev) => {
+            const next = { ...prev };
+            if (next.password) {
+                delete next.password;
+            }
+            if (next.confirmPassword) {
+                delete next.confirmPassword;
+            }
+            return next;
+        });
+        if (localError)
+            setLocalError(null);
+    }, [localError]);
+    const handleConfirmPasswordChange = useCallback((text) => {
+        setConfirmPassword(text);
+        setFieldErrors((prev) => {
+            const next = { ...prev };
+            if (next.confirmPassword) {
+                delete next.confirmPassword;
+            }
+            return next;
+        });
+        if (localError)
+            setLocalError(null);
+    }, [localError]);
+    const handleSignUp = useCallback(async () => {
+        setLocalError(null);
+        setFieldErrors({});
+        // Manual validation since batchValidate is not available
+        const emailResult = validateEmail(email.trim());
+        if (!emailResult.isValid) {
+            setFieldErrors((prev) => ({ ...prev, email: emailResult.error }));
+            return;
+        }
+        const passwordResult = validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG);
+        if (!passwordResult.isValid) {
+            setFieldErrors((prev) => ({ ...prev, password: passwordResult.error }));
+            return;
+        }
+        const confirmResult = validatePasswordConfirmation(password, confirmPassword);
+        if (!confirmResult.isValid) {
+            setFieldErrors((prev) => ({ ...prev, confirmPassword: confirmResult.error }));
+            return;
+        }
+        try {
+            await signUp(email.trim(), password, displayName.trim() || undefined);
+        }
+        catch (err) {
+            const localizationKey = getAuthErrorLocalizationKey(err);
+            const errorMessage = t(localizationKey);
+            setLocalError(errorMessage);
+        }
+    }, [displayName, email, password, confirmPassword, signUp, t]);
+    const displayError = localError || error;
+    return {
+        displayName,
+        email,
+        password,
+        confirmPassword,
+        fieldErrors,
+        localError,
+        loading,
+        passwordRequirements,
+        passwordsMatch,
+        handleDisplayNameChange,
+        handleEmailChange,
+        handlePasswordChange,
+        handleConfirmPasswordChange,
+        handleSignUp,
+        displayError,
+    };
+}

package/lib/presentation/navigation/AuthNavigator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Auth Navigator
+ * Stack navigator for authentication screens (Login, Register)
+ */
+import React from "react";
+export type AuthStackParamList = {
+    Login: undefined;
+    Register: undefined;
+};
+export interface AuthNavigatorProps {
+    /**
+     * Terms of Service URL
+     */
+    termsUrl?: string;
+    /**
+     * Privacy Policy URL
+     */
+    privacyUrl?: string;
+    /**
+     * Callback when Terms of Service is pressed
+     */
+    onTermsPress?: () => void;
+    /**
+     * Callback when Privacy Policy is pressed
+     */
+    onPrivacyPress?: () => void;
+}
+export declare const AuthNavigator: React.FC<AuthNavigatorProps>;

package/lib/presentation/navigation/AuthNavigator.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Auth Navigator
+ * Stack navigator for authentication screens (Login, Register)
+ */
+import { useEffect, useState } from "react";
+import { createStackNavigator } from "@react-navigation/stack";
+import { useAppDesignTokens } from "@umituz/react-native-design-system-theme";
+import { storageRepository } from "@umituz/react-native-storage";
+import { unwrap } from "@umituz/react-native-storage";
+import { LoginScreen } from "../screens/LoginScreen";
+import { RegisterScreen } from "../screens/RegisterScreen";
+const AuthStack = createStackNavigator();
+const SHOW_REGISTER_KEY = "auth_show_register";
+export const AuthNavigator = ({ termsUrl, privacyUrl, onTermsPress, onPrivacyPress, }) => {
+    const tokens = useAppDesignTokens();
+    const [initialRouteName, setInitialRouteName] = useState(undefined);
+    useEffect(() => {
+        storageRepository.getString(SHOW_REGISTER_KEY, "false").then((result) => {
+            const value = unwrap(result, "false");
+            if (value === "true") {
+                setInitialRouteName("Register");
+                storageRepository.removeItem(SHOW_REGISTER_KEY);
+            }
+            else {
+                setInitialRouteName("Login");
+            }
+        });
+    }, []);
+    if (initialRouteName === undefined) {
+        return null;
+    }
+    return (_jsxs(AuthStack.Navigator, { initialRouteName: initialRouteName, screenOptions: {
+            headerShown: false,
+            cardStyle: { backgroundColor: tokens.colors.backgroundPrimary },
+        }, children: [_jsx(AuthStack.Screen, { name: "Login", component: LoginScreen }), _jsx(AuthStack.Screen, { name: "Register", children: (props) => (_jsx(RegisterScreen, { ...props, termsUrl: termsUrl, privacyUrl: privacyUrl, onTermsPress: onTermsPress, onPrivacyPress: onPrivacyPress })) })] }));
+};

package/lib/presentation/screens/LoginScreen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Login Screen
+ * Beautiful, production-ready login screen with email/password and guest mode
+ */
+import React from "react";
+export declare const LoginScreen: React.FC;

package/lib/presentation/screens/LoginScreen.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useNavigation } from "@react-navigation/native";
+import { useLocalization } from "@umituz/react-native-localization";
+import { AuthContainer } from "../components/AuthContainer";
+import { AuthHeader } from "../components/AuthHeader";
+import { AuthFormCard } from "../components/AuthFormCard";
+import { LoginForm } from "../components/LoginForm";
+export const LoginScreen = () => {
+    const { t } = useLocalization();
+    const navigation = useNavigation();
+    const handleNavigateToRegister = () => {
+        navigation.navigate("Register");
+    };
+    return (_jsxs(AuthContainer, { children: [_jsx(AuthHeader, { title: t("auth.title") }), _jsx(AuthFormCard, { children: _jsx(LoginForm, { onNavigateToRegister: handleNavigateToRegister }) })] }));
+};

package/lib/presentation/screens/RegisterScreen.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Register Screen
+ * Beautiful, production-ready registration screen with validation
+ */
+import React from "react";
+export interface RegisterScreenProps {
+    termsUrl?: string;
+    privacyUrl?: string;
+    onTermsPress?: () => void;
+    onPrivacyPress?: () => void;
+}
+export declare const RegisterScreen: React.FC<RegisterScreenProps>;