@umituz/react-native-auth 4.3.77 → 4.3.79

package/src/infrastructure/utils/listener/anonymousSignIn/types.ts

@@ -0,0 +1,21 @@
+/**
+ * Anonymous Sign-In Types
+ */
+
+export interface AnonymousSignInCallbacks {
+  onSignInSuccess: () => void;
+  onSignInFailure: (error: Error) => void;
+}
+
+export interface AnonymousSignInOptions {
+  maxRetries?: number;
+  retryDelay?: number;
+  timeout?: number;
+}
+
+export interface AnonymousStore {
+  setFirebaseUser: (user: any) => void;
+  setLoading: (loading: boolean) => void;
+  setInitialized: (initialized: boolean) => void;
+  setError: (error: string | null) => void;
+}

package/src/presentation/components/RegisterForm/RegisterForm.tsx

@@ -0,0 +1,91 @@
+/**
+ * Register Form Component
+ * Main registration form with error display and actions
+ */
+
+import React, { memo } from 'react';
+import { AtomicButton } from '@umituz/react-native-design-system/atoms';
+import { useRegisterForm } from '../../hooks/useRegisterForm';
+import { AuthErrorDisplay } from '../AuthErrorDisplay';
+import { AuthLink } from '../AuthLink';
+import { AuthLegalLinks } from '../AuthLegalLinks';
+import { RegisterFormFields } from './RegisterFormFields';
+import { styles } from './styles';
+import type { RegisterFormProps } from './types';
+
+export const RegisterForm = memo<RegisterFormProps>(({
+  translations,
+  onNavigateToLogin,
+  termsUrl,
+  privacyUrl,
+  onTermsPress,
+  onPrivacyPress,
+}) => {
+  const {
+    displayName,
+    email,
+    password,
+    confirmPassword,
+    fieldErrors,
+    loading,
+    passwordRequirements,
+    passwordsMatch,
+    handleDisplayNameChange,
+    handleEmailChange,
+    handlePasswordChange,
+    handleConfirmPasswordChange,
+    handleSignUp,
+    displayError,
+  } = useRegisterForm();
+
+  return (
+    <>
+      <RegisterFormFields
+        displayName={displayName}
+        email={email}
+        password={password}
+        confirmPassword={confirmPassword}
+        fieldErrors={fieldErrors}
+        loading={loading}
+        passwordRequirements={passwordRequirements}
+        passwordsMatch={passwordsMatch}
+        translations={translations}
+        onDisplayNameChange={handleDisplayNameChange}
+        onEmailChange={handleEmailChange}
+        onPasswordChange={handlePasswordChange}
+        onConfirmPasswordChange={handleConfirmPasswordChange}
+        onSubmit={handleSignUp}
+      />
+
+      <AuthErrorDisplay error={displayError} />
+
+      <AtomicButton
+        variant="primary"
+        onPress={() => void handleSignUp()}
+        disabled={loading || !email.trim() || !password || !confirmPassword}
+        fullWidth
+        style={styles.signUpButton}
+      >
+        {translations.signUp}
+      </AtomicButton>
+
+      <AuthLink
+        text={translations.alreadyHaveAccount}
+        linkText={translations.signIn}
+        onPress={onNavigateToLogin}
+        disabled={loading}
+      />
+
+      <AuthLegalLinks
+        translations={translations.legal}
+        termsUrl={termsUrl}
+        privacyUrl={privacyUrl}
+        onTermsPress={onTermsPress}
+        onPrivacyPress={onPrivacyPress}
+        prefixText={translations.bySigningUp}
+      />
+    </>
+  );
+});
+
+RegisterForm.displayName = 'RegisterForm';

package/src/presentation/components/RegisterForm/RegisterFormFields.tsx

@@ -0,0 +1,117 @@
+/**
+ * Register Form Fields
+ * Individual form field components for registration
+ */
+
+import React, { useRef } from 'react';
+import { TextInput } from 'react-native';
+import { FormTextInput } from '../form/FormTextInput';
+import { FormEmailInput } from '../form/FormEmailInput';
+import { FormPasswordInput } from '../form/FormPasswordInput';
+import { PasswordStrengthIndicator } from '../PasswordStrengthIndicator';
+import { PasswordMatchIndicator } from '../PasswordMatchIndicator';
+import type { RegisterFormTranslations } from './types';
+
+export interface RegisterFormFieldsProps {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  fieldErrors: Record<string, string | null>;
+  loading: boolean;
+  passwordRequirements: any;
+  passwordsMatch: boolean;
+  translations: RegisterFormTranslations;
+  onDisplayNameChange: (value: string) => void;
+  onEmailChange: (value: string) => void;
+  onPasswordChange: (value: string) => void;
+  onConfirmPasswordChange: (value: string) => void;
+  onSubmit: () => void;
+}
+
+export const RegisterFormFields: React.FC<RegisterFormFieldsProps> = ({
+  displayName,
+  email,
+  password,
+  confirmPassword,
+  fieldErrors,
+  loading,
+  passwordRequirements,
+  passwordsMatch,
+  translations,
+  onDisplayNameChange,
+  onEmailChange,
+  onPasswordChange,
+  onConfirmPasswordChange,
+  onSubmit,
+}) => {
+  const emailRef = useRef<React.ElementRef<typeof TextInput>>(null);
+  const passwordRef = useRef<React.ElementRef<typeof TextInput>>(null);
+  const confirmPasswordRef = useRef<React.ElementRef<typeof TextInput>>(null);
+
+  return (
+    <>
+      <FormTextInput
+        value={displayName}
+        onChangeText={onDisplayNameChange}
+        label={translations.displayName}
+        placeholder={translations.displayNamePlaceholder}
+        error={fieldErrors.displayName}
+        disabled={loading}
+        autoCapitalize="words"
+        onSubmitEditing={() => emailRef.current?.focus()}
+        returnKeyType="next"
+      />
+
+      <FormEmailInput
+        ref={emailRef}
+        value={email}
+        onChangeText={onEmailChange}
+        label={translations.email}
+        placeholder={translations.emailPlaceholder}
+        error={fieldErrors.email}
+        disabled={loading}
+        onSubmitEditing={() => passwordRef.current?.focus()}
+        returnKeyType="next"
+      />
+
+      <FormPasswordInput
+        ref={passwordRef}
+        value={password}
+        onChangeText={onPasswordChange}
+        label={translations.password}
+        placeholder={translations.passwordPlaceholder}
+        error={fieldErrors.password}
+        disabled={loading}
+        onSubmitEditing={() => confirmPasswordRef.current?.focus()}
+        returnKeyType="next"
+        style={{ marginBottom: 4 }}
+      />
+      {password.length > 0 && (
+        <PasswordStrengthIndicator
+          translations={translations.passwordStrength}
+          requirements={passwordRequirements}
+        />
+      )}
+
+      <FormPasswordInput
+        ref={confirmPasswordRef}
+        value={confirmPassword}
+        onChangeText={onConfirmPasswordChange}
+        label={translations.confirmPassword}
+        placeholder={translations.confirmPasswordPlaceholder}
+        error={fieldErrors.confirmPassword}
+        disabled={loading}
+        onSubmitEditing={() => void onSubmit()}
+        returnKeyType="done"
+        style={{ marginBottom: 4 }}
+      />
+      {confirmPassword.length > 0 && (
+        <PasswordMatchIndicator
+          translations={translations.passwordMatch}
+          isMatch={passwordsMatch}
+        />
+      )}
+    </>
+  );
+};

package/src/presentation/components/RegisterForm/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Register Form Module Exports
+ */
+
+export { RegisterForm } from './RegisterForm';
+export { RegisterFormFields } from './RegisterFormFields';
+export type { RegisterFormTranslations, RegisterFormProps } from './types';

package/src/presentation/components/RegisterForm/styles.ts

@@ -0,0 +1,11 @@
+/**
+ * Register Form Styles
+ */
+
+import { StyleSheet } from 'react-native';
+
+export const styles = StyleSheet.create({
+  passwordInput: { marginBottom: 4 },
+  confirmPasswordInput: { marginBottom: 4 },
+  signUpButton: { minHeight: 52, marginBottom: 16, marginTop: 8 },
+});

package/src/presentation/components/RegisterForm/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Register Form Types
+ */
+
+import type { AuthLegalLinksTranslations } from '../AuthLegalLinks';
+import type { PasswordStrengthTranslations } from '../PasswordStrengthIndicator';
+import type { PasswordMatchTranslations } from '../PasswordMatchIndicator';
+
+export interface RegisterFormTranslations {
+  displayName: string;
+  displayNamePlaceholder: string;
+  email: string;
+  emailPlaceholder: string;
+  password: string;
+  passwordPlaceholder: string;
+  confirmPassword: string;
+  confirmPasswordPlaceholder: string;
+  signUp: string;
+  alreadyHaveAccount: string;
+  signIn: string;
+  bySigningUp: string;
+  legal: AuthLegalLinksTranslations;
+  passwordStrength: PasswordStrengthTranslations;
+  passwordMatch: PasswordMatchTranslations;
+}
+
+export interface RegisterFormProps {
+  translations: RegisterFormTranslations;
+  onNavigateToLogin: () => void;
+  termsUrl?: string;
+  privacyUrl?: string;
+  onTermsPress?: () => void;
+  onPrivacyPress?: () => void;
+}

package/src/presentation/hooks/auth/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Auth Hooks Module Exports
+ */
+
+export { useAuthBottomSheet } from './useAuthBottomSheet';
+export { useSocialAuthHandlers } from './useSocialAuthHandlers';
+export type { UseAuthBottomSheetParams, SocialAuthConfiguration, SocialAuthHandlers } from './types';

package/src/presentation/hooks/auth/types.ts

@@ -0,0 +1,26 @@
+/**
+ * Auth Bottom Sheet Types
+ */
+
+import type { GoogleAuthConfig } from '../useGoogleAuth';
+import type { SocialAuthProvider } from '../../domain/value-objects/AuthConfig';
+
+export interface SocialAuthConfiguration {
+  google?: GoogleAuthConfig;
+  apple?: { enabled: boolean };
+}
+
+export interface UseAuthBottomSheetParams {
+  socialConfig?: SocialAuthConfiguration;
+  onGoogleSignIn?: () => Promise<void>;
+  onAppleSignIn?: () => Promise<void>;
+  /** Called when auth completes successfully (login or register) */
+  onAuthSuccess?: () => void;
+}
+
+export interface SocialAuthHandlers {
+  handleGoogleSignIn: () => Promise<void>;
+  handleAppleSignIn: () => Promise<void>;
+  googleLoading: boolean;
+  appleLoading: boolean;
+}

package/src/presentation/hooks/auth/useAuthBottomSheet.ts

@@ -0,0 +1,110 @@
+/**
+ * Auth Bottom Sheet Hook (Refactored)
+ * Main hook for auth bottom sheet management
+ */
+
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import type { BottomSheetModalRef } from '@umituz/react-native-design-system/molecules';
+import { useAuthModalStore } from '../../stores/authModalStore';
+import { useAuth } from '../useAuth';
+import { determineEnabledProviders } from '../../utils/socialAuthHandler.util';
+import { useAuthTransitions, executeAfterAuth } from '../../utils/authTransition.util';
+import { useSocialAuthHandlers } from './useSocialAuthHandlers';
+import type { SocialAuthProvider } from '../../../domain/value-objects/AuthConfig';
+import type { UseAuthBottomSheetParams } from './types';
+
+export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
+  const { socialConfig, onGoogleSignIn, onAppleSignIn, onAuthSuccess } = params;
+
+  const modalRef = useRef<BottomSheetModalRef>(null);
+
+  const { isVisible, mode, hideAuthModal, setMode, executePendingCallback, clearPendingCallback } =
+    useAuthModalStore();
+  const { isAuthenticated, isAnonymous } = useAuth();
+
+  // Social auth handlers
+  const { handleGoogleSignIn, handleAppleSignIn, googleLoading, appleLoading } =
+    useSocialAuthHandlers(socialConfig, onGoogleSignIn, onAppleSignIn);
+
+  // Determine enabled providers
+  const providers = useMemo<SocialAuthProvider[]>(() => {
+    return determineEnabledProviders(socialConfig, appleAvailable, googleConfigured);
+  }, [socialConfig, appleAvailable, googleConfigured]);
+
+  // Handle visibility sync with modalRef
+  useEffect(() => {
+    if (isVisible) {
+      modalRef.current?.present();
+    } else {
+      modalRef.current?.dismiss();
+    }
+  }, [isVisible]);
+
+  const handleDismiss = useCallback(() => {
+    hideAuthModal();
+    clearPendingCallback();
+  }, [hideAuthModal, clearPendingCallback]);
+
+  const handleClose = useCallback(() => {
+    modalRef.current?.dismiss();
+    handleDismiss();
+  }, [handleDismiss]);
+
+  // Handle auth transitions
+  useAuthTransitions(
+    { isAuthenticated, isAnonymous, isVisible },
+    (result) => {
+      if (result.shouldClose) {
+        modalRef.current?.dismiss();
+        hideAuthModal();
+        onAuthSuccess?.();
+
+        const timeoutId = executeAfterAuth(() => {
+          executePendingCallback();
+        });
+
+        return () => clearTimeout(timeoutId);
+      }
+      return undefined;
+    }
+  );
+
+  const handleNavigateToRegister = useCallback(() => {
+    setMode('register');
+  }, [setMode]);
+
+  const handleNavigateToLogin = useCallback(() => {
+    setMode('login');
+  }, [setMode]);
+
+  return useMemo(
+    () => ({
+      modalRef,
+      googleLoading,
+      appleLoading,
+      mode,
+      providers,
+      handleDismiss,
+      handleClose,
+      handleNavigateToRegister,
+      handleNavigateToLogin,
+      handleGoogleSignIn,
+      handleAppleSignIn,
+    }),
+    [
+      modalRef,
+      googleLoading,
+      appleLoading,
+      mode,
+      providers,
+      handleDismiss,
+      handleClose,
+      handleNavigateToRegister,
+      handleNavigateToLogin,
+      handleGoogleSignIn,
+      handleAppleSignIn,
+    ]
+  );
+}
+
+// TODO: Fix appleAvailable and googleConfigured references

package/src/presentation/hooks/auth/useSocialAuthHandlers.ts

@@ -0,0 +1,56 @@
+/**
+ * Social Auth Handlers
+ * Handles social authentication logic
+ */
+
+import { useCallback, useState } from 'react';
+import { useGoogleAuth } from '../useGoogleAuth';
+import { useAppleAuth } from '../useAppleAuth';
+import type { SocialAuthConfiguration, SocialAuthHandlers } from './types';
+
+export function useSocialAuthHandlers(
+  socialConfig?: SocialAuthConfiguration,
+  onGoogleSignIn?: () => Promise<void>,
+  onAppleSignIn?: () => Promise<void>
+): SocialAuthHandlers {
+  // Social Auth Hooks
+  const { signInWithGoogle, googleConfigured } = useGoogleAuth(socialConfig?.google);
+  const { signInWithApple, appleAvailable } = useAppleAuth();
+
+  // Social auth loading states
+  const [googleLoading, setGoogleLoading] = useState(false);
+  const [appleLoading, setAppleLoading] = useState(false);
+
+  const handleGoogleSignIn = useCallback(async () => {
+    setGoogleLoading(true);
+    try {
+      if (onGoogleSignIn) {
+        await onGoogleSignIn();
+      } else if (signInWithGoogle) {
+        await signInWithGoogle();
+      }
+    } finally {
+      setGoogleLoading(false);
+    }
+  }, [onGoogleSignIn, signInWithGoogle]);
+
+  const handleAppleSignIn = useCallback(async () => {
+    setAppleLoading(true);
+    try {
+      if (onAppleSignIn) {
+        await onAppleSignIn();
+      } else if (signInWithApple) {
+        await signInWithApple();
+      }
+    } finally {
+      setAppleLoading(false);
+    }
+  }, [onAppleSignIn, signInWithApple]);
+
+  return {
+    handleGoogleSignIn,
+    handleAppleSignIn,
+    googleLoading,
+    appleLoading,
+  };
+}

package/src/shared/error-handling/handlers/ErrorHandler.ts

@@ -0,0 +1,70 @@
+/**
+ * Error Handler
+ * Centralized error handling logic
+ */
+
+import type { ErrorMap } from '../types/ErrorTypes';
+import { ErrorMapper, DEFAULT_AUTH_ERROR_MAPPINGS } from '../mappers/ErrorMapper';
+
+export class ErrorHandler {
+  private mapper: ErrorMapper;
+  private translations?: ErrorMap;
+
+  constructor(translations?: ErrorMap, config?: typeof DEFAULT_AUTH_ERROR_MAPPINGS) {
+    this.mapper = new ErrorMapper(config || DEFAULT_AUTH_ERROR_MAPPINGS);
+    this.translations = translations;
+  }
+
+  /**
+   * Handle error and return user-friendly message
+   */
+  handle(error: unknown): string {
+    const key = this.mapper.getLocalizationKey(error);
+    return this.mapper.resolveMessage(key, this.translations);
+  }
+
+  /**
+   * Get localization key for error
+   */
+  getErrorKey(error: unknown): string {
+    return this.mapper.getLocalizationKey(error);
+  }
+
+  /**
+   * Update translations
+   */
+  setTranslations(translations: ErrorMap): void {
+    this.translations = translations;
+  }
+
+  /**
+   * Set error mappings
+   */
+  setMappings(config: Partial<typeof DEFAULT_AUTH_ERROR_MAPPINGS>): void {
+    this.mapper.setMappings(config);
+  }
+
+  /**
+   * Check if error is of specific type
+   */
+  isErrorType(error: unknown, errorName: string): boolean {
+    return error instanceof Error && error.name === errorName;
+  }
+
+  /**
+   * Log error in development
+   */
+  logError(context: string, error: unknown): void {
+    if (__DEV__) {
+      console.error(`[${context}] Error:`, error);
+    }
+  }
+
+  /**
+   * Handle and log error
+   */
+  handleAndLog(context: string, error: unknown): string {
+    this.logError(context, error);
+    return this.handle(error);
+  }
+}

package/src/shared/error-handling/handlers/FormErrorHandler.ts

@@ -0,0 +1,99 @@
+/**
+ * Form Error Handler
+ * Handles form-specific error logic
+ */
+
+import type { FieldError, ErrorMap } from '../types/ErrorTypes';
+import { ErrorHandler } from './ErrorHandler';
+import { FieldErrorMapper } from '../mappers/FieldErrorMapper';
+
+export interface FormErrorHandlerConfig {
+  translations?: ErrorMap;
+  errorMappings?: Partial<typeof DEFAULT_AUTH_ERROR_MAPPINGS>;
+}
+
+export class FormErrorHandler extends ErrorHandler {
+  constructor(config: FormErrorHandlerConfig = {}) {
+    super(config.translations, config.errorMappings);
+  }
+
+  /**
+   * Handle validation result errors
+   */
+  handleValidationErrors(
+    errors: FieldError[],
+    translations?: ErrorMap
+  ): Record<string, string> {
+    const mappedErrors = translations
+      ? FieldErrorMapper.mapErrorsToMessages(errors, translations)
+      : errors;
+
+    return FieldErrorMapper.toRecord(mappedErrors);
+  }
+
+  /**
+   * Get form field errors with null support
+   */
+  getFormFieldErrors(
+    errors: FieldError[],
+    fields: string[]
+  ): Record<string, string | null> {
+    return FieldErrorMapper.toFormFieldErrors(errors, fields);
+  }
+
+  /**
+   * Check if form has errors
+   */
+  formHasErrors(errors: FieldError[]): boolean {
+    return errors.length > 0;
+  }
+
+  /**
+   * Check if specific field has error
+   */
+  fieldHasError(errors: FieldError[], field: string): boolean {
+    return FieldErrorMapper.extractFieldError(errors, field) !== null;
+  }
+
+  /**
+   * Get first form error message
+   */
+  getFirstFormError(errors: FieldError[]): string | null {
+    return FieldErrorMapper.getFirstErrorMessage(errors);
+  }
+
+  /**
+   * Handle auth error for form
+   */
+  handleAuthError(error: unknown): string {
+    return this.handle(error);
+  }
+
+  /**
+   * Clear field errors for specific fields
+   */
+  clearFieldErrors(errors: FieldError[], fields: string[]): FieldError[] {
+    return FieldErrorMapper.excludeFields(errors, fields);
+  }
+
+  /**
+   * Filter errors to only specific fields
+   */
+  filterToFields(errors: FieldError[], fields: string[]): FieldError[] {
+    return FieldErrorMapper.filterByFields(errors, fields);
+  }
+
+  /**
+   * Create field error
+   */
+  createFieldError(field: string, message: string): FieldError {
+    return FieldErrorMapper.createFieldError(field, message);
+  }
+
+  /**
+   * Merge multiple error arrays
+   */
+  mergeErrors(...errorArrays: FieldError[][]): FieldError[] {
+    return FieldErrorMapper.mergeFieldErrors(...errorArrays);
+  }
+}

package/src/shared/error-handling/handlers/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Error Handlers Public API
+ */
+
+export { ErrorHandler } from './ErrorHandler';
+export { FormErrorHandler } from './FormErrorHandler';
+export type { FormErrorHandlerConfig } from './FormErrorHandler';

package/src/shared/error-handling/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Error Handling Module Public API
+ * Centralized error handling system
+ */
+
+// Types
+export type {
+  FieldError,
+  FormFieldErrors,
+  ErrorMap,
+  ErrorMappingConfig,
+} from './types';
+
+// Mappers
+export { ErrorMapper, DEFAULT_AUTH_ERROR_MAPPINGS, FieldErrorMapper } from './mappers';
+
+// Handlers
+export { ErrorHandler, FormErrorHandler } from './handlers';
+export type { FormErrorHandlerConfig } from './handlers';