@umituz/react-native-auth 1.12.0 → 2.0.1

package/src/infrastructure/services/GuestModeService.ts

@@ -0,0 +1,86 @@
+/**
+ * Guest Mode Service
+ * Handles guest mode functionality
+ */
+
+import type { IAuthProvider } from "../../application/ports/IAuthProvider";
+import type { AuthUser } from "../../domain/entities/AuthUser";
+import { emitGuestModeEnabled } from "../utils/AuthEventEmitter";
+
+export interface IStorageProvider {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+}
+
+export class GuestModeService {
+  private isGuestMode: boolean = false;
+  private storageKey: string;
+
+  constructor(storageKey: string = "@auth_guest_mode") {
+    this.storageKey = storageKey;
+  }
+
+  async load(storageProvider: IStorageProvider): Promise<boolean> {
+    try {
+      const value = await storageProvider.get(this.storageKey);
+      this.isGuestMode = value === "true";
+      return this.isGuestMode;
+    } catch {
+      return false;
+    }
+  }
+
+  async save(storageProvider: IStorageProvider): Promise<void> {
+    try {
+      await storageProvider.set(this.storageKey, this.isGuestMode.toString());
+    } catch {
+      // Silently fail storage operations
+    }
+  }
+
+  async clear(storageProvider: IStorageProvider): Promise<void> {
+    try {
+      await storageProvider.remove(this.storageKey);
+    } catch {
+      // Silently fail storage operations
+    }
+    this.isGuestMode = false;
+  }
+
+  async enable(storageProvider: IStorageProvider, provider?: IAuthProvider): Promise<void> {
+    // Sign out from provider if logged in
+    if (provider?.getCurrentUser()) {
+      try {
+        await provider.signOut();
+      } catch {
+        // Ignore sign out errors when switching to guest mode
+      }
+    }
+
+    this.isGuestMode = true;
+    await this.save(storageProvider);
+    emitGuestModeEnabled();
+  }
+
+  getIsGuestMode(): boolean {
+    return this.isGuestMode;
+  }
+
+  setGuestMode(enabled: boolean): void {
+    this.isGuestMode = enabled;
+  }
+
+  wrapAuthStateCallback(
+    callback: (user: AuthUser | null) => void
+  ): (user: AuthUser | null) => void {
+    return (user: AuthUser | null) => {
+      // Don't update if in guest mode
+      if (!this.isGuestMode) {
+        callback(user);
+      } else {
+        callback(null);
+      }
+    };
+  }
+}

package/src/infrastructure/storage/GuestModeStorage.ts

@@ -3,18 +3,27 @@
  * Single Responsibility: Manage guest mode persistence
  */
 
-import { storageRepository, unwrap } from "@umituz/react-native-storage";
-
-const GUEST_MODE_KEY = "@auth_guest_mode";
+import type { IStorageProvider } from "../services/GuestModeService";
+import { getAuthPackage } from "../services/AuthPackage";
 
 /**
  * Load guest mode from storage
  */
-export async function loadGuestMode(): Promise<boolean> {
+export async function loadGuestMode(storageKey?: string): Promise<boolean> {
   try {
-    const result = await storageRepository.getString(GUEST_MODE_KEY, "false");
-    const guestModeValue = unwrap(result, "false");
-    return guestModeValue === "true";
+    const packageConfig = getAuthPackage()?.getConfig();
+    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    
+    const storageProvider = getAuthPackage()?.getStorageProvider();
+    if (!storageProvider) {
+      if (__DEV__) {
+        console.warn("[GuestModeStorage] No storage provider available");
+      }
+      return false;
+    }
+
+    const value = await storageProvider.get(key);
+    return value === "true";
   } catch {
     return false;
   }
@@ -23,19 +32,28 @@ export async function loadGuestMode(): Promise<boolean> {
 /**
  * Save guest mode to storage
  */
-export async function saveGuestMode(isGuest: boolean): Promise<void> {
+export async function saveGuestMode(isGuest: boolean, storageKey?: string): Promise<void> {
   try {
+    const packageConfig = getAuthPackage()?.getConfig();
+    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    
+    const storageProvider = getAuthPackage()?.getStorageProvider();
+    if (!storageProvider) {
+      if (__DEV__) {
+        console.warn("[GuestModeStorage] No storage provider available");
+      }
+      return;
+    }
+
     if (isGuest) {
-      await storageRepository.setString(GUEST_MODE_KEY, "true");
-      /* eslint-disable-next-line no-console */
+      await storageProvider.set(key, "true");
       if (__DEV__) {
         console.log("[GuestModeStorage] Guest mode persisted to storage");
       }
     } else {
-      await storageRepository.removeItem(GUEST_MODE_KEY);
+      await storageProvider.remove(key);
     }
   } catch (error) {
-    /* eslint-disable-next-line no-console */
     if (__DEV__) {
       console.warn("[GuestModeStorage] Failed to persist guest mode:", error);
     }
@@ -45,9 +63,17 @@ export async function saveGuestMode(isGuest: boolean): Promise<void> {
 /**
  * Clear guest mode from storage
  */
-export async function clearGuestMode(): Promise<void> {
+export async function clearGuestMode(storageKey?: string): Promise<void> {
   try {
-    await storageRepository.removeItem(GUEST_MODE_KEY);
+    const packageConfig = getAuthPackage()?.getConfig();
+    const key = storageKey ?? packageConfig?.storageKeys.guestMode ?? "@auth_guest_mode";
+    
+    const storageProvider = getAuthPackage()?.getStorageProvider();
+    if (!storageProvider) {
+      return;
+    }
+
+    await storageProvider.remove(key);
   } catch {
     // Ignore storage errors
   }

package/src/infrastructure/utils/AuthErrorMapper.ts

@@ -18,9 +18,13 @@ import {
  * Map Firebase Auth errors to domain errors
  */
 export function mapFirebaseAuthError(error: unknown): Error {
-  const errorObj = error as { code?: string; message?: string } | undefined;
-  const code = errorObj?.code || "";
-  const message = errorObj?.message || "Authentication failed";
+  if (!error || typeof error !== 'object') {
+    return new AuthError("Authentication failed", "AUTH_UNKNOWN_ERROR");
+  }
+
+  const errorObj = error as { code?: string; message?: string };
+  const code = errorObj.code || "";
+  const message = errorObj.message || "Authentication failed";
 
   switch (code) {
     case "auth/email-already-in-use":

package/src/infrastructure/utils/AuthValidation.ts

@@ -4,6 +4,7 @@
  */
 
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
+import { getAuthPackage } from "../services/AuthPackage";
 
 export interface ValidationResult {
   isValid: boolean;
@@ -22,11 +23,35 @@ export interface PasswordRequirements {
   hasSpecialChar: boolean;
 }
 
-const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-const UPPERCASE_REGEX = /[A-Z]/;
-const LOWERCASE_REGEX = /[a-z]/;
-const NUMBER_REGEX = /[0-9]/;
-const SPECIAL_CHAR_REGEX = /[!@#$%^&*(),.?":{}|<>]/;
+export interface ValidationConfig {
+  emailRegex: RegExp;
+  uppercaseRegex: RegExp;
+  lowercaseRegex: RegExp;
+  numberRegex: RegExp;
+  specialCharRegex: RegExp;
+  displayNameMinLength: number;
+}
+
+const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
+  emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  uppercaseRegex: /[A-Z]/,
+  lowercaseRegex: /[a-z]/,
+  numberRegex: /[0-9]/,
+  specialCharRegex: /[!@#$%^&*(),.?":{}|<>]/,
+  displayNameMinLength: 2,
+};
+
+function getValidationConfig(): ValidationConfig {
+  const packageConfig = getAuthPackage()?.getConfig();
+  return {
+    emailRegex: packageConfig?.validation.emailRegex || DEFAULT_VALIDATION_CONFIG.emailRegex,
+    uppercaseRegex: DEFAULT_VALIDATION_CONFIG.uppercaseRegex,
+    lowercaseRegex: DEFAULT_VALIDATION_CONFIG.lowercaseRegex,
+    numberRegex: DEFAULT_VALIDATION_CONFIG.numberRegex,
+    specialCharRegex: DEFAULT_VALIDATION_CONFIG.specialCharRegex,
+    displayNameMinLength: DEFAULT_VALIDATION_CONFIG.displayNameMinLength,
+  };
+}
 
 /**
  * Validate email format
@@ -36,7 +61,8 @@ export function validateEmail(email: string): ValidationResult {
     return { isValid: false, error: "Email is required" };
   }
 
-  if (!EMAIL_REGEX.test(email.trim())) {
+  const config = getValidationConfig();
+  if (!config.emailRegex.test(email.trim())) {
     return { isValid: false, error: "Please enter a valid email address" };
   }
 
@@ -63,13 +89,14 @@ export function validatePasswordForRegister(
   password: string,
   config: PasswordConfig
 ): PasswordStrengthResult {
+  const validationConfig = getValidationConfig();
   const requirements: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,
-    hasUppercase: !config.requireUppercase || UPPERCASE_REGEX.test(password),
-    hasLowercase: !config.requireLowercase || LOWERCASE_REGEX.test(password),
-    hasNumber: !config.requireNumber || NUMBER_REGEX.test(password),
+    hasUppercase: !config.requireUppercase || validationConfig.uppercaseRegex.test(password),
+    hasLowercase: !config.requireLowercase || validationConfig.lowercaseRegex.test(password),
+    hasNumber: !config.requireNumber || validationConfig.numberRegex.test(password),
     hasSpecialChar:
-      !config.requireSpecialChar || SPECIAL_CHAR_REGEX.test(password),
+      !config.requireSpecialChar || validationConfig.specialCharRegex.test(password),
   };
 
   if (!password || password.length === 0) {
@@ -88,7 +115,7 @@ export function validatePasswordForRegister(
     };
   }
 
-  if (config.requireUppercase && !UPPERCASE_REGEX.test(password)) {
+  if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
     return {
       isValid: false,
       error: "Password must contain at least one uppercase letter",
@@ -96,7 +123,7 @@ export function validatePasswordForRegister(
     };
   }
 
-  if (config.requireLowercase && !LOWERCASE_REGEX.test(password)) {
+  if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
     return {
       isValid: false,
       error: "Password must contain at least one lowercase letter",
@@ -104,7 +131,7 @@ export function validatePasswordForRegister(
     };
   }
 
-  if (config.requireNumber && !NUMBER_REGEX.test(password)) {
+  if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
     return {
       isValid: false,
       error: "Password must contain at least one number",
@@ -112,7 +139,7 @@ export function validatePasswordForRegister(
     };
   }
 
-  if (config.requireSpecialChar && !SPECIAL_CHAR_REGEX.test(password)) {
+  if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
     return {
       isValid: false,
       error: "Password must contain at least one special character",
@@ -146,16 +173,19 @@ export function validatePasswordConfirmation(
  */
 export function validateDisplayName(
   displayName: string,
-  minLength: number = 2
+  minLength?: number
 ): ValidationResult {
   if (!displayName || displayName.trim() === "") {
     return { isValid: false, error: "Name is required" };
   }
 
-  if (displayName.trim().length < minLength) {
+  const config = getValidationConfig();
+  const actualMinLength = minLength ?? config.displayNameMinLength;
+
+  if (displayName.trim().length < actualMinLength) {
     return {
       isValid: false,
-      error: `Name must be at least ${minLength} characters`,
+      error: `Name must be at least ${actualMinLength} characters`,
     };
   }
 

package/src/presentation/components/PasswordMatchIndicator.tsx

@@ -20,8 +20,8 @@ export const PasswordMatchIndicator: React.FC<PasswordMatchIndicatorProps> = ({
 
   const color = isMatch ? tokens.colors.success : tokens.colors.error;
   const text = isMatch
-    ? t("auth.passwordsMatch", "Passwords match")
-    : t("auth.passwordsDontMatch", "Passwords don't match");
+    ? t("auth.passwordsMatch", { defaultValue: "Passwords match" })
+    : t("auth.passwordsDontMatch", { defaultValue: "Passwords don't match" });
 
   return (
     <View style={styles.container}>

package/src/presentation/hooks/useAuthActions.ts

@@ -40,8 +40,8 @@ export function useAuthActions(
       if (isGuest) {
         setIsGuest(false);
       }
-    } catch (err: any) {
-      const errorMessage = err.message || "Sign up failed";
+    } catch (err: unknown) {
+      const errorMessage = err instanceof Error ? err.message : "Sign up failed";
       setError(errorMessage);
       throw err;
     } finally {
@@ -79,12 +79,8 @@ export function useAuthActions(
         }
         setIsGuest(false);
       }
-    } catch (err: any) {
-      /* eslint-disable-next-line no-console */
-      if (__DEV__) {
-        console.error("[useAuthActions] Error in signIn:", err);
-      }
-      const errorMessage = err.message || "Failed to sign in";
+} catch (err: unknown) {
+      const errorMessage = err instanceof Error ? err.message : "Sign in failed";
       setError(errorMessage);
       throw err;
     } finally {
@@ -152,12 +148,13 @@ export function useAuthActions(
       if (__DEV__) {
         console.log("[useAuthActions] ✅ isGuest set to true");
       }
-    } catch (error) {
-      /* eslint-disable-next-line no-console */
+    } catch (error: unknown) {
+      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: error instanceof Error ? error.message : String(error),
+          message: errorMessage,
           stack: error instanceof Error ? error.stack : undefined,
         });
       }

package/src/presentation/hooks/useAuthState.ts

@@ -83,9 +83,19 @@ export function useAuthState(): UseAuthStateResult {
       }
     );
 
+    const errorSubscription = DeviceEventEmitter.addListener(
+      "auth-error",
+      (payload: any) => {
+        if (payload?.error) {
+          setError(payload.error);
+        }
+      }
+    );
+
     return () => {
       guestSubscription.remove();
       authSubscription.remove();
+      errorSubscription.remove();
     };
   }, []);
 

package/src/presentation/hooks/useRegisterForm.ts

@@ -131,23 +131,22 @@ export function useRegisterForm(): UseRegisterFormResult {
     setLocalError(null);
     setFieldErrors({});
 
-    const validationResult = batchValidate([
-      {
-        field: "email",
-        validator: () => validateEmail(email.trim()),
-      },
-      {
-        field: "password",
-        validator: () => validatePasswordForRegister(password, DEFAULT_PASSWORD_CONFIG),
-      },
-      {
-        field: "confirmPassword",
-        validator: () => validatePasswordConfirmation(password, confirmPassword),
-      },
-    ]);
-
-    if (!validationResult.isValid) {
-      setFieldErrors(validationResult.errors);
+    // 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;
     }
 

package/src/presentation/navigation/AuthNavigator.tsx

@@ -16,7 +16,7 @@ export type AuthStackParamList = {
   Register: undefined;
 };
 
-const AuthStack = createStackNavigator<AuthStackParamList>();
+const AuthStack = createStackNavigator();
 
 const SHOW_REGISTER_KEY = "auth_show_register";
 
@@ -76,7 +76,7 @@ export const AuthNavigator: React.FC<AuthNavigatorProps> = ({
     >
       <AuthStack.Screen name="Login" component={LoginScreen} />
       <AuthStack.Screen name="Register">
-        {(props) => (
+        {(props: any) => (
           <RegisterScreen
             {...props}
             termsUrl={termsUrl}

package/src/presentation/screens/LoginScreen.tsx

@@ -13,17 +13,14 @@ import { AuthHeader } from "../components/AuthHeader";
 import { AuthFormCard } from "../components/AuthFormCard";
 import { LoginForm } from "../components/LoginForm";
 
-type LoginScreenNavigationProp = StackNavigationProp<
-  AuthStackParamList,
-  "Login"
->;
+type LoginScreenNavigationProp = any;
 
 export const LoginScreen: React.FC = () => {
   const { t } = useLocalization();
-  const navigation = useNavigation<LoginScreenNavigationProp>();
+  const navigation = useNavigation();
 
   const handleNavigateToRegister = () => {
-    navigation.navigate("Register");
+    navigation.navigate("Register" as any);
   };
 
   return (

package/src/presentation/screens/RegisterScreen.tsx

@@ -13,10 +13,7 @@ import { AuthHeader } from "../components/AuthHeader";
 import { AuthFormCard } from "../components/AuthFormCard";
 import { RegisterForm } from "../components/RegisterForm";
 
-type RegisterScreenNavigationProp = StackNavigationProp<
-  AuthStackParamList,
-  "Register"
->;
+type RegisterScreenNavigationProp = any;
 
 export interface RegisterScreenProps {
   termsUrl?: string;
@@ -32,10 +29,10 @@ export const RegisterScreen: React.FC<RegisterScreenProps> = ({
   onPrivacyPress,
 }) => {
   const { t } = useLocalization();
-  const navigation = useNavigation<RegisterScreenNavigationProp>();
+  const navigation = useNavigation();
 
   const handleNavigateToLogin = () => {
-    navigation.navigate("Login");
+    navigation.navigate("Login" as any);
   };
 
   return (

package/src/types/external.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Type declarations for external dependencies
+ * These are optional dependencies that should be provided by the consuming application
+ */
+
+declare module '@umituz/react-native-design-system-theme' {
+  export function useAppDesignTokens(): any;
+  export const defaultTheme: any;
+}
+
+declare module '@umituz/react-native-design-system-atoms' {
+  export const AtomicInput: any;
+  export const AtomicButton: any;
+  export const AtomicText: any;
+  export const AtomicView: any;
+}
+
+declare module '@umituz/react-native-localization' {
+  export function useTranslation(): {
+    t: (key: string, params?: Record<string, any>) => string;
+  };
+  export function useLocalization(): {
+    t: (key: string, params?: Record<string, any>) => string;
+  };
+}
+
+declare module '@umituz/react-native-firebase-auth' {
+  export function useFirebaseAuth(): any;
+}
+
+declare module '@umituz/react-native-validation' {
+  export function useValidation(): any;
+  export function batchValidate(): any;
+}
+
+declare module '@umituz/react-native-storage' {
+  export const storageRepository: {
+    getString: (key: string, defaultValue?: string) => Promise<{ value: string } | null>;
+    setString: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+  };
+  export function unwrap(result: any, defaultValue: any): any;
+}
+
+declare module 'react-native-safe-area-context' {
+  export function useSafeAreaInsets(): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+  };
+}
+
+declare module 'expo-linear-gradient' {
+  import { ComponentType } from 'react';
+  export const LinearGradient: ComponentType<any>;
+}
+
+declare module '@react-navigation/stack' {
+  import { ComponentType } from 'react';
+  export const createStackNavigator: any;
+  export type StackNavigationProp<any> = any;
+}
+
+declare module '@react-navigation/native' {
+  export function useNavigation(): any;
+  export function useFocusEffect(effect: () => void | (() => void)): void;
+}

package/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Ümit UZ
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-