@umituz/react-native-auth 4.3.76 → 4.3.78

package/src/shared/error-handling/mappers/ErrorMapper.ts

@@ -0,0 +1,115 @@
+/**
+ * Error Mapper
+ * Maps errors to localization keys
+ */
+
+import type { ErrorMap, ErrorMappingConfig } from '../types/ErrorTypes';
+
+export class ErrorMapper {
+  private config: ErrorMappingConfig;
+
+  constructor(config: ErrorMappingConfig = {}) {
+    this.config = {
+      errorCodeMap: config.errorCodeMap || {},
+      errorNameMap: config.errorNameMap || {},
+      defaultKey: config.defaultKey || 'auth.errors.unknownError',
+    };
+  }
+
+  /**
+   * Map error code to localization key
+   */
+  getLocalizationKey(error: unknown): string {
+    // Handle non-Error types
+    if (!(error instanceof Error)) {
+      return this.config.defaultKey!;
+    }
+
+    const code = (error as any).code;
+    const name = error.name;
+
+    // First check by error name (most specific)
+    if (this.config.errorNameMap && name && this.config.errorNameMap[name]) {
+      return this.config.errorNameMap[name];
+    }
+
+    // Then check by error code
+    if (this.config.errorCodeMap && code && this.config.errorCodeMap[code]) {
+      return this.config.errorCodeMap[code];
+    }
+
+    // Default to unknown error
+    return this.config.defaultKey!;
+  }
+
+  /**
+   * Resolve error key to localized message
+   */
+  resolveMessage(key: string, translations?: ErrorMap): string {
+    return translations?.[key] || key;
+  }
+
+  /**
+   * Get error message with translations
+   */
+  getErrorMessage(error: unknown, translations?: ErrorMap): string {
+    const key = this.getLocalizationKey(error);
+    return this.resolveMessage(key, translations);
+  }
+
+  /**
+   * Set error mappings
+   */
+  setMappings(config: Partial<ErrorMappingConfig>): void {
+    if (config.errorCodeMap) {
+      this.config.errorCodeMap = { ...this.config.errorCodeMap, ...config.errorCodeMap };
+    }
+    if (config.errorNameMap) {
+      this.config.errorNameMap = { ...this.config.errorNameMap, ...config.errorNameMap };
+    }
+    if (config.defaultKey) {
+      this.config.defaultKey = config.defaultKey;
+    }
+  }
+}
+
+/**
+ * Default auth error mappings
+ */
+export const DEFAULT_AUTH_ERROR_MAPPINGS: ErrorMappingConfig = {
+  errorCodeMap: {
+    AUTH_INVALID_EMAIL: 'auth.errors.invalidEmail',
+    AUTH_WEAK_PASSWORD: 'auth.errors.weakPassword',
+    AUTH_USER_NOT_FOUND: 'auth.errors.userNotFound',
+    AUTH_WRONG_PASSWORD: 'auth.errors.wrongPassword',
+    AUTH_EMAIL_ALREADY_IN_USE: 'auth.errors.emailAlreadyInUse',
+    AUTH_NETWORK_ERROR: 'auth.errors.networkError',
+    AUTH_CONFIG_ERROR: 'auth.errors.configurationError',
+    AUTH_TOO_MANY_REQUESTS: 'auth.errors.tooManyRequests',
+    AUTH_USER_DISABLED: 'auth.errors.userDisabled',
+    AUTH_NOT_INITIALIZED: 'auth.errors.authNotInitialized',
+    AUTH_INVALID_CREDENTIAL: 'auth.errors.invalidCredential',
+    // Firebase error codes
+    'auth/invalid-email': 'auth.errors.invalidEmail',
+    'auth/weak-password': 'auth.errors.weakPassword',
+    'auth/user-not-found': 'auth.errors.invalidCredential',
+    'auth/wrong-password': 'auth.errors.invalidCredential',
+    'auth/email-already-in-use': 'auth.errors.emailAlreadyInUse',
+    'auth/network-request-failed': 'auth.errors.networkError',
+    'auth/too-many-requests': 'auth.errors.tooManyRequests',
+    'auth/user-disabled': 'auth.errors.userDisabled',
+    'auth/invalid-credential': 'auth.errors.invalidCredential',
+    'auth/invalid-login-credentials': 'auth.errors.invalidCredential',
+  },
+  errorNameMap: {
+    AuthInvalidEmailError: 'auth.errors.invalidEmail',
+    AuthWeakPasswordError: 'auth.errors.weakPassword',
+    AuthUserNotFoundError: 'auth.errors.userNotFound',
+    AuthWrongPasswordError: 'auth.errors.wrongPassword',
+    AuthEmailAlreadyInUseError: 'auth.errors.emailAlreadyInUse',
+    AuthNetworkError: 'auth.errors.networkError',
+    AuthConfigurationError: 'auth.errors.configurationError',
+    AuthInitializationError: 'auth.errors.authNotInitialized',
+  },
+  defaultKey: 'auth.errors.unknownError',
+};

package/src/shared/error-handling/mappers/FieldErrorMapper.ts

@@ -0,0 +1,97 @@
+/**
+ * Field Error Mapper
+ * Maps field errors from validation results
+ */
+
+import type { FieldError, FormFieldErrors, ErrorMap } from '../types/ErrorTypes';
+
+export class FieldErrorMapper {
+  /**
+   * Convert field errors array to record
+   */
+  static toRecord(errors: FieldError[]): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const error of errors) {
+      result[error.field] = error.message;
+    }
+    return result;
+  }
+
+  /**
+   * Convert field errors array to form field errors (with null support)
+   */
+  static toFormFieldErrors(errors: FieldError[], fields: string[]): FormFieldErrors {
+    const result: FormFieldErrors = {};
+    for (const field of fields) {
+      const fieldError = errors.find((e) => e.field === field);
+      result[field] = fieldError?.message ?? null;
+    }
+    return result;
+  }
+
+  /**
+   * Extract single field error
+   */
+  static extractFieldError(errors: FieldError[], field: string): string | null {
+    const fieldError = errors.find((e) => e.field === field);
+    return fieldError?.message ?? null;
+  }
+
+  /**
+   * Check if validation has errors for specific fields
+   */
+  static hasFieldErrors(errors: FieldError[], fields: string[]): boolean {
+    return errors.some((error) => fields.includes(error.field));
+  }
+
+  /**
+   * Get first error message
+   */
+  static getFirstErrorMessage(errors: FieldError[]): string | null {
+    if (errors.length === 0) {
+      return null;
+    }
+    return errors[0].message ?? null;
+  }
+
+  /**
+   * Map error keys to messages using translation map
+   */
+  static mapErrorsToMessages(
+    errors: FieldError[],
+    translations: ErrorMap
+  ): FieldError[] {
+    return errors.map((error) => ({
+      ...error,
+      message: translations[error.message] || error.message,
+    }));
+  }
+
+  /**
+   * Create field error
+   */
+  static createFieldError(field: string, message: string): FieldError {
+    return { field, message };
+  }
+
+  /**
+   * Merge field errors
+   */
+  static mergeFieldErrors(...errorArrays: FieldError[][]): FieldError[] {
+    return errorArrays.flat();
+  }
+
+  /**
+   * Filter errors by fields
+   */
+  static filterByFields(errors: FieldError[], fields: string[]): FieldError[] {
+    return errors.filter((error) => fields.includes(error.field));
+  }
+
+  /**
+   * Exclude errors by fields
+   */
+  static excludeFields(errors: FieldError[], fields: string[]): FieldError[] {
+    return errors.filter((error) => !fields.includes(error.field));
+  }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Error Mappers Public API
+ */
+
+export { ErrorMapper, DEFAULT_AUTH_ERROR_MAPPINGS } from './ErrorMapper';
+export { FieldErrorMapper } from './FieldErrorMapper';

package/src/shared/error-handling/types/ErrorTypes.ts

@@ -0,0 +1,23 @@
+/**
+ * Error Types
+ * Core types for error handling system
+ */
+
+export interface FieldError {
+  field: string;
+  message: string;
+}
+
+export interface FormFieldErrors {
+  [fieldName: string]: string | null;
+}
+
+export interface ErrorMap {
+  [key: string]: string;
+}
+
+export interface ErrorMappingConfig {
+  errorCodeMap?: ErrorMap;
+  errorNameMap?: ErrorMap;
+  defaultKey?: string;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Error Types Public API
+ */
+
+export type {
+  FieldError,
+  FormFieldErrors,
+  ErrorMap,
+  ErrorMappingConfig,
+} from './ErrorTypes';

package/src/shared/form/builders/FieldBuilder.ts

@@ -0,0 +1,90 @@
+/**
+ * Field Builder
+ * Builds individual form field state and handlers
+ */
+
+import { useCallback, useRef } from 'react';
+import type { FieldState, FieldChangeHandler, FormFieldConfig } from '../types/FormTypes';
+
+export interface UseFieldOptions extends FormFieldConfig {
+  initialValue?: string;
+  onValueChange?: (value: string) => void;
+  onErrorClear?: () => void;
+}
+
+export interface UseFieldResult {
+  value: string;
+  error: string | null;
+  touched: boolean;
+  handleChange: FieldChangeHandler;
+  setError: (error: string | null) => void;
+  setTouched: (touched: boolean) => void;
+  reset: () => void;
+  clearError: () => void;
+}
+
+/**
+ * Hook for managing single form field
+ */
+export function useField(
+  options: UseFieldOptions = {}
+): UseFieldResult {
+  const {
+    initialValue = '',
+    validateOnChange = false,
+    clearErrorOnChange = true,
+    onValueChange,
+    onErrorClear,
+  } = options;
+
+  const [value, setValue] = React.useState(initialValue);
+  const [error, setError] = React.useState<string | null>(null);
+  const [touched, setTouched] = React.useState(false);
+
+  // Store refs to avoid recreating handlers
+  const initialValueRef = useRef(initialValue);
+  const onValueChangeRef = useRef(onValueChange);
+  const onErrorClearRef = useRef(onErrorClear);
+
+  // Update refs
+  onValueChangeRef.current = onValueChange;
+  onErrorClearRef.current = onErrorClear;
+
+  const handleChange = useCallback((newValue: string) => {
+    setValue(newValue);
+
+    // Clear error on change if configured
+    if (clearErrorOnChange && error) {
+      setError(null);
+      onErrorClearRef.current?.();
+    }
+
+    // Call external callback
+    onValueChangeRef.current?.(newValue);
+  }, [error, clearErrorOnChange]);
+
+  const reset = useCallback(() => {
+    setValue(initialValueRef.current);
+    setError(null);
+    setTouched(false);
+  }, []);
+
+  const clearError = useCallback(() => {
+    setError(null);
+    onErrorClearRef.current?.();
+  }, []);
+
+  return {
+    value,
+    error,
+    touched,
+    handleChange,
+    setError,
+    setTouched,
+    reset,
+    clearError,
+  };
+}
+
+// Import React for useState
+import React from 'react';

package/src/shared/form/builders/FormBuilder.ts

@@ -0,0 +1,126 @@
+/**
+ * Form Builder
+ * Builds form state with multiple fields
+ */
+
+import { useCallback, useRef } from 'react';
+import type { FormState, FormConfig, FieldChangeHandler } from '../types/FormTypes';
+
+export interface UseFormOptions<T extends Record<string, string>> extends FormConfig {
+  initialValues: T;
+  onFieldChange?: (field: keyof T, value: string) => void;
+  onErrorsClear?: () => void;
+}
+
+export interface UseFormResult<T extends Record<string, string>> {
+  values: T;
+  errors: Record<keyof T, string | null>;
+  touched: Record<keyof T, boolean>;
+  handleChange: (field: keyof T) => (value: string) => void;
+  setFieldValue: (field: keyof T, value: string) => void;
+  setFieldError: (field: keyof T, error: string | null) => void;
+  setFieldTouched: (field: keyof T, touched: boolean) => void;
+  resetForm: () => void;
+  clearErrors: () => void;
+  clearFieldError: (field: keyof T) => void;
+  isDirty: boolean;
+}
+
+/**
+ * Hook for managing form with multiple fields
+ */
+export function useForm<T extends Record<string, string>>(
+  options: UseFormOptions<T>
+): UseFormResult<T> {
+  const {
+    initialValues,
+    validateOnBlur = false,
+    clearErrorsOnSubmit = true,
+    onFieldChange,
+    onErrorsClear,
+  } = options;
+
+  type FieldKey = keyof T;
+
+  const [values, setValues] = React.useState<T>(initialValues);
+  const [errors, setErrors] = React.useState<Record<FieldKey, string | null>>(
+    {} as Record<FieldKey, string | null>
+  );
+  const [touched, setTouched] = React.useState<Record<FieldKey, boolean>>(
+    {} as Record<FieldKey, boolean>
+  );
+
+  // Store initial values in ref
+  const initialValuesRef = useRef(initialValues);
+  const onFieldChangeRef = useRef(onFieldChange);
+  const onErrorsClearRef = useRef(onErrorsClear);
+
+  // Update refs
+  onFieldChangeRef.current = onFieldChange;
+  onErrorsClearRef.current = onErrorsClear;
+
+  const handleChange = useCallback(
+    (field: FieldKey) => (value: string) => {
+      setValues((prev) => ({ ...prev, [field]: value }));
+
+      // Clear error when field changes (optional)
+      if (errors[field]) {
+        setErrors((prev) => ({ ...prev, [field]: null }));
+      }
+
+      // Call external callback
+      onFieldChangeRef.current?.(field, value);
+    },
+    [errors]
+  );
+
+  const setFieldValue = useCallback((field: FieldKey, value: string) => {
+    setValues((prev) => ({ ...prev, [field]: value }));
+    onFieldChangeRef.current?.(field, value);
+  }, []);
+
+  const setFieldError = useCallback((field: FieldKey, error: string | null) => {
+    setErrors((prev) => ({ ...prev, [field]: error }));
+  }, []);
+
+  const setFieldTouched = useCallback((field: FieldKey, isTouched: boolean) => {
+    setTouched((prev) => ({ ...prev, [field]: isTouched }));
+  }, []);
+
+  const resetForm = useCallback(() => {
+    setValues(initialValuesRef.current);
+    setErrors({} as Record<FieldKey, string | null>);
+    setTouched({} as Record<FieldKey, boolean>);
+  }, []);
+
+  const clearErrors = useCallback(() => {
+    setErrors({} as Record<FieldKey, string | null>);
+    onErrorsClearRef.current?.();
+  }, []);
+
+  const clearFieldError = useCallback((field: FieldKey) => {
+    setErrors((prev) => ({ ...prev, [field]: null }));
+  }, []);
+
+  // Check if form is dirty (has changes)
+  const isDirty = Object.keys(values).some(
+    (key) => values[key as FieldKey] !== initialValuesRef.current[key as FieldKey]
+  );
+
+  return {
+    values,
+    errors,
+    touched,
+    handleChange,
+    setFieldValue,
+    setFieldError,
+    setFieldTouched,
+    resetForm,
+    clearErrors,
+    clearFieldError,
+    isDirty,
+  };
+}
+
+// Import React for useState
+import React from 'react';

package/src/shared/form/builders/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Form Builders Public API
+ */
+
+export { useField } from './FieldBuilder';
+export type { UseFieldOptions, UseFieldResult } from './FieldBuilder';
+
+export { useForm } from './FormBuilder';
+export type { UseFormOptions, UseFormResult } from './FormBuilder';

package/src/shared/form/index.ts

@@ -0,0 +1,51 @@
+/**
+ * Form Module Public API
+ * Centralized form state management system
+ */
+
+// Types
+export type {
+  FieldState,
+  FormState,
+  FieldChangeHandler,
+  FormFieldConfig,
+  FormConfig,
+} from './types';
+
+// Builders
+export { useField, useForm } from './builders';
+export type { UseFieldOptions, UseFieldResult, UseFormOptions, UseFormResult } from './builders';
+
+// State utilities
+export {
+  isFormValid,
+  isFormDirty,
+  isFormTouched,
+  getFormErrors,
+  getFirstFormError,
+  countFormErrors,
+  getFieldError,
+  fieldHasError,
+  isFieldTouched,
+  resetFormState,
+} from './state';
+
+// Utils
+export {
+  sanitizeFormValues,
+  extractFields,
+  areRequiredFieldsFilled,
+  getEmptyRequiredFields,
+  createFieldOptions,
+  mergeFormErrors,
+  clearFieldErrors,
+  createFieldChangeHandler,
+  createFieldBlurHandler,
+  debounceFieldChange,
+  isFieldValueEmpty,
+  sanitizeFieldValue,
+  formatFieldValue,
+  validateFieldValue,
+  getFieldDisplayValue,
+  truncateFieldValue,
+} from './utils';

package/src/shared/form/state/FormState.ts

@@ -0,0 +1,114 @@
+/**
+ * Form State Utilities
+ * Utilities for managing form state
+ */
+
+import type { FormState } from '../types/FormTypes';
+
+/**
+ * Check if form is valid (no errors)
+ */
+export function isFormValid<T extends Record<string, string>>(
+  formState: FormState<T>
+): boolean {
+  return Object.values(formState.errors).every((error) => error === null);
+}
+
+/**
+ * Check if form is dirty (has changes)
+ */
+export function isFormDirty<T extends Record<string, string>>(
+  formState: FormState<T>,
+  initialValues: T
+): boolean {
+  return Object.keys(formState.fields).some((key) => {
+    const fieldKey = key as keyof T;
+    return formState.fields[fieldKey] !== initialValues[fieldKey];
+  });
+}
+
+/**
+ * Check if form is touched (any field touched)
+ */
+export function isFormTouched<T extends Record<string, string>>(
+  formState: FormState<T>
+): boolean {
+  return Object.values(formState.touched).some((touched) => touched);
+}
+
+/**
+ * Get all errors as array
+ */
+export function getFormErrors<T extends Record<string, string>>(
+  formState: FormState<T>
+): string[] {
+  return Object.values(formState.errors).filter((error): error is string => error !== null);
+}
+
+/**
+ * Get first error message
+ */
+export function getFirstFormError<T extends Record<string, string>>(
+  formState: FormState<T>
+): string | null {
+  const errors = getFormErrors(formState);
+  return errors.length > 0 ? errors[0] : null;
+}
+
+/**
+ * Count errors
+ */
+export function countFormErrors<T extends Record<string, string>>(
+  formState: FormState<T>
+): number {
+  return getFormErrors(formState).length;
+}
+
+/**
+ * Get error for specific field
+ */
+export function getFieldError<T extends Record<string, string>>(
+  formState: FormState<T>,
+  field: keyof T
+): string | null {
+  return formState.errors[field] || null;
+}
+
+/**
+ * Check if field has error
+ */
+export function fieldHasError<T extends Record<string, string>>(
+  formState: FormState<T>,
+  field: keyof T
+): boolean {
+  return formState.errors[field] !== null;
+}
+
+/**
+ * Check if field is touched
+ */
+export function isFieldTouched<T extends Record<string, string>>(
+  formState: FormState<T>,
+  field: keyof T
+): boolean {
+  return formState.touched[field] || false;
+}
+
+/**
+ * Reset form to initial state
+ */
+export function resetFormState<T extends Record<string, string>>(
+  initialValues: T
+): FormState<T> {
+  return {
+    fields: initialValues,
+    errors: Object.keys(initialValues).reduce((acc, key) => {
+      acc[key as keyof T] = null;
+      return acc;
+    }, {} as Record<keyof T, string | null>),
+    touched: Object.keys(initialValues).reduce((acc, key) => {
+      acc[key as keyof T] = false;
+      return acc;
+    }, {} as Record<keyof T, boolean>),
+  };
+}

package/src/shared/form/state/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Form State Public API
+ */
+
+export {
+  isFormValid,
+  isFormDirty,
+  isFormTouched,
+  getFormErrors,
+  getFirstFormError,
+  countFormErrors,
+  getFieldError,
+  fieldHasError,
+  isFieldTouched,
+  resetFormState,
+} from './FormState';

package/src/shared/form/types/FormTypes.ts

@@ -0,0 +1,30 @@
+/**
+ * Form Types
+ * Core types for form system
+ */
+
+export interface FieldState {
+  value: string;
+  error: string | null;
+  touched: boolean;
+}
+
+export interface FormState<T extends Record<string, string>> {
+  fields: T;
+  errors: Record<keyof T, string | null>;
+  touched: Record<keyof T, boolean>;
+}
+
+export interface FieldChangeHandler {
+  (value: string): void;
+}
+
+export interface FormFieldConfig {
+  validateOnChange?: boolean;
+  clearErrorOnChange?: boolean;
+}
+
+export interface FormConfig {
+  validateOnBlur?: boolean;
+  clearErrorsOnSubmit?: boolean;
+}