@umituz/react-native-design-system 4.25.8 → 4.25.9

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

@@ -1,116 +0,0 @@
-/**
- * Sharing Domain - useSharing Hook
- *
- * React hook for sharing files.
- * Provides system share sheet functionality with state management.
- *
- * @domain sharing
- * @layer presentation/hooks
- */
-
-import { useCallback, useMemo } from 'react';
-import { SharingService } from '../../infrastructure/services/SharingService';
-import type { ShareOptions } from '../../domain/entities/Share';
-import { useAsyncOperation } from '../../../../utils/hooks';
-
-/**
- * useSharing hook for sharing files via system share sheet
- */
-export const useSharing = () => {
-  // Check availability on mount
-  const availabilityOp = useAsyncOperation<boolean, string>(
-    () => SharingService.isAvailable(),
-    {
-      immediate: true,
-      initialData: false,
-      errorHandler: () => 'Failed to check sharing availability',
-    }
-  );
-
-  // Share operations
-  const shareOp = useAsyncOperation<boolean, string>(
-    async (uri: string, options?: ShareOptions) => {
-      const result = await SharingService.shareFile(uri, options);
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to share file');
-      }
-      return true;
-    },
-    {
-      immediate: false,
-      errorHandler: (err) => err instanceof Error ? err.message : 'Failed to share file',
-    }
-  );
-
-  const shareWithAutoTypeOp = useAsyncOperation<boolean, string>(
-    async (uri: string, filename: string, dialogTitle?: string) => {
-      const result = await SharingService.shareWithAutoType(uri, filename, dialogTitle);
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to share file');
-      }
-      return true;
-    },
-    {
-      immediate: false,
-      errorHandler: (err) => err instanceof Error ? err.message : 'Failed to share file',
-    }
-  );
-
-  const shareMultipleOp = useAsyncOperation<boolean, string>(
-    async (uris: string[], options?: ShareOptions) => {
-      const result = await SharingService.shareMultipleFiles(uris, options);
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to share files');
-      }
-      return true;
-    },
-    {
-      immediate: false,
-      errorHandler: (err) => err instanceof Error ? err.message : 'Failed to share files',
-    }
-  );
-
-  const share = useCallback(
-    async (uri: string, options?: ShareOptions): Promise<boolean> => {
-      const result = await shareOp.execute(uri, options);
-      return result ?? false;
-    },
-    [shareOp]
-  );
-
-  const shareWithAutoType = useCallback(
-    async (uri: string, filename: string, dialogTitle?: string): Promise<boolean> => {
-      const result = await shareWithAutoTypeOp.execute(uri, filename, dialogTitle);
-      return result ?? false;
-    },
-    [shareWithAutoTypeOp]
-  );
-
-  const shareMultiple = useCallback(
-    async (uris: string[], options?: ShareOptions): Promise<boolean> => {
-      const result = await shareMultipleOp.execute(uris, options);
-      return result ?? false;
-    },
-    [shareMultipleOp]
-  );
-
-  return useMemo(() => ({
-    share,
-    shareWithAutoType,
-    shareMultiple,
-    isAvailable: availabilityOp.data ?? false,
-    isSharing: shareOp.isLoading || shareWithAutoTypeOp.isLoading || shareMultipleOp.isLoading,
-    error: shareOp.error || shareWithAutoTypeOp.error || shareMultipleOp.error,
-  }), [
-    share,
-    shareWithAutoType,
-    shareMultiple,
-    availabilityOp.data,
-    shareOp.isLoading,
-    shareWithAutoTypeOp.isLoading,
-    shareMultipleOp.isLoading,
-    shareOp.error,
-    shareWithAutoTypeOp.error,
-    shareMultipleOp.error,
-  ]);
-};

package/src/utils/colorMapper.ts

@@ -1,193 +0,0 @@
-/**
- * Color Mapper Utility
- * Centralized color mapping logic for consistent theming
- */
-
-import type { DesignTokens } from '../theme';
-
-/**
- * Standard color variants available in the design system
- */
-export type ColorVariant =
-  | 'primary'
-  | 'secondary'
-  | 'tertiary'
-  | 'success'
-  | 'warning'
-  | 'error'
-  | 'info'
-  | 'surface'
-  | 'background'
-  | 'text'
-  | 'border'
-  | 'disabled';
-
-/**
- * Color intensity levels
- */
-export type ColorIntensity = 'primary' | 'secondary' | 'light' | 'dark';
-
-/**
- * Maps a color variant to actual color value from tokens
- *
- * @param variant - Color variant to map
- * @param tokens - Design tokens containing color definitions
- * @param intensity - Optional color intensity level
- * @returns Hex color string
- */
-export function mapColorVariant(
-  variant: ColorVariant,
-  tokens: DesignTokens,
-  intensity: ColorIntensity = 'primary'
-): string {
-  const colors = tokens.colors as any;
-
-  const colorMap: Record<ColorVariant, Record<ColorIntensity, string>> = {
-    primary: {
-      primary: colors.primary,
-      secondary: colors.primarySecondary || colors.primary,
-      light: colors.primaryLight || colors.primary,
-      dark: colors.primaryDark || colors.primary,
-    },
-    secondary: {
-      primary: colors.secondary,
-      secondary: colors.secondarySecondary || colors.secondary,
-      light: colors.secondaryLight || colors.secondary,
-      dark: colors.secondaryDark || colors.secondary,
-    },
-    tertiary: {
-      primary: colors.tertiary || colors.primary,
-      secondary: colors.tertiary || colors.primary,
-      light: colors.tertiary || colors.primary,
-      dark: colors.tertiary || colors.primary,
-    },
-    success: {
-      primary: colors.success || '#4CAF50',
-      secondary: colors.successSecondary || '#81C784',
-      light: colors.successLight || '#A5D6A7',
-      dark: colors.successDark || '#388E3C',
-    },
-    warning: {
-      primary: colors.warning || '#FF9800',
-      secondary: colors.warningSecondary || '#FFB74D',
-      light: colors.warningLight || '#FFCC80',
-      dark: colors.warningDark || '#F57C00',
-    },
-    error: {
-      primary: colors.error || '#F44336',
-      secondary: colors.errorSecondary || '#E57373',
-      light: colors.errorLight || '#EF9A9A',
-      dark: colors.errorDark || '#D32F2F',
-    },
-    info: {
-      primary: colors.info || '#2196F3',
-      secondary: colors.infoSecondary || '#64B5F6',
-      light: colors.infoLight || '#90CAF9',
-      dark: colors.infoDark || '#1976D2',
-    },
-    surface: {
-      primary: colors.surface,
-      secondary: colors.surfaceSecondary || colors.surface,
-      light: colors.surfaceLight || colors.surface,
-      dark: colors.surfaceDark || colors.surface,
-    },
-    background: {
-      primary: colors.backgroundPrimary,
-      secondary: colors.backgroundSecondary || colors.backgroundPrimary,
-      light: colors.backgroundLight || colors.backgroundPrimary,
-      dark: colors.backgroundDark || colors.backgroundPrimary,
-    },
-    text: {
-      primary: colors.textPrimary,
-      secondary: colors.textSecondary,
-      light: colors.textLight || colors.textPrimary,
-      dark: colors.textDark || colors.textPrimary,
-    },
-    border: {
-      primary: colors.borderLight,
-      secondary: colors.borderMedium || colors.borderLight,
-      light: colors.borderLight,
-      dark: colors.borderDark || colors.borderLight,
-    },
-    disabled: {
-      primary: colors.disabled || colors.textSecondary,
-      secondary: colors.disabledSecondary || colors.disabled || colors.textSecondary,
-      light: colors.disabledLight || colors.disabled || colors.textSecondary,
-      dark: colors.disabledDark || colors.disabled || colors.textSecondary,
-    },
-  };
-
-  return colorMap[variant]?.[intensity] || colors.primary;
-}
-
-/**
- * Creates a color mapping object for components
- * Useful for icon colors, button colors, etc.
- *
- * @param tokens - Design tokens
- * @param colorKeys - Array of color keys to map
- * @returns Object mapping color keys to values
- */
-export function createColorMap(
-  tokens: DesignTokens,
-  colorKeys: ColorVariant[]
-): Record<string, string> {
-  const colorMap: Record<string, string> = {};
-
-  colorKeys.forEach((key) => {
-    colorMap[key] = mapColorVariant(key, tokens);
-  });
-
-  return colorMap;
-}
-
-/**
- * Gets text color based on background color for contrast
- *
- * @param backgroundColor - Background color hex value
- * @returns Appropriate text color (light or dark)
- */
-export function getContrastTextColor(backgroundColor: string): string {
-  const hex = backgroundColor.replace('#', '');
-  const r = parseInt(hex.substr(0, 2), 16);
-  const g = parseInt(hex.substr(2, 2), 16);
-  const b = parseInt(hex.substr(4, 2), 16);
-
-  // Calculate luminance
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
-
-  return luminance > 0.5 ? '#000000' : '#FFFFFF';
-}
-
-/**
- * Checks if a color is light
- *
- * @param color - Hex color string
- * @returns True if color is light
- */
-export function isLightColor(color: string): boolean {
-  const hex = color.replace('#', '');
-  const r = parseInt(hex.substr(0, 2), 16);
-  const g = parseInt(hex.substr(2, 2), 16);
-  const b = parseInt(hex.substr(4, 2), 16);
-
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
-
-  return luminance > 0.5;
-}
-
-/**
- * Adjusts color opacity
- *
- * @param color - Hex color string
- * @param opacity - Opacity value (0-1)
- * @returns RGBA color string
- */
-export function adjustColorOpacity(color: string, opacity: number): string {
-  const hex = color.replace('#', '');
-  const r = parseInt(hex.substr(0, 2), 16);
-  const g = parseInt(hex.substr(2, 2), 16);
-  const b = parseInt(hex.substr(4, 2), 16);
-
-  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
-}

package/src/utils/errors/adapters/CacheErrorAdapter.ts

@@ -1,68 +0,0 @@
-/**
- * Cache Error Adapter
- *
- * Adapts cache errors to unified DesignSystemError format.
- * Maintains backward compatibility with CacheError.
- */
-
-import { DesignSystemError, ErrorCodes, ErrorCategory } from '../DesignSystemError';
-import type { ErrorMetadata } from '../DesignSystemError';
-import { CacheError } from '../../../storage/cache/domain/ErrorHandler';
-
-export class CacheErrorAdapter {
-  /**
-   * Create a DesignSystemError for cache operations
-   */
-  static create(message: string, context: string, cause?: unknown): DesignSystemError {
-    const metadata: ErrorMetadata = {
-      category: ErrorCategory.CACHE,
-      operation: context,
-      cause,
-      retryable: true,
-    };
-
-    return new DesignSystemError(
-      `${context}: ${message}`,
-      ErrorCodes.CACHE_ERROR,
-      { context },
-      metadata
-    );
-  }
-
-  /**
-   * Convert legacy CacheError to DesignSystemError
-   */
-  static fromCacheError(error: CacheError): DesignSystemError {
-    return new DesignSystemError(
-      error.message,
-      ErrorCodes.CACHE_ERROR,
-      { cacheErrorCode: error.code },
-      {
-        category: ErrorCategory.CACHE,
-        retryable: true,
-      }
-    );
-  }
-
-  /**
-   * Handle with timeout (replaces cache ErrorHandler.withTimeout)
-   */
-  static async withTimeout<T>(
-    promise: Promise<T>,
-    timeoutMs: number,
-    context: string
-  ): Promise<T> {
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
-        reject(
-          this.create(
-            `Operation timed out after ${timeoutMs}ms`,
-            context
-          )
-        );
-      }, timeoutMs);
-    });
-
-    return Promise.race([promise, timeoutPromise]);
-  }
-}

package/src/utils/errors/adapters/ImageErrorAdapter.ts

@@ -1,91 +0,0 @@
-/**
- * Image Error Adapter
- *
- * Adapts image errors to unified DesignSystemError format.
- * Maintains backward compatibility with ImageError.
- */
-
-import { DesignSystemError, ErrorCodes, ErrorCategory } from '../DesignSystemError';
-import type { ErrorMetadata } from '../DesignSystemError';
-import {
-  ImageError,
-  IMAGE_ERROR_CODES,
-  type ImageErrorCode,
-} from '../../../image/infrastructure/utils/ImageErrorHandler';
-
-export class ImageErrorAdapter {
-  /**
-   * Map ImageErrorCode to DesignSystemError code
-   */
-  private static mapErrorCode(code: ImageErrorCode): string {
-    switch (code) {
-      case IMAGE_ERROR_CODES.INVALID_URI:
-      case IMAGE_ERROR_CODES.INVALID_DIMENSIONS:
-      case IMAGE_ERROR_CODES.INVALID_QUALITY:
-      case IMAGE_ERROR_CODES.VALIDATION_ERROR:
-        return ErrorCodes.VALIDATION_ERROR;
-
-      case IMAGE_ERROR_CODES.MANIPULATION_FAILED:
-      case IMAGE_ERROR_CODES.CONVERSION_FAILED:
-        return ErrorCodes.IMAGE_LOAD_ERROR;
-
-      case IMAGE_ERROR_CODES.STORAGE_FAILED:
-        return ErrorCodes.STORAGE_ERROR;
-
-      default:
-        return ErrorCodes.UNKNOWN_ERROR;
-    }
-  }
-
-  /**
-   * Create a DesignSystemError for image operations
-   */
-  static create(
-    message: string,
-    code: ImageErrorCode,
-    operation?: string
-  ): DesignSystemError {
-    const metadata: ErrorMetadata = {
-      category: ErrorCategory.IMAGE,
-      operation,
-      retryable: code === IMAGE_ERROR_CODES.MANIPULATION_FAILED,
-    };
-
-    return new DesignSystemError(
-      message,
-      this.mapErrorCode(code),
-      { imageErrorCode: code, operation },
-      metadata
-    );
-  }
-
-  /**
-   * Convert legacy ImageError to DesignSystemError
-   */
-  static fromImageError(error: ImageError): DesignSystemError {
-    return this.create(error.message, error.code as ImageErrorCode, error.operation);
-  }
-
-  /**
-   * Handle unknown image errors
-   */
-  static handleUnknown(error: unknown, operation?: string): DesignSystemError {
-    if (error instanceof ImageError) {
-      return this.fromImageError(error);
-    }
-
-    const message = error instanceof Error ? error.message : 'Unknown image error occurred';
-
-    return new DesignSystemError(
-      message,
-      ErrorCodes.IMAGE_LOAD_ERROR,
-      { operation },
-      {
-        category: ErrorCategory.IMAGE,
-        operation,
-        cause: error,
-        retryable: true,
-      }
-    );
-  }
-}

package/src/utils/errors/adapters/StorageErrorAdapter.ts

@@ -1,107 +0,0 @@
-/**
- * Storage Error Adapter
- *
- * Adapts storage errors to unified DesignSystemError format.
- * Maintains backward compatibility with StorageError hierarchy.
- */
-
-import { DesignSystemError, ErrorCodes, ErrorCategory } from '../DesignSystemError';
-import type { ErrorMetadata } from '../DesignSystemError';
-import {
-  StorageError,
-  StorageReadError,
-  StorageWriteError,
-  StorageDeleteError,
-  StorageSerializationError,
-  StorageDeserializationError,
-} from '../../../storage/domain/errors/StorageError';
-
-export class StorageErrorAdapter {
-  /**
-   * Create a DesignSystemError for storage read failures
-   */
-  static readError(key: string, cause?: unknown): DesignSystemError {
-    const metadata: ErrorMetadata = {
-      category: ErrorCategory.STORAGE,
-      operation: 'read',
-      key,
-      cause,
-      retryable: true,
-    };
-
-    return new DesignSystemError(
-      `Failed to read from storage: ${key}`,
-      ErrorCodes.STORAGE_ERROR,
-      { key },
-      metadata
-    );
-  }
-
-  /**
-   * Create a DesignSystemError for storage write failures
-   */
-  static writeError(key: string, cause?: unknown): DesignSystemError {
-    const metadata: ErrorMetadata = {
-      category: ErrorCategory.STORAGE,
-      operation: 'write',
-      key,
-      cause,
-      retryable: true,
-    };
-
-    return new DesignSystemError(
-      `Failed to write to storage: ${key}`,
-      ErrorCodes.STORAGE_ERROR,
-      { key },
-      metadata
-    );
-  }
-
-  /**
-   * Create a DesignSystemError for storage delete failures
-   */
-  static deleteError(key: string, cause?: unknown): DesignSystemError {
-    const metadata: ErrorMetadata = {
-      category: ErrorCategory.STORAGE,
-      operation: 'delete',
-      key,
-      cause,
-      retryable: true,
-    };
-
-    return new DesignSystemError(
-      `Failed to delete from storage: ${key}`,
-      ErrorCodes.STORAGE_ERROR,
-      { key },
-      metadata
-    );
-  }
-
-  /**
-   * Convert legacy StorageError to DesignSystemError
-   */
-  static fromStorageError(error: StorageError): DesignSystemError {
-    let operation = 'unknown';
-
-    if (error instanceof StorageReadError) operation = 'read';
-    else if (error instanceof StorageWriteError) operation = 'write';
-    else if (error instanceof StorageDeleteError) operation = 'delete';
-    else if (error instanceof StorageSerializationError) operation = 'serialize';
-    else if (error instanceof StorageDeserializationError) operation = 'deserialize';
-
-    const cause = 'cause' in error ? error.cause : undefined;
-
-    return new DesignSystemError(
-      error.message,
-      ErrorCodes.STORAGE_ERROR,
-      { key: error.key },
-      {
-        category: ErrorCategory.STORAGE,
-        operation,
-        key: error.key,
-        cause,
-        retryable: true,
-      }
-    );
-  }
-}

package/src/utils/formatHelper.ts

@@ -1,16 +0,0 @@
-/**
- * Format Helper Utility
- * Common formatting functions for dates, numbers, currency, etc.
- *
- * This file re-exports all formatting utilities for convenience
- */
-
-// Date formatting
-export * from './formatters/dateFormatter';
-
-// Number, currency, percent formatting
-export * from './formatters/numberFormatter';
-
-// String, phone, file size formatting
-export * from './formatters/stringFormatter';
-

package/src/utils/formatters/dateFormatter.ts

@@ -1,64 +0,0 @@
-/**
- * Date Formatter Utility
- * Date and time formatting functions
- */
-
-/**
- * Date formatting options
- */
-export interface DateFormatOptions {
-  format?: 'short' | 'medium' | 'long' | 'full' | 'relative';
-  locale?: string;
-  includeTime?: boolean;
-}
-
-/**
- * Formats a date according to the specified options
- *
- * @param date - Date to format
- * @param options - Formatting options
- * @returns Formatted date string
- */
-export function formatDate(date: Date | string | number, options: DateFormatOptions = {}): string {
-  const {
-    format = 'medium',
-    locale = 'en-US',
-    includeTime = false,
-  } = options;
-
-  const dateObj = typeof date === 'string' || typeof date === 'number'
-    ? new Date(date)
-    : date;
-
-  if (isNaN(dateObj.getTime())) {
-    return 'Invalid Date';
-  }
-
-  const now = new Date();
-  const diffMs = now.getTime() - dateObj.getTime();
-  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-
-  // Relative date formatting for recent dates
-  if (format === 'relative') {
-    if (diffDays === 0) return 'Today';
-    if (diffDays === 1) return 'Yesterday';
-    if (diffDays === -1) return 'Tomorrow';
-    if (diffDays < -1 && diffDays > -7) return `${Math.abs(diffDays)} days from now`;
-    if (diffDays > 1 && diffDays < 7) return `${diffDays} days ago`;
-  }
-
-  const dateStyle = format === 'short' ? 'short' :
-                    format === 'long' ? 'long' :
-                    format === 'full' ? 'full' : 'medium';
-
-  if (includeTime) {
-    return new Intl.DateTimeFormat(locale, {
-      dateStyle,
-      timeStyle: 'short',
-    }).format(dateObj);
-  }
-
-  return new Intl.DateTimeFormat(locale, {
-    dateStyle,
-  }).format(dateObj);
-}