@umituz/react-native-auth 4.3.14 → 4.3.15

package/src/presentation/stores/authStore.ts

@@ -11,15 +11,8 @@
 
 import { createStore, storageService } from "@umituz/react-native-design-system";
 import { mapToAuthUser } from "../../infrastructure/utils/UserMapper";
-import type { AuthState, AuthActions, UserType } from "../../types/auth-store.types";
+import type { AuthState, AuthActions } from "../../types/auth-store.types";
 import { initialAuthState } from "../../types/auth-store.types";
-import {
-  selectUserId,
-  selectIsAuthenticated,
-  selectIsAnonymous,
-  selectUserType,
-  selectIsRegisteredUser,
-} from "./auth.selectors";
 
 // =============================================================================
 // STORE
@@ -96,42 +89,3 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
   }),
 });
 
-// =============================================================================
-// NON-HOOK GETTERS
-// =============================================================================
-
-/**
- * Get user ID without hook
- */
-export function getUserId(): string | null {
-  return selectUserId(useAuthStore.getState());
-}
-
-/**
- * Get user type without hook
- */
-export function getUserType(): UserType {
-  return selectUserType(useAuthStore.getState());
-}
-
-/**
- * Check if authenticated without hook
- */
-export function getIsAuthenticated(): boolean {
-  return selectIsAuthenticated(useAuthStore.getState());
-}
-
-/**
- * Check if anonymous without hook
- */
-export function getIsAnonymous(): boolean {
-  return selectIsAnonymous(useAuthStore.getState());
-}
-
-/**
- * Check if registered user without hook
- * Returns true only if user is authenticated AND not anonymous
- */
-export function getIsRegisteredUser(): boolean {
-  return selectIsRegisteredUser(useAuthStore.getState());
-}

package/src/presentation/utils/authTransition.util.ts

@@ -5,13 +5,13 @@
 
 import { useRef, useEffect } from "react";
 
-export interface AuthTransitionState {
+interface AuthTransitionState {
   isAuthenticated: boolean;
   isAnonymous: boolean;
   isVisible: boolean;
 }
 
-export interface AuthTransitionResult {
+interface AuthTransitionResult {
   justAuthenticated: boolean;
   justConvertedFromAnonymous: boolean;
   shouldClose: boolean;
@@ -60,18 +60,6 @@ export function useAuthTransitions(
   }, [state.isAuthenticated, state.isVisible, state.isAnonymous, onTransition]);
 }
 
-/**
- * Check if should close modal after auth transition
- */
-export function shouldCloseAfterAuth(
-  justAuthenticated: boolean,
-  justConvertedFromAnonymous: boolean,
-  isVisible: boolean,
-  isAnonymous: boolean
-): boolean {
-  return (justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous;
-}
-
 /**
  * Execute callback with delay after auth
  */

package/src/presentation/utils/commonStyles.ts

@@ -5,9 +5,6 @@
 
 import { StyleSheet } from "react-native";
 
-/**
- * Action button style - used in account actions and profile sections
- */
 export const actionButtonStyle = StyleSheet.create({
     container: {
         flexDirection: "row" as const,
@@ -24,45 +21,3 @@ export const actionButtonStyle = StyleSheet.create({
         fontWeight: "500",
     },
 });
-
-/**
- * Input field styles - used in forms
- */
-export const inputFieldStyle = StyleSheet.create({
-    container: {
-        marginBottom: 20,
-    },
-});
-
-/**
- * Card content styles
- */
-export const cardContentStyle = StyleSheet.create({
-    container: {
-        padding: 16,
-    },
-    divider: {
-        height: 24,
-    },
-});
-
-/**
- * Avatar container styles
- */
-export const avatarContainerStyle = StyleSheet.create({
-    container: {
-        marginRight: 12,
-    },
-});
-
-/**
- * Info text styles
- */
-export const infoTextStyle = StyleSheet.create({
-    container: {
-        flex: 1,
-    },
-    displayName: {
-        marginBottom: 2,
-    },
-});

package/src/presentation/utils/form/formErrorUtils.ts

@@ -3,63 +3,8 @@
  * Shared utilities for form error state management
  */
 
-import { useCallback } from "react";
-
 export type FieldErrors<T extends string> = Partial<Record<T, string>>;
 
-/**
- * Create a field error updater that clears the specified field error
- * @param fieldErrors - Current field errors state
- * @param setFieldErrors - Function to update field errors
- * @param field - Field to clear
- * @returns Function to clear the specified field error
- */
-export function createFieldErrorUpdater<T extends string>(
-    fieldErrors: FieldErrors<T>,
-    setFieldErrors: (errors: FieldErrors<T> | ((prev: FieldErrors<T>) => FieldErrors<T>)) => void,
-    localError: string | null,
-    setLocalError: (error: string | null) => void
-) {
-    return useCallback((field: T) => {
-        if (fieldErrors[field]) {
-            setFieldErrors((prev) => {
-                const next = { ...prev };
-                delete next[field];
-                return next;
-            });
-        }
-        if (localError) {
-            setLocalError(null);
-        }
-    }, [fieldErrors, setFieldErrors, localError, setLocalError]);
-}
-
-/**
- * Create a single field error updater
- * @param setFieldErrors - Function to update field errors
- * @param setLocalError - Function to update local error
- * @param fields - Fields to clear when this updater is called
- * @returns Function to clear specified field errors
- */
-export function useFieldErrorClearer<T extends string>(
-    setFieldErrors: (errors: FieldErrors<T> | ((prev: FieldErrors<T>) => FieldErrors<T>)) => void,
-    setLocalError: (error: string | null) => void,
-    fields: T[]
-) {
-    return useCallback(() => {
-        setFieldErrors((prev) => {
-            const next = { ...prev };
-            fields.forEach((field) => {
-                if (next[field]) {
-                    delete next[field];
-                }
-            });
-            return next;
-        });
-        setLocalError(null);
-    }, [setFieldErrors, setLocalError, fields]);
-}
-
 /**
  * Clear a specific field error
  * @param setFieldErrors - Function to update field errors

package/src/presentation/utils/form/formValidation.util.ts

@@ -3,15 +3,6 @@
  * Exports all form validation utilities
  */
 
-// Types
-export type {
-  FormValidationError,
-  FormValidationResult,
-  LoginFormValues,
-  RegisterFormValues,
-  ProfileFormValues,
-} from "./validation/formValidation.types";
-
 // Validators
 export {
   validateLoginForm,
@@ -21,6 +12,3 @@ export {
 
 // Utilities
 export { errorsToFieldErrors } from "./validation/formValidation.utils";
-
-// Hook
-export { useFormValidation } from "./validation/formValidation.hook";

package/src/presentation/utils/form/useFormField.hook.ts

@@ -5,61 +5,11 @@
 
 import { useCallback, useState } from "react";
 
-export interface UseFormFieldOptions {
+interface UseFormFieldOptions {
   clearLocalError?: () => void;
   fieldsToClear?: string[];
 }
 
-export interface UseFormFieldResult {
-  value: string;
-  error: string | null;
-  setValue: (value: string) => void;
-  setError: (error: string | null) => void;
-  clearError: () => void;
-  handleChange: (text: string) => void;
-}
-
-/**
- * Hook for managing a single form field with automatic error clearing
- * @param initialValue - Initial field value
- * @param setError - Function to set field error in parent state
- * @param options - Additional options
- * @returns Field state and handlers
- */
-export function useFormField(
-  initialValue: string,
-  setError: (error: string | null) => void,
-  options?: UseFormFieldOptions
-): UseFormFieldResult {
-  const [value, setValue] = useState(initialValue);
-  const [error, setLocalError] = useState<string | null>(null);
-
-  const clearError = useCallback(() => {
-    setLocalError(null);
-    setError(null);
-    options?.clearLocalError?.();
-  }, [setError, options]);
-
-  const handleChange = useCallback(
-    (text: string) => {
-      setValue(text);
-      if (error) {
-        clearError();
-      }
-    },
-    [error, clearError]
-  );
-
-  return {
-    value,
-    error,
-    setValue,
-    setError: setLocalError,
-    clearError,
-    handleChange,
-  };
-}
-
 /**
  * Hook for managing multiple form fields
  * @param initialFields - Initial field values

package/src/presentation/utils/form/usePasswordValidation.hook.ts

@@ -8,18 +8,17 @@ import {
   validatePasswordForRegister,
   validatePasswordConfirmation,
   type PasswordRequirements,
-  type ValidationResult,
 } from "../../../application/services/ValidationService";
 import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
 
-export interface UsePasswordValidationResult {
+interface UsePasswordValidationResult {
   passwordRequirements: PasswordRequirements;
   passwordsMatch: boolean;
   isValid: boolean;
   confirmationError: string | null;
 }
 
-export interface UsePasswordValidationOptions {
+interface UsePasswordValidationOptions {
   passwordConfig?: PasswordConfig;
 }
 
@@ -72,16 +71,3 @@ export function usePasswordValidation(
   };
 }
 
-/**
- * Hook for login password validation (simpler, no requirements)
- * @param password - Password value
- * @returns Validation result
- */
-export function useLoginPasswordValidation(password: string): ValidationResult {
-  return useMemo(() => {
-    if (!password || password.length === 0) {
-      return { isValid: false, error: "auth.validation.passwordRequired" };
-    }
-    return { isValid: true };
-  }, [password]);
-}

package/src/presentation/utils/passwordPromptCallback.ts

@@ -4,8 +4,6 @@ export const setPasswordPromptCallback = (cb: ((value: string | null) => void) |
   callback = cb;
 };
 
-export const getPasswordPromptCallback = (): ((value: string | null) => void) | null => callback;
-
 export const resolvePasswordPrompt = (value: string | null): void => {
   if (callback) {
     callback(value);

package/src/presentation/utils/socialAuthHandler.util.ts

@@ -3,56 +3,14 @@
  * Manages social authentication state and handlers
  */
 
-import { useState, useCallback } from "react";
 import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
 import { Platform } from "react-native";
 
-export interface SocialAuthHandlers {
-  googleLoading: boolean;
-  appleLoading: boolean;
-  handleGoogleSignIn: () => Promise<void>;
-  handleAppleSignIn: () => Promise<void>;
-}
-
-export interface SocialAuthConfig {
+interface SocialAuthConfig {
   google?: { iosClientId?: string; webClientId?: string; androidClientId?: string };
   apple?: { enabled: boolean };
 }
 
-/**
- * Hook for managing a single social auth provider's loading state
- * @returns Loading state and handler creator
- */
-export function useSocialAuthLoading() {
-  const [googleLoading, setGoogleLoading] = useState(false);
-  const [appleLoading, setAppleLoading] = useState(false);
-
-  const createHandler = useCallback(
-    (setter: (loading: boolean) => void, signInHandler?: () => Promise<void>) => {
-      return async () => {
-        if (!signInHandler) {
-          throw new Error("Sign-in handler not available");
-        }
-        setter(true);
-        try {
-          await signInHandler();
-        } finally {
-          setter(false);
-        }
-      };
-    },
-    []
-  );
-
-  return {
-    googleLoading,
-    appleLoading,
-    setGoogleLoading,
-    setAppleLoading,
-    createHandler,
-  };
-}
-
 /**
  * Determine enabled social auth providers
  */
@@ -74,16 +32,4 @@ export function determineEnabledProviders(
   return providers;
 }
 
-/**
- * Select the appropriate sign-in handler from external and internal options
- * @param externalHandler - External handler provided by parent
- * @param internalHandler - Internal handler from auth hook
- * @returns The selected handler or undefined
- */
-export function selectSignInHandler(
-  externalHandler?: () => Promise<void>,
-  internalHandler?: () => Promise<void>
-): (() => Promise<void>) | undefined {
-  return externalHandler ?? internalHandler;
-}
 

package/src/infrastructure/utils/AuthErrorMapper.ts

@@ -1,93 +0,0 @@
-/**
- * Auth Error Mapper
- * Single Responsibility: Map Firebase Auth errors to domain errors
- *
- * @module AuthErrorMapper
- * @description Provides type-safe error mapping from Firebase Auth errors to
- * domain-specific error types. Includes runtime validation and type guards.
- */
-
-import {
-  AuthError,
-  AuthConfigurationError,
-  AuthNetworkError,
-} from "../../domain/errors/AuthError";
-import {
-  extractErrorCode,
-  extractErrorMessage,
-} from "./error/errorExtraction";
-import { ERROR_CODE_MAP, type ErrorConstructor, type ErrorFactory } from "./error/errorCodeMapping.constants";
-
-/**
- * Create error from error mapping
- * @param mapping - Error mapping configuration
- * @returns Created error instance
- */
-function createErrorFromMapping(mapping: { type: "class" | "factory"; create: ErrorConstructor | ErrorFactory }): Error {
-  return mapping.type === "class"
-    ? new (mapping.create as ErrorConstructor)()
-    : (mapping.create as ErrorFactory)();
-}
-
-/**
- * Map Firebase Auth errors to domain errors
- *
- * @param error - Unknown error from Firebase Auth or other sources
- * @returns Mapped domain error with appropriate error type and message
- *
- * @example
- * ```ts
- * try {
- *   await signInWithEmailAndPassword(auth, email, password);
- * } catch (error) {
- *   throw mapFirebaseAuthError(error);
- * }
- * ```
- *
- * @remarks
- * This function handles:
- * - Firebase Auth errors with proper code mapping
- * - Standard JavaScript Error objects
- * - Unknown error types with safe fallbacks
- * - Type-safe error extraction using type guards
- */
-export function mapFirebaseAuthError(error: unknown): Error {
-  // Handle null/undefined
-  if (!error || typeof error !== 'object') {
-    return new AuthError("Authentication failed", "AUTH_UNKNOWN_ERROR");
-  }
-
-  const code = extractErrorCode(error);
-  const message = extractErrorMessage(error);
-
-  // Map known Firebase Auth error codes to domain errors
-  const mapping = ERROR_CODE_MAP[code];
-  if (mapping) {
-    return createErrorFromMapping(mapping);
-  }
-
-  // Default fallback for unknown error codes
-  return new AuthError(message, code || "AUTH_UNKNOWN_ERROR");
-}
-
-/**
- * Check if error is a network-related error
- * @param error - Error to check
- * @returns True if error is network-related
- */
-export function isNetworkError(error: unknown): boolean {
-  return (
-    error instanceof AuthNetworkError ||
-    (error instanceof AuthError && error.code === "auth/network-request-failed")
-  );
-}
-
-/**
- * Check if error is a configuration-related error
- * @param error - Error to check
- * @returns True if error is configuration-related
- */
-export function isConfigurationError(error: unknown): boolean {
-  return error instanceof AuthConfigurationError;
-}
-

package/src/infrastructure/utils/error/errorCodeMapping.constants.ts

@@ -1,23 +0,0 @@
-/**
- * Firebase Error Code Mapping Constants
- * Centralized configuration for mapping Firebase error codes to domain errors
- */
-
-import type { ErrorMapping } from "./mappings/errorMapping.types";
-import { AUTH_ERROR_MAPPINGS } from "./mappings/authErrorMappings";
-import { CONFIG_ERROR_MAPPINGS } from "./mappings/configErrorMappings";
-import { NETWORK_ERROR_MAPPINGS } from "./mappings/networkErrorMappings";
-import { ACTION_CODE_ERROR_MAPPINGS } from "./mappings/actionCodeErrorMappings";
-
-// Export types needed by AuthErrorMapper
-export type { ErrorConstructor, ErrorFactory } from "./mappings/errorMapping.types";
-
-/**
- * Combined Firebase error code to domain error mapping
- */
-export const ERROR_CODE_MAP: Record<string, ErrorMapping> = {
-  ...AUTH_ERROR_MAPPINGS,
-  ...CONFIG_ERROR_MAPPINGS,
-  ...NETWORK_ERROR_MAPPINGS,
-  ...ACTION_CODE_ERROR_MAPPINGS,
-};

package/src/infrastructure/utils/error/errorExtraction.ts

@@ -1,80 +0,0 @@
-/**
- * Error Extraction Utilities
- * Utilities for extracting error information from various error types
- */
-
-/**
- * Firebase Auth error structure
- * Based on Firebase Auth SDK error format
- */
-interface FirebaseAuthError {
-    code: string;
-    message: string;
-    name?: string;
-    stack?: string;
-}
-
-/**
- * Type guard to check if error is a valid Firebase Auth error
- * @param error - Unknown error to check
- * @returns True if error matches Firebase Auth error structure
- */
-export function isFirebaseAuthError(error: unknown): error is FirebaseAuthError {
-    if (!error || typeof error !== 'object') {
-        return false;
-    }
-
-    const err = error as Partial<FirebaseAuthError>;
-    return (
-        typeof err.code === 'string' &&
-        typeof err.message === 'string' &&
-        err.code.startsWith('auth/')
-    );
-}
-
-/**
- * Extract error code from error object
- * @param error - Unknown error
- * @returns Error code or empty string
- */
-export function extractErrorCode(error: unknown): string {
-    if (isFirebaseAuthError(error)) {
-        return error.code;
-    }
-
-    // Fallback for non-Firebase errors
-    if (error && typeof error === 'object' && 'code' in error) {
-        const code = (error as { code?: unknown }).code;
-        if (typeof code === 'string') {
-            return code;
-        }
-    }
-
-    return '';
-}
-
-/**
- * Extract error message from error object
- * @param error - Unknown error
- * @returns Error message or default message
- */
-export function extractErrorMessage(error: unknown): string {
-    if (isFirebaseAuthError(error)) {
-        return error.message;
-    }
-
-    // Fallback for Error objects
-    if (error instanceof Error) {
-        return error.message;
-    }
-
-    // Fallback for objects with message property
-    if (error && typeof error === 'object' && 'message' in error) {
-        const message = (error as { message?: unknown }).message;
-        if (typeof message === 'string') {
-            return message;
-        }
-    }
-
-    return "Authentication failed";
-}

package/src/infrastructure/utils/error/mappings/actionCodeErrorMappings.ts

@@ -1,26 +0,0 @@
-/**
- * Action Code Error Mappings
- * Email verification, password reset link errors
- */
-
-import { AuthError } from "../../../../domain/errors/AuthError";
-import type { ErrorMapping } from "./errorMapping.types";
-
-export const ACTION_CODE_ERROR_MAPPINGS: Record<string, ErrorMapping> = {
-  "auth/expired-action-code": {
-    type: "factory",
-    create: () =>
-      new AuthError(
-        "This link has expired. Please request a new one.",
-        "AUTH_EXPIRED_ACTION_CODE"
-      ),
-  },
-  "auth/invalid-action-code": {
-    type: "factory",
-    create: () =>
-      new AuthError(
-        "This link is invalid. Please request a new one.",
-        "AUTH_INVALID_ACTION_CODE"
-      ),
-  },
-};