@umituz/react-native-settings 5.2.34 → 5.2.36

package/src/domains/legal/presentation/components/index.ts

@@ -1,5 +0,0 @@
-export { LegalItem } from "./LegalItem";
-export { LegalLinks } from "./LegalLinks";
-export { LegalSection } from "./LegalSection";
-export { LegalScreenHeader } from "./LegalScreenHeader";
-export { LegalDocumentsList } from "./LegalDocumentsList";

package/src/domains/localization/infrastructure/config/languagesData.ts

@@ -1,26 +0,0 @@
-/**
- * Language Data Exports
- * Centralized exports for language management
- */
-
-import { languageRepository } from '../repository/LanguageRepository';
-import { DEFAULT_LANGUAGES } from './constants/defaultLanguages';
-import type { Language } from '../storage/types/Language';
-
-export { languageRepository };
-export { DEFAULT_LANGUAGES };
-export type { Language };
-
-export const getLanguageByCode = (code: string) =>
-  languageRepository.getLanguageByCode(code);
-
-export const searchLanguages = (query: string) =>
-  languageRepository.searchLanguages(query);
-
-export const isLanguageSupported = (code: string) =>
-  languageRepository.isLanguageSupported(code);
-
-export const getDefaultLanguage = () =>
-  languageRepository.getDefaultLanguage();
-
-export const LANGUAGES = languageRepository.getLanguages();

package/src/domains/localization/infrastructure/hooks/TranslationHook.ts

@@ -1,37 +0,0 @@
-/**
- * Translation Hook
- *
- * Provides translation function with fallback logic
- * - React i18next integration
- * - Direct i18n fallback
- * - Type-safe translation function
- */
-
-import { useTranslation } from 'react-i18next';
-import i18n from '../config/i18n';
-
-/**
- * Custom hook that provides translation function with proper fallbacks
- */
-export const useTranslationFunction = (): ((key: string, options?: Record<string, unknown>) => string) => {
-  // Always call useTranslation hook (React hooks rules)
-  const translationResult = useTranslation(undefined, { i18n });
-
-  // Use react-i18next if available, otherwise fallback to direct i18n
-  if (translationResult?.t && typeof translationResult.t === 'function' && i18n.isInitialized) {
-    return (key: string, options?: Record<string, unknown>): string => {
-      const result = translationResult.t(key, options);
-      return typeof result === 'string' ? result : String(result);
-    };
-  } else {
-    return (key: string, options?: Record<string, unknown>): string => {
-      // Fallback to direct i18n.t
-      if (i18n.isInitialized && typeof i18n.t === 'function') {
-        const result = i18n.t(key, options);
-        return typeof result === 'string' ? result : String(result);
-      }
-      // Final fallback: return key
-      return key;
-    };
-  }
-};

package/src/domains/localization/infrastructure/storage/AsyncStorageWrapper.ts

@@ -1,34 +0,0 @@
-/**
- * Storage Wrapper
- * Uses @umituz/react-native-design-system for persistence
- */
-
-import { storageRepository } from '@umituz/react-native-design-system';
-
-export const STORAGE_KEYS = {
-  LANGUAGE: '@localization:language',
-} as const;
-
-export const StorageWrapper = {
-  async getString(key: string, defaultValue: string): Promise<string> {
-    try {
-      const result = await storageRepository.getString(key, defaultValue);
-      if (result.success && result.data !== null) {
-        return result.data;
-      }
-      return defaultValue;
-    } catch (error) {
-      console.error('[StorageWrapper] Failed to get string:', key, error);
-      return defaultValue;
-    }
-  },
-
-  async setString(key: string, value: string): Promise<void> {
-    try {
-      await storageRepository.setString(key, value);
-    } catch (error) {
-      console.error('[StorageWrapper] Failed to set string:', key, error);
-      throw error;
-    }
-  },
-};

package/src/infrastructure/storage/storeConfig.ts

@@ -1,114 +0,0 @@
-/**
- * Store Configuration Standards
- * Standardized patterns for all Zustand stores
- *
- * Provides consistent configuration for:
- * - Persistence settings
- * - Version management
- * - State partializing (excluding transient state)
- * - Storage service integration
- */
-
-import type { StateStorage } from 'zustand/middleware';
-import { storageService } from '@umituz/react-native-design-system';
-
-/**
- * Standard store configuration interface
- */
-export interface StandardStoreConfig<T> {
-  /** Unique storage key name */
-  name: string;
-  /** Store version for migrations */
-  version: number;
-  /** Enable persistence */
-  persist: boolean;
-  /** Custom partialize function to control what gets persisted */
-  partialize?: (state: T) => Partial<T>;
-  /** Storage service (defaults to design-system's storageService) */
-  storage?: StateStorage;
-}
-
-/**
- * Create standardized store configuration
- *
- * @param config - Store configuration
- * @returns Complete store config with defaults
- *
- * @example
- * ```typescript
- * const config = createStoreConfig({
- *   name: 'my-store',
- *   version: 1,
- *   persist: true,
- *   partialize: excludeTransientState,
- * });
- * ```
- */
-export const createStoreConfig = <T extends object>(
-  config: StandardStoreConfig<T>
-): Required<StandardStoreConfig<T>> => {
-  return {
-    name: config.name,
-    version: config.version,
-    persist: config.persist,
-    partialize: config.partialize || ((state) => state),
-    storage: config.storage || storageService,
-  };
-};
-
-/**
- * Base interface for store state with transient flags
- */
-export interface BaseStoreState {
-  /** Loading state (never persisted) */
-  isLoading?: boolean;
-  /** Initialization state (never persisted) */
-  isInitialized?: boolean;
-}
-
-/**
- * Standard partialize function that excludes loading/initialization flags
- * These flags are runtime state and should never be persisted
- *
- * @param state - Store state
- * @returns State with transient flags excluded
- *
- * @example
- * ```typescript
- * const config = createStoreConfig({
- *   name: 'my-store',
- *   version: 1,
- *   persist: true,
- *   partialize: excludeTransientState,
- * });
- * ```
- */
-export const excludeTransientState = <T extends BaseStoreState>(
-  state: T
-): Partial<T> => {
-  const { isLoading: _isLoading, isInitialized: _isInitialized, ...persistedState } = state;
-  return persistedState as Partial<T>;
-};
-
-/**
- * Create partialize function that excludes specific keys
- *
- * @param excludeKeys - Keys to exclude from persistence
- * @returns Partialize function
- *
- * @example
- * ```typescript
- * const partialize = createPartializeExcluding(['isLoading', 'error', 'tempData']);
- * ```
- */
-export const createPartializeExcluding = <T extends object>(
-  excludeKeys: (keyof T)[]
-) => {
-  return (state: T): Partial<T> => {
-    const result = { ...state };
-    excludeKeys.forEach((key) => {
-      delete result[key];
-    });
-    return result;
-  };
-};

package/src/infrastructure/types/commonComponentTypes.ts

@@ -1,142 +0,0 @@
-/**
- * Common Component Types
- * Shared interfaces for common component props to reduce duplication
- */
-
-import type { StyleProp, ViewStyle } from "react-native";
-import type { IconName } from "@umituz/react-native-design-system";
-
-/**
- * Base props for settings item components
- */
-export interface BaseSettingsItemProps {
-  title: string;
-  description?: string;
-  icon?: IconName;
-  onPress?: () => void;
-  disabled?: boolean;
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-}
-
-/**
- * Base props for card components
- */
-export interface BaseCardProps {
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-}
-
-/**
- * Base props for section components
- */
-export interface BaseSectionProps {
-  title?: string;
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-}
-
-/**
- * Navigation item props
- */
-export interface NavigationItemProps extends BaseSettingsItemProps {
-  route?: string;
-  showChevron?: boolean;
-}
-
-/**
- * Toggle item props (items with switches)
- */
-export interface ToggleItemProps extends BaseSettingsItemProps {
-  showSwitch: true;
-  switchValue: boolean;
-  onSwitchChange: (value: boolean) => void;
-}
-
-/**
- * Pressable item props
- */
-export interface PressableItemProps extends BaseSettingsItemProps {
-  onPress: () => void;
-}
-
-/**
- * Icon styling props
- */
-export interface IconStyleProps {
-  iconBgColor?: string;
-  iconColor?: string;
-  iconSize?: number;
-}
-
-/**
- * Loading state props
- */
-export interface LoadingStateProps {
-  loading?: boolean;
-}
-
-/**
- * Badge props (for notification counts, etc.)
- */
-export interface BadgeProps {
-  badge?: string | number;
-  badgeColor?: string;
-  badgeTextColor?: string;
-}
-
-/**
- * Screen header props
- */
-export interface ScreenHeaderProps {
-  title: string;
-  subtitle?: string;
-  showBackButton?: boolean;
-  onBackPress?: () => void;
-  rightElement?: React.ReactNode;
-  style?: StyleProp<ViewStyle>;
-}
-
-/**
- * List item props
- */
-export interface ListItemProps extends BaseSettingsItemProps {
-  rightElement?: React.ReactNode;
-  leftElement?: React.ReactNode;
-}
-
-/**
- * Modal props
- */
-export interface BaseModalProps {
-  visible: boolean;
-  onClose: () => void;
-  title?: string;
-  testID?: string;
-}
-
-/**
- * Form input props
- */
-export interface BaseInputProps {
-  value: string;
-  onChangeText: (text: string) => void;
-  placeholder?: string;
-  error?: string;
-  disabled?: boolean;
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-}
-
-/**
- * Button props
- */
-export interface BaseButtonProps {
-  title: string;
-  onPress: () => void;
-  disabled?: boolean;
-  loading?: boolean;
-  variant?: "primary" | "secondary" | "danger" | "ghost";
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-}

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

@@ -1,110 +0,0 @@
-/**
- * Core Async Operation Utilities
- * Base types and handlers for async operations
- */
-
-import type { ValidationResult } from "../validation";
-import { isDev } from '../../../utils/devUtils';
-
-/**
- * Result type for async operations
- */
-export type AsyncResult<T, E = Error> =
-  | { success: true; data: T }
-  | { success: false; error: E };
-
-/**
- * Generic async handler with error handling
- */
-export const handleAsyncOperation = async <T>(
-  operation: () => Promise<T>,
-  onError?: (error: Error) => void
-): Promise<AsyncResult<T>> => {
-  try {
-    const data = await operation();
-    return { success: true, data };
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    if (onError) {
-      onError(err);
-    }
-    return { success: false, error: err };
-  }
-};
-
-/**
- * Async operation with loading state
- * FIXED: Properly handles errors in onSuccess callback
- */
-export const createAsyncHandler = <T extends unknown[], R>(
-  handler: (...args: T) => Promise<R>,
-  options: {
-    onLoadingStart?: () => void;
-    onLoadingEnd?: () => void;
-    onError?: (error: Error) => void;
-    onSuccess?: (result: R) => void;
-  }
-) => {
-  return async (...args: T): Promise<void> => {
-    const { onLoadingStart, onLoadingEnd, onError, onSuccess } = options;
-
-    let loadingStarted = false;
-
-    try {
-      onLoadingStart?.();
-      loadingStarted = true;
-      const result = await handler(...args);
-      // FIXED: Wrap onSuccess in try-catch to handle errors separately
-      try {
-        onSuccess?.(result);
-      } catch (callbackError) {
-        // Log callback error but don't treat it as handler error
-        if (isDev()) {
-          console.error("[createAsyncHandler] onSuccess callback error:", callbackError);
-        }
-      }
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      onError?.(err);
-    } finally {
-      // FIXED: Only call onLoadingEnd if it was started
-      if (loadingStarted) {
-        try {
-          onLoadingEnd?.();
-        } catch (callbackError) {
-          // Log callback error but don't throw
-          if (isDev()) {
-            console.error("[createAsyncHandler] onLoadingEnd callback error:", callbackError);
-          }
-        }
-      }
-    }
-  };
-};
-
-/**
- * Async operation with validation
- */
-export const createValidatedAsyncHandler = <T, R>(
-  validator: (data: T) => ValidationResult,
-  handler: (data: T) => Promise<R>,
-  options: {
-    onValidationError?: (error: string) => void;
-    onError?: (error: Error) => void;
-  } = {}
-) => {
-  return async (data: T): Promise<AsyncResult<R>> => {
-    const { onValidationError, onError } = options;
-
-    // Validate first
-    const validationResult = validator(data);
-    if (!validationResult.isValid) {
-      const error = new Error(validationResult.error || "Validation failed");
-      onValidationError?.(error.message);
-      return { success: false, error };
-    }
-
-    // Execute handler
-    return handleAsyncOperation(() => handler(data), onError);
-  };
-};

package/src/infrastructure/utils/async/debounceAndBatch.ts

@@ -1,69 +0,0 @@
-/**
- * Debounce and Batch Utilities
- * Utilities for debouncing and batching async operations
- */
-
-import type { AsyncResult } from "./core";
-
-/**
- * Debounced async operation
- */
-export const createDebouncedAsyncOperation = <T extends unknown[], R>(
-  operation: (...args: T) => Promise<R>,
-  delayMs: number
-): ((...args: T) => Promise<R>) => {
-  let timeoutId: NodeJS.Timeout | null = null;
-
-  return (...args: T): Promise<R> => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-
-    return new Promise((resolve, reject) => {
-      timeoutId = setTimeout(async () => {
-        try {
-          const result = await operation(...args);
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      }, delayMs);
-    });
-  };
-};
-
-/**
- * Batch async operations
- */
-export const batchAsyncOperations = async <T, R>(
-  items: T[],
-  operation: (item: T) => Promise<R>,
-  options: {
-    concurrency?: number;
-    onProgress?: (completed: number, total: number) => void;
-  } = {}
-): Promise<AsyncResult<R[]>> => {
-  const { concurrency = 5, onProgress } = options;
-
-  try {
-    const results: R[] = [];
-    const batches: T[][] = [];
-
-    // Create batches
-    for (let i = 0; i < items.length; i += concurrency) {
-      batches.push(items.slice(i, i + concurrency));
-    }
-
-    // Process batches
-    for (const batch of batches) {
-      const batchResults = await Promise.all(batch.map(operation));
-      results.push(...batchResults);
-      onProgress?.(results.length, items.length);
-    }
-
-    return { success: true, data: results };
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    return { success: false, error: err };
-  }
-};

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

@@ -1,8 +0,0 @@
-/**
- * Async Utilities
- * Barrel export for all async utility modules
- */
-
-export * from "./core";
-export * from "./retryAndTimeout";
-export * from "./debounceAndBatch";

package/src/infrastructure/utils/async/retryAndTimeout.ts

@@ -1,65 +0,0 @@
-/**
- * Retry and Timeout Utilities
- * Utilities for handling retries and timeouts in async operations
- */
-
-/**
- * Retry utility for async operations
- */
-export const retryAsyncOperation = async <T>(
-  operation: () => Promise<T>,
-  options: {
-    maxAttempts?: number;
-    delayMs?: number;
-    backoffMultiplier?: number;
-    onRetry?: (attempt: number, error: Error) => void;
-  } = {}
-): Promise<T> => {
-  const {
-    maxAttempts = 3,
-    delayMs = 1000,
-    backoffMultiplier = 2,
-    onRetry,
-  } = options;
-
-  let lastError: Error | undefined;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-
-      if (attempt < maxAttempts) {
-        onRetry?.(attempt, lastError);
-        const delay = delayMs * Math.pow(backoffMultiplier, attempt - 1);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-
-  throw lastError || new Error("Operation failed after retries");
-};
-
-/**
- * Timeout wrapper for async operations
- */
-export const withTimeout = async <T>(
-  operation: Promise<T>,
-  timeoutMs: number,
-  timeoutMessage: string = "Operation timed out"
-): Promise<T> => {
-  let timeoutId: NodeJS.Timeout | undefined;
-
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    timeoutId = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
-  });
-
-  try {
-    return await Promise.race([operation, timeoutPromise]);
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  }
-};

package/src/infrastructure/utils/dateUtils.ts

@@ -1,61 +0,0 @@
-/**
- * Date Utilities
- *
- * Helper functions for date manipulation and calculations.
- */
-
-/**
- * Calculate days between two dates
- * @param dateString ISO date string
- * @param now Current date (defaults to new Date())
- * @returns Number of days between dates
- */
-export function daysBetween(dateString: string, now: Date = new Date()): number {
-  const date = new Date(dateString);
-  const diffMs = now.getTime() - date.getTime();
-  return Math.floor(diffMs / (1000 * 60 * 60 * 24));
-}
-
-/**
- * Format date to ISO string
- * @param date Date to format
- * @returns ISO date string
- */
-export function toISOString(date: Date = new Date()): string {
-  return date.toISOString();
-}
-
-/**
- * Check if a date is within the last N days
- * @param dateString ISO date string to check
- * @param days Number of days to check within
- * @returns true if date is within the last N days
- */
-export function isWithinLastDays(dateString: string, days: number): boolean {
-  const daysDiff = daysBetween(dateString);
-  return daysDiff >= 0 && daysDiff <= days;
-}
-
-/**
- * Check if a date has passed (is older than N days ago)
- * @param dateString ISO date string to check
- * @param days Number of days threshold
- * @returns true if date is older than N days
- */
-export function isOlderThanDays(dateString: string, days: number): boolean {
-  const daysDiff = daysBetween(dateString);
-  return daysDiff > days;
-}
-
-/**
- * Add days to a date
- * @param dateString ISO date string
- * @param days Number of days to add
- * @returns New date with days added
- */
-export function addDays(dateString: string, days: number): Date {
-  const date = new Date(dateString);
-  const result = new Date(date);
-  result.setDate(result.getDate() + days);
-  return result;
-}