@umituz/react-native-settings 4.23.86 → 4.23.88

package/src/infrastructure/utils/errorHandlers.ts

@@ -0,0 +1,249 @@
+/**
+ * Error Handling Utilities
+ * Centralized error handling and error message generation
+ * FIXED: Added safety checks for showToast and proper error handling
+ */
+
+/**
+ * Error types for better error classification
+ */
+export enum ErrorType {
+  NETWORK = "NETWORK",
+  VALIDATION = "VALIDATION",
+  AUTHENTICATION = "AUTHENTICATION",
+  AUTHORIZATION = "AUTHORIZATION",
+  NOT_FOUND = "NOT_FOUND",
+  SERVER = "SERVER",
+  UNKNOWN = "UNKNOWN",
+}
+
+/**
+ * Custom error class with error type
+ */
+export class AppError extends Error {
+  constructor(
+    message: string,
+    public type: ErrorType = ErrorType.UNKNOWN,
+    public code?: string,
+    public statusCode?: number
+  ) {
+    super(message);
+    this.name = "AppError";
+  }
+}
+
+/**
+ * Error handler result
+ */
+export interface ErrorHandlerResult {
+  message: string;
+  type: ErrorType;
+  shouldShowToUser: boolean;
+}
+
+/**
+ * Classify error based on error properties
+ */
+export const classifyError = (error: unknown): ErrorType => {
+  if (error instanceof AppError) {
+    return error.type;
+  }
+
+  if (!(error instanceof Error)) {
+    return ErrorType.UNKNOWN;
+  }
+
+  const errorMessage = error.message.toLowerCase();
+
+  // Network errors
+  if (
+    errorMessage.includes("network") ||
+    errorMessage.includes("fetch") ||
+    errorMessage.includes("connection")
+  ) {
+    return ErrorType.NETWORK;
+  }
+
+  // Authentication errors
+  if (
+    errorMessage.includes("unauthorized") ||
+    errorMessage.includes("unauthenticated") ||
+    errorMessage.includes("token") ||
+    errorMessage.includes("401")
+  ) {
+    return ErrorType.AUTHENTICATION;
+  }
+
+  // Authorization errors
+  if (
+    errorMessage.includes("forbidden") ||
+    errorMessage.includes("permission") ||
+    errorMessage.includes("403")
+  ) {
+    return ErrorType.AUTHORIZATION;
+  }
+
+  // Not found errors
+  if (
+    errorMessage.includes("not found") ||
+    errorMessage.includes("404")
+  ) {
+    return ErrorType.NOT_FOUND;
+  }
+
+  // Server errors
+  if (
+    errorMessage.includes("500") ||
+    errorMessage.includes("502") ||
+    errorMessage.includes("503")
+  ) {
+    return ErrorType.SERVER;
+  }
+
+  return ErrorType.UNKNOWN;
+};
+
+/**
+ * Get user-friendly error message
+ */
+export const getUserFriendlyErrorMessage = (
+  error: unknown,
+  context?: {
+    operation?: string;
+    entity?: string;
+  }
+): ErrorHandlerResult => {
+  const errorType = classifyError(error);
+
+  let message = "An unexpected error occurred";
+  let shouldShowToUser = true;
+
+  switch (errorType) {
+    case ErrorType.NETWORK:
+      message = "Unable to connect. Please check your internet connection and try again.";
+      break;
+
+    case ErrorType.AUTHENTICATION:
+      message = "Your session has expired. Please sign in again.";
+      break;
+
+    case ErrorType.AUTHORIZATION:
+      message = "You don't have permission to perform this action.";
+      break;
+
+    case ErrorType.NOT_FOUND:
+      if (context?.entity) {
+        // FIXED: Sanitize entity name to prevent injection
+        const sanitizedEntity = String(context.entity).replace(/[<>]/g, "");
+        message = `${sanitizedEntity} not found`;
+      } else {
+        message = "The requested resource was not found.";
+      }
+      break;
+
+    case ErrorType.SERVER:
+      message = "Server error. Please try again later.";
+      shouldShowToUser = false;
+      break;
+
+    case ErrorType.VALIDATION:
+      message = error instanceof Error ? error.message : "Invalid input";
+      break;
+
+    default:
+      if (error instanceof Error) {
+        message = error.message;
+      }
+  }
+
+  return { message, type: errorType, shouldShowToUser };
+};
+
+/**
+ * Log error appropriately based on type
+ */
+export const logError = (
+  error: unknown,
+  context?: {
+    operation?: string;
+    userId?: string;
+    additionalInfo?: Record<string, unknown>;
+  }
+): void => {
+  const errorType = classifyError(error);
+  const errorMessage = error instanceof Error ? error.message : String(error);
+
+  const logData = {
+    type: errorType,
+    message: errorMessage,
+    operation: context?.operation,
+    userId: context?.userId,
+    ...context?.additionalInfo,
+  };
+
+  // In production, send to error tracking service
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[Error]", logData);
+  }
+
+  // TODO: Send to error tracking service in production
+  // ErrorTracking.captureException(error, logData);
+};
+
+/**
+ * Handle error with logging and user message
+ */
+export const handleError = (
+  error: unknown,
+  context?: {
+    operation?: string;
+    entity?: string;
+    userId?: string;
+    showToast?: (message: string) => void;
+  }
+): ErrorHandlerResult => {
+  // Log the error
+  logError(error, context);
+
+  // Get user-friendly message
+  const result = getUserFriendlyErrorMessage(error, context);
+
+  // Show toast if provided and safe to do so
+  // FIXED: Added safety check and try-catch for showToast
+  if (context?.showToast && result.shouldShowToUser) {
+    try {
+      if (typeof context.showToast === "function") {
+        context.showToast(result.message);
+      }
+    } catch (toastError) {
+      // Log toast error but don't crash error handling
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[ErrorHandlers] showToast failed:", toastError);
+      }
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Wrap an async function with error handling
+ */
+export const withErrorHandling = async <T>(
+  operation: () => Promise<T>,
+  options: {
+    operation?: string;
+    entity?: string;
+    showToast?: (message: string) => void;
+    onError?: (result: ErrorHandlerResult) => void;
+  }
+): Promise<{ success: true; data: T } | { success: false; error: ErrorHandlerResult }> => {
+  try {
+    const data = await operation();
+    return { success: true, data };
+  } catch (error) {
+    const errorResult = handleError(error, options);
+    options?.onError?.(errorResult);
+    return { success: false, error: errorResult };
+  }
+};

package/src/infrastructure/utils/index.ts

@@ -5,3 +5,8 @@
 
 export * from './styleUtils';
 export * from './memoUtils';
+export * from './styleTokens';
+export * from './configFactory';
+export * from './validation';
+export * from './async';
+export * from './errorHandlers';

package/src/infrastructure/utils/memoUtils.ts

@@ -2,7 +2,7 @@
  * Memo Utilities
  * Centralized memoization helpers to reduce code duplication
  */
-import { useMemo, useCallback, useRef, DependencyList } from 'react';
+import { useMemo, useCallback, useRef, useEffect, DependencyList } from 'react';
 import type { DesignTokens } from '@umituz/react-native-design-system';
 
 /**
@@ -114,7 +114,7 @@ export function useMemoWithEquality<T>(
 }
 
 /**
- * Custom hook that creates a debounced callback
+ * Custom hook that creates a debounced callback with proper cleanup
  * @param callback Function to debounce
  * @param delay Delay in milliseconds
  * @returns Debounced callback
@@ -125,6 +125,14 @@ export function useDebouncedCallback<T extends (...args: any[]) => any>(
 ): T {
   const timeoutRef = useRef<NodeJS.Timeout | null>(null);
 
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+
   return useCallback((...args: Parameters<T>) => {
     if (timeoutRef.current) {
       clearTimeout(timeoutRef.current);

package/src/infrastructure/utils/styleTokens.ts

@@ -0,0 +1,132 @@
+/**
+ * Style Tokens
+ * Centralized design tokens to replace magic numbers across the codebase
+ */
+
+/**
+ * Spacing tokens - replaces magic numbers for padding, margins, gaps
+ */
+export const SPACING = {
+  xs: 4,
+  sm: 8,
+  md: 12,
+  lg: 16,
+  xl: 20,
+  xxl: 24,
+  xxxl: 32,
+} as const;
+
+/**
+ * Font size tokens - replaces magic numbers for font sizes
+ */
+export const FONT_SIZE = {
+  xs: 10,
+  sm: 12,
+  md: 14,
+  base: 16,
+  lg: 18,
+  xl: 20,
+  xxl: 24,
+  xxxl: 28,
+  display: 32,
+} as const;
+
+/**
+ * Border radius tokens - replaces magic numbers for border radius
+ */
+export const BORDER_RADIUS = {
+  none: 0,
+  sm: 4,
+  md: 8,
+  lg: 12,
+  xl: 16,
+  full: 9999,
+} as const;
+
+/**
+ * Opacity tokens - replaces magic numbers for opacity values
+ */
+export const OPACITY = {
+  disabled: 0.3,
+  hover: 0.7,
+  focus: 0.8,
+  pressed: 0.9,
+  overlay: 0.5,
+  icon: 0.6,
+} as const;
+
+/**
+ * Icon size tokens
+ */
+export const ICON_SIZE = {
+  xs: 16,
+  sm: 20,
+  md: 24,
+  lg: 32,
+  xl: 40,
+  xxl: 48,
+} as const;
+
+/**
+ * Layout dimension tokens
+ */
+export const DIMENSION = {
+  touchTarget: {
+    minHeight: 44,
+    minWidth: 44,
+  },
+  card: {
+    minHeight: 72,
+  },
+  input: {
+    minHeight: 48,
+  },
+  button: {
+    minHeight: 44,
+    height: 48,
+  },
+  avatar: {
+    xs: 24,
+    sm: 32,
+    md: 40,
+    lg: 48,
+    xl: 64,
+    xxl: 96,
+  },
+} as const;
+
+/**
+ * Z-index tokens for layering
+ */
+export const Z_INDEX = {
+  base: 0,
+  overlay: 10,
+  dropdown: 100,
+  sticky: 200,
+  fixed: 300,
+  modalBackdrop: 400,
+  modal: 500,
+  popover: 600,
+  toast: 700,
+} as const;
+
+/**
+ * Animation duration tokens (in ms)
+ */
+export const DURATION = {
+  fast: 150,
+  normal: 250,
+  slow: 350,
+  extraSlow: 500,
+} as const;
+
+/**
+ * Type exports for token values
+ */
+export type SpacingToken = typeof SPACING[keyof typeof SPACING];
+export type FontSizeToken = typeof FONT_SIZE[keyof typeof FONT_SIZE];
+export type BorderRadiusToken = typeof BORDER_RADIUS[keyof typeof BORDER_RADIUS];
+export type OpacityToken = typeof OPACITY[keyof typeof OPACITY];
+export type IconSizeToken = typeof ICON_SIZE[keyof typeof ICON_SIZE];
+export type ZIndexToken = typeof Z_INDEX[keyof typeof Z_INDEX];
+export type DurationToken = typeof DURATION[keyof typeof DURATION];

package/src/infrastructure/utils/validation/core.ts

@@ -0,0 +1,42 @@
+/**
+ * Core Validation Utilities
+ * Base validation interfaces and types
+ */
+
+/**
+ * Validation result interface
+ */
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+/**
+ * Text validation options
+ */
+export interface TextValidationOptions {
+  minLength?: number;
+  maxLength?: number;
+  required?: boolean;
+  pattern?: RegExp;
+  customValidator?: (value: string) => string | null;
+}
+
+/**
+ * Email validation options
+ */
+export interface EmailValidationOptions {
+  required?: boolean;
+  allowEmpty?: boolean;
+}
+
+/**
+ * Password validation options
+ */
+export interface PasswordValidationOptions {
+  minLength?: number;
+  requireUppercase?: boolean;
+  requireLowercase?: boolean;
+  requireNumber?: boolean;
+  requireSpecialChar?: boolean;
+}

package/src/infrastructure/utils/validation/formValidators.ts

@@ -0,0 +1,82 @@
+/**
+ * Form Validators
+ * Domain-specific form validation functions
+ */
+
+import type { ValidationResult } from "./core";
+import { validateRating } from "./numericValidators";
+
+/**
+ * Feedback form validation
+ */
+export const validateFeedbackForm = (data: {
+  type: string;
+  rating: number;
+  description: string;
+}): ValidationResult => {
+  // Validate rating
+  const ratingResult = validateRating(data.rating);
+  if (!ratingResult.isValid) {
+    return ratingResult;
+  }
+
+  // Validate description (required)
+  if (!data.description.trim()) {
+    return { isValid: false, error: "Please provide a description" };
+  }
+
+  // Check description length
+  if (data.description.length < 10) {
+    return { isValid: false, error: "Description must be at least 10 characters" };
+  }
+
+  if (data.description.length > 1000) {
+    return { isValid: false, error: "Description must be less than 1000 characters" };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Reminder form validation
+ */
+export const validateReminderForm = (data: {
+  title: string;
+  body?: string;
+  frequency: string;
+  hour?: number;
+  minute?: number;
+  weekday?: number;
+  maxTitleLength?: number;
+  maxBodyLength?: number;
+}): ValidationResult => {
+  // Validate title
+  if (!data.title.trim()) {
+    return { isValid: false, error: "Title is required" };
+  }
+
+  if (data.maxTitleLength && data.title.length > data.maxTitleLength) {
+    return { isValid: false, error: `Title must be less than ${data.maxTitleLength} characters` };
+  }
+
+  // Validate body length if provided
+  if (data.body && data.maxBodyLength && data.body.length > data.maxBodyLength) {
+    return { isValid: false, error: `Body must be less than ${data.maxBodyLength} characters` };
+  }
+
+  // Validate time values if provided
+  if (data.hour !== undefined && (data.hour < 0 || data.hour > 23)) {
+    return { isValid: false, error: "Hour must be between 0 and 23" };
+  }
+
+  if (data.minute !== undefined && (data.minute < 0 || data.minute > 59)) {
+    return { isValid: false, error: "Minute must be between 0 and 59" };
+  }
+
+  // Validate weekday if frequency is weekly
+  if (data.frequency === "weekly" && (data.weekday === undefined || data.weekday < 0 || data.weekday > 6)) {
+    return { isValid: false, error: "Please select a valid day" };
+  }
+
+  return { isValid: true };
+};

package/src/infrastructure/utils/validation/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Validation Utilities
+ * Barrel export for all validation modules
+ */
+
+export * from "./core";
+export * from "./textValidators";
+export * from "./passwordValidator";
+export * from "./numericValidators";
+export * from "./formValidators";
+
+import type { ValidationResult } from "./core";
+
+/**
+ * Form field validator factory
+ * Creates a validator function for a specific field
+ */
+export const createFieldValidator = <T>(
+  validator: (value: T) => ValidationResult
+) => {
+  return (value: T): ValidationResult => validator(value);
+};
+
+/**
+ * Multi-field validator
+ * Validates multiple fields and returns the first error
+ */
+export const validateMultipleFields = (
+  fields: Record<string, ValidationResult>
+): ValidationResult => {
+  for (const result of Object.values(fields)) {
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return { isValid: true };
+};

package/src/infrastructure/utils/validation/numericValidators.ts

@@ -0,0 +1,66 @@
+/**
+ * Numeric Validators
+ * Validation functions for numeric inputs
+ */
+
+import type { ValidationResult } from "./core";
+
+/**
+ * Validates a rating value (1-5)
+ */
+export const validateRating = (rating: number): ValidationResult => {
+  if (rating < 1 || rating > 5) {
+    return { isValid: false, error: "Rating must be between 1 and 5" };
+  }
+  return { isValid: true };
+};
+
+/**
+ * Validates a number is within a range
+ */
+export const validateRange = (
+  value: number,
+  min: number,
+  max: number,
+  fieldName?: string
+): ValidationResult => {
+  if (value < min || value > max) {
+    return {
+      isValid: false,
+      error: `${fieldName || "Value"} must be between ${min} and ${max}`,
+    };
+  }
+  return { isValid: true };
+};
+
+/**
+ * Validates a positive number
+ */
+export const validatePositiveNumber = (
+  value: number,
+  fieldName?: string
+): ValidationResult => {
+  if (value <= 0) {
+    return {
+      isValid: false,
+      error: `${fieldName || "Value"} must be greater than 0`,
+    };
+  }
+  return { isValid: true };
+};
+
+/**
+ * Validates a non-negative number
+ */
+export const validateNonNegativeNumber = (
+  value: number,
+  fieldName?: string
+): ValidationResult => {
+  if (value < 0) {
+    return {
+      isValid: false,
+      error: `${fieldName || "Value"} must be 0 or greater`,
+    };
+  }
+  return { isValid: true };
+};

package/src/infrastructure/utils/validation/passwordValidator.ts

@@ -0,0 +1,53 @@
+/**
+ * Password Validator
+ * Password-specific validation logic
+ */
+
+import type { ValidationResult, PasswordValidationOptions } from "./core";
+
+/**
+ * Validates a password
+ */
+export const validatePassword = (
+  password: string,
+  options: PasswordValidationOptions = {}
+): ValidationResult => {
+  const {
+    minLength = 8,
+    requireUppercase = false,
+    requireLowercase = false,
+    requireNumber = false,
+    requireSpecialChar = false,
+  } = options;
+
+  const errors: string[] = [];
+
+  if (password.length < minLength) {
+    errors.push(`at least ${minLength} characters`);
+  }
+
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    errors.push("one uppercase letter");
+  }
+
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    errors.push("one lowercase letter");
+  }
+
+  if (requireNumber && !/\d/.test(password)) {
+    errors.push("one number");
+  }
+
+  if (requireSpecialChar && !/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password)) {
+    errors.push("one special character");
+  }
+
+  if (errors.length > 0) {
+    return {
+      isValid: false,
+      error: `Password must contain ${errors.join(", ")}`,
+    };
+  }
+
+  return { isValid: true };
+};