@umituz/react-native-design-system 4.23.113 → 4.23.115

package/src/theme/infrastructure/stores/themeStore.ts

@@ -20,6 +20,8 @@ interface ThemeState {
   defaultThemeMode: ThemeMode;
   isDark: boolean;
   isInitialized: boolean;
+  _updateInProgress: boolean;
+  _initInProgress: boolean;
 }
 
 interface ThemeActions {
@@ -32,9 +34,6 @@ interface ThemeActions {
   initialize: () => Promise<void>;
 }
 
-let themeUpdateInProgress = false;
-let themeInitInProgress = false;
-
 export const useTheme = createStore<ThemeState, ThemeActions>({
   name: 'theme-store',
   initialState: {
@@ -45,14 +44,16 @@ export const useTheme = createStore<ThemeState, ThemeActions>({
     defaultThemeMode: 'dark',
     isDark: true,
     isInitialized: false,
+    _updateInProgress: false,
+    _initInProgress: false,
   },
   persist: false,
   actions: (set, get) => ({
     initialize: async () => {
-      const { isInitialized, customColors: currentColors, defaultThemeMode } = get();
-      if (isInitialized || themeInitInProgress) return;
+      const { isInitialized, _initInProgress, customColors: currentColors, defaultThemeMode } = get();
+      if (isInitialized || _initInProgress) return;
 
-      themeInitInProgress = true;
+      set({ _initInProgress: true });
 
       try {
         const [savedMode, savedColors] = await Promise.all([
@@ -77,16 +78,17 @@ export const useTheme = createStore<ThemeState, ThemeActions>({
         dsTheme.setThemeMode(mode);
         dsTheme.setCustomColors(colors);
       } catch {
-        set({ isInitialized: true });
+        set({ isInitialized: true, _initInProgress: false });
         useDesignSystemTheme.getState().setThemeMode(defaultThemeMode);
       } finally {
-        themeInitInProgress = false;
+        set({ _initInProgress: false });
       }
     },
 
     setThemeMode: async (mode: ThemeMode) => {
-      if (themeUpdateInProgress) return;
-      themeUpdateInProgress = true;
+      const { _updateInProgress } = get();
+      if (_updateInProgress) return;
+      set({ _updateInProgress: true });
 
       try {
         const theme = mode === 'light' ? lightTheme : darkTheme;
@@ -96,7 +98,7 @@ export const useTheme = createStore<ThemeState, ThemeActions>({
       } catch {
         // Silent failure
       } finally {
-        themeUpdateInProgress = false;
+        set({ _updateInProgress: false });
       }
     },
 

package/src/timezone/infrastructure/services/BusinessCalendarManager.ts

@@ -4,6 +4,7 @@
  * Business date utilities for work days and month boundaries
  * Handles weekend detection and business day calculations
  */
+import { parseDate } from '../utils/TimezoneParsers';
 
 export class BusinessCalendarManager {
   /**

package/src/timezone/infrastructure/services/CalendarManager.ts

@@ -1,4 +1,5 @@
 import { TimezoneCalendarDay } from '../../domain/entities/Timezone';
+import { parseDate } from '../utils/TimezoneParsers';
 
 /**
  * CalendarManager
@@ -123,8 +124,7 @@ export class CalendarManager {
     }
 
     parse(date: Date | string | number): Date {
-        if (date instanceof Date) return new Date(date.getTime());
-        return new Date(date);
+        return parseDate(date);
     }
 
     isValid(date: Date | string | number): boolean {

package/src/timezone/infrastructure/services/DateComparisonUtils.ts

@@ -4,6 +4,7 @@
  * Precise date comparison utilities and relative time formatting
  * Handles hour/minute precision comparisons and "from now" formatting
  */
+import { parseDate } from '../utils/TimezoneParsers';
 
 export class DateComparisonUtils {
   /**

package/src/timezone/infrastructure/services/DateFormatter.ts

@@ -2,6 +2,8 @@
  * DateFormatter
  * Handles locale-aware formatting of dates and times
  */
+import { parseDate } from '../utils/TimezoneParsers';
+
 export class DateFormatter {
     formatDate(
         date: Date | string | number,
@@ -98,8 +100,7 @@ export class DateFormatter {
     }
 
     parse(date: Date | string | number): Date {
-        if (date instanceof Date) return new Date(date.getTime());
-        return new Date(date);
+        return parseDate(date);
     }
 
     formatDuration(milliseconds: number): string {

package/src/timezone/infrastructure/services/DateRangeUtils.ts

@@ -4,6 +4,7 @@
  * Date range utilities for working with date intervals
  * Handles range generation, overlap detection, and clamping
  */
+import { parseDate } from '../utils/TimezoneParsers';
 
 export class DateRangeUtils {
   /**

package/src/timezone/infrastructure/utils/TimezoneParsers.ts

@@ -0,0 +1,27 @@
+/**
+ * Timezone Parsers Utility
+ *
+ * Shared parsing functions for timezone services.
+ * Extracted from duplicate methods across DateFormatter, CalendarManager,
+ * BusinessCalendarManager, DateRangeUtils, and DateComparisonUtils.
+ */
+
+/**
+ * Parse date from various input types
+ * Ensures a Date object is returned from Date, string, or number input
+ */
+export function parseDate(date: Date | string | number): Date {
+    if (date instanceof Date) return new Date(date.getTime());
+    return new Date(date);
+}
+
+/**
+ * Parse timezone offset string to number
+ * @param offset - Offset string (e.g., "+05:30", "-08:00")
+ * @returns Offset in minutes
+ */
+export function parseTimezoneOffset(offset: string): number {
+    const sign = offset[0] === '-' ? -1 : 1;
+    const [hours, minutes] = offset.slice(1).split(':').map(Number);
+    return sign * (hours * 60 + (minutes || 0));
+}

package/src/utilities/sharing/presentation/hooks/useSharing.ts

@@ -8,7 +8,7 @@
  * @layer presentation/hooks
  */
 
-import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
 import { SharingService } from '../../infrastructure/services/SharingService';
 import type { ShareOptions } from '../../domain/entities/Share';
 
@@ -47,29 +47,40 @@ export const useSharing = () => {
   const [isSharing, setIsSharing] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
+  // Track mounted state to prevent setState on unmounted component
+  const isMountedRef = useRef(true);
+
   /**
    * Check sharing availability on mount
    */
   useEffect(() => {
     const checkAvailability = async () => {
       const available = await SharingService.isAvailable();
-      setIsAvailable(available);
+      if (isMountedRef.current) {
+        setIsAvailable(available);
+      }
     };
 
     checkAvailability();
+
+    return () => {
+      isMountedRef.current = false;
+    };
   }, []);
 
   /**
    * Share a file via system share sheet
    */
   const share = useCallback(async (uri: string, options?: ShareOptions): Promise<boolean> => {
-    setIsSharing(true);
-    setError(null);
+    if (isMountedRef.current) {
+      setIsSharing(true);
+      setError(null);
+    }
 
     try {
       const result = await SharingService.shareFile(uri, options);
 
-      if (!result.success) {
+      if (!result.success && isMountedRef.current) {
         setError(result.error || 'Failed to share file');
         return false;
       }
@@ -77,10 +88,14 @@ export const useSharing = () => {
       return true;
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : 'Failed to share file';
-      setError(errorMessage);
+      if (isMountedRef.current) {
+        setError(errorMessage);
+      }
       return false;
     } finally {
-      setIsSharing(false);
+      if (isMountedRef.current) {
+        setIsSharing(false);
+      }
     }
   }, []);
 
@@ -89,13 +104,15 @@ export const useSharing = () => {
    */
   const shareWithAutoType = useCallback(
     async (uri: string, filename: string, dialogTitle?: string): Promise<boolean> => {
-      setIsSharing(true);
-      setError(null);
+      if (isMountedRef.current) {
+        setIsSharing(true);
+        setError(null);
+      }
 
       try {
         const result = await SharingService.shareWithAutoType(uri, filename, dialogTitle);
 
-        if (!result.success) {
+        if (!result.success && isMountedRef.current) {
           setError(result.error || 'Failed to share file');
           return false;
         }
@@ -103,10 +120,14 @@ export const useSharing = () => {
         return true;
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : 'Failed to share file';
-        setError(errorMessage);
+        if (isMountedRef.current) {
+          setError(errorMessage);
+        }
         return false;
       } finally {
-        setIsSharing(false);
+        if (isMountedRef.current) {
+          setIsSharing(false);
+        }
       }
     },
     []
@@ -117,13 +138,15 @@ export const useSharing = () => {
    */
   const shareMultiple = useCallback(
     async (uris: string[], options?: ShareOptions): Promise<boolean> => {
-      setIsSharing(true);
-      setError(null);
+      if (isMountedRef.current) {
+        setIsSharing(true);
+        setError(null);
+      }
 
       try {
         const result = await SharingService.shareMultipleFiles(uris, options);
 
-        if (!result.success) {
+        if (!result.success && isMountedRef.current) {
           setError(result.error || 'Failed to share files');
           return false;
         }
@@ -131,10 +154,14 @@ export const useSharing = () => {
         return true;
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : 'Failed to share files';
-        setError(errorMessage);
+        if (isMountedRef.current) {
+          setError(errorMessage);
+        }
         return false;
       } finally {
-        setIsSharing(false);
+        if (isMountedRef.current) {
+          setIsSharing(false);
+        }
       }
     },
     []

package/src/utils/async/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Async Utilities
+ * Retry and timeout utilities for async operations
+ */
+
+export {
+  retryWithBackoff,
+  retryWithTimeout,
+  isNetworkError,
+  isRetryableHttpStatus,
+  type RetryOptions,
+} from './retryWithBackoff';

package/src/utils/async/retryWithBackoff.ts

@@ -0,0 +1,177 @@
+/**
+ * retryWithBackoff
+ *
+ * Retry utility with exponential backoff for async operations.
+ * Useful for network requests, file operations, etc.
+ */
+
+import { ErrorHandler } from '../errors/ErrorHandler';
+
+export interface RetryOptions {
+  /**
+   * Maximum number of retry attempts
+   * @default 3
+   */
+  maxRetries?: number;
+
+  /**
+   * Initial delay in milliseconds before first retry
+   * @default 1000
+   */
+  baseDelay?: number;
+
+  /**
+   * Maximum delay in milliseconds (caps exponential growth)
+   * @default 10000
+   */
+  maxDelay?: number;
+
+  /**
+   * Multiplier for exponential backoff
+   * @default 2
+   */
+  backoffMultiplier?: number;
+
+  /**
+   * Function to determine if error is retryable
+   * @default () => true (retry all errors)
+   */
+  shouldRetry?: (error: Error, attempt: number) => boolean;
+
+  /**
+   * Callback on each retry attempt
+   */
+  onRetry?: (error: Error, attempt: number, delay: number) => void;
+}
+
+/**
+ * Retry an async function with exponential backoff
+ *
+ * @example
+ * ```ts
+ * const result = await retryWithBackoff(
+ *   () => fetch('https://api.example.com'),
+ *   { maxRetries: 3, baseDelay: 1000 }
+ * );
+ * ```
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+): Promise<T> {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    maxDelay = 10000,
+    backoffMultiplier = 2,
+    shouldRetry = () => true,
+    onRetry,
+  } = options;
+
+  let lastError: Error;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      // Attempt the operation
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      // Check if we should retry
+      const isLastAttempt = attempt === maxRetries;
+      if (isLastAttempt || !shouldRetry(lastError, attempt)) {
+        throw lastError;
+      }
+
+      // Calculate delay with exponential backoff
+      const delay = Math.min(
+        baseDelay * Math.pow(backoffMultiplier, attempt),
+        maxDelay
+      );
+
+      // Call onRetry callback if provided
+      if (onRetry) {
+        onRetry(lastError, attempt + 1, delay);
+      }
+
+      // Log retry in development
+      if (__DEV__) {
+        console.log(
+          `[Retry] Attempt ${attempt + 1}/${maxRetries} failed. Retrying in ${delay}ms...`,
+          lastError.message
+        );
+      }
+
+      // Wait before retrying
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  // This should never be reached, but TypeScript needs it
+  throw lastError!;
+}
+
+/**
+ * Retry with timeout
+ * Combines retry logic with a timeout
+ *
+ * @example
+ * ```ts
+ * const result = await retryWithTimeout(
+ *   () => fetch('https://api.example.com'),
+ *   { timeout: 5000, maxRetries: 3 }
+ * );
+ * ```
+ */
+export async function retryWithTimeout<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions & { timeout?: number } = {}
+): Promise<T> {
+  const { timeout = 30000, ...retryOptions } = options;
+
+  return retryWithBackoff(
+    () => withTimeout(fn(), timeout),
+    retryOptions
+  );
+}
+
+/**
+ * Add timeout to a promise
+ */
+function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number
+): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) =>
+      setTimeout(
+        () => reject(new Error(`Operation timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      )
+    ),
+  ]);
+}
+
+/**
+ * Check if error is a network error
+ * Useful for shouldRetry callback
+ */
+export function isNetworkError(error: Error): boolean {
+  return (
+    error.message.includes('network') ||
+    error.message.includes('timeout') ||
+    error.message.includes('fetch') ||
+    error.message.includes('ECONNREFUSED') ||
+    error.message.includes('ETIMEDOUT')
+  );
+}
+
+/**
+ * Check if error is retryable HTTP status
+ * Useful for shouldRetry callback
+ */
+export function isRetryableHttpStatus(status: number): boolean {
+  // Retry on 5xx server errors and 429 (rate limit)
+  return status >= 500 || status === 429 || status === 408;
+}

package/src/utils/errors/DesignSystemError.ts

@@ -0,0 +1,117 @@
+/**
+ * DesignSystemError
+ *
+ * Unified error class for the design system package.
+ * Provides consistent error handling with error codes and context.
+ */
+
+export class DesignSystemError extends Error {
+  /**
+   * Error code for categorization
+   */
+  public readonly code: string;
+
+  /**
+   * Additional context about the error
+   */
+  public readonly context?: Record<string, any>;
+
+  /**
+   * Timestamp when error was created
+   */
+  public readonly timestamp: Date;
+
+  constructor(
+    message: string,
+    code: string,
+    context?: Record<string, any>
+  ) {
+    super(message);
+    this.name = 'DesignSystemError';
+    this.code = code;
+    this.context = context;
+    this.timestamp = new Date();
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, DesignSystemError);
+    }
+  }
+
+  /**
+   * Convert error to JSON for logging/debugging
+   */
+  toJSON(): Record<string, any> {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack,
+    };
+  }
+
+  /**
+   * Get user-friendly error message
+   */
+  getUserMessage(): string {
+    // You can customize user-facing messages based on error codes
+    switch (this.code) {
+      case 'FILE_NOT_FOUND':
+        return 'The requested file could not be found.';
+      case 'PERMISSION_DENIED':
+        return 'Permission denied. Please check app permissions.';
+      case 'NETWORK_ERROR':
+        return 'Network error. Please check your connection.';
+      case 'STORAGE_FULL':
+        return 'Storage is full. Please free up some space.';
+      case 'INVALID_INPUT':
+        return 'Invalid input provided.';
+      default:
+        return this.message;
+    }
+  }
+}
+
+/**
+ * Common error codes used across the design system
+ */
+export const ErrorCodes = {
+  // File system errors
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  FILE_READ_ERROR: 'FILE_READ_ERROR',
+  FILE_WRITE_ERROR: 'FILE_WRITE_ERROR',
+  FILE_DELETE_ERROR: 'FILE_DELETE_ERROR',
+  DIRECTORY_CREATE_ERROR: 'DIRECTORY_CREATE_ERROR',
+  PERMISSION_DENIED: 'PERMISSION_DENIED',
+  STORAGE_FULL: 'STORAGE_FULL',
+
+  // Network errors
+  NETWORK_ERROR: 'NETWORK_ERROR',
+  TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+  API_ERROR: 'API_ERROR',
+
+  // Media errors
+  MEDIA_PICKER_ERROR: 'MEDIA_PICKER_ERROR',
+  MEDIA_SAVE_ERROR: 'MEDIA_SAVE_ERROR',
+  IMAGE_LOAD_ERROR: 'IMAGE_LOAD_ERROR',
+
+  // Storage errors
+  CACHE_ERROR: 'CACHE_ERROR',
+  STORAGE_ERROR: 'STORAGE_ERROR',
+
+  // Validation errors
+  INVALID_INPUT: 'INVALID_INPUT',
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+
+  // Theme errors
+  THEME_LOAD_ERROR: 'THEME_LOAD_ERROR',
+  THEME_SAVE_ERROR: 'THEME_SAVE_ERROR',
+
+  // Generic errors
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+  INITIALIZATION_ERROR: 'INITIALIZATION_ERROR',
+} as const;
+
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];