@umituz/react-native-design-system 4.23.79 → 4.23.81

package/src/exception/infrastructure/services/ExceptionReporter.ts

@@ -1,134 +0,0 @@
-/**
- * Exception Reporter Service
- *
- * Handles reporting exceptions to external services.
- *
- * SOLID: Single Responsibility - Only exception reporting
- * DRY: Centralized reporting logic
- * KISS: Simple reporting interface
- */
-
-import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
-
-export interface ExceptionReporterConfig {
-  enabled: boolean;
-  endpoint?: string;
-  apiKey?: string;
-  environment: 'development' | 'staging' | 'production';
-}
-
-export class ExceptionReporter {
-  private config: ExceptionReporterConfig;
-
-  constructor(config: ExceptionReporterConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Report exception to external service
-   */
-  async reportException(exception: ExceptionEntity): Promise<boolean> {
-    if (!this.config.enabled) {
-      return false;
-    }
-
-    try {
-      // Default console reporting for development
-      if (this.config.environment === 'development') {
-        return this.reportToConsole(exception);
-      }
-
-      // External service reporting
-      if (this.config.endpoint) {
-        return await this.reportToExternalService(exception);
-      }
-
-      return false;
-    } catch (error) {
-      // Don't throw in reporter to avoid infinite loops
-      console.warn('Exception reporting failed:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Report to console (development)
-   */
-  private reportToConsole(exception: ExceptionEntity): boolean {
-    const level = this.getConsoleLevel(exception.severity);
-
-    console[level](
-      `[${exception.severity.toUpperCase()}] ${exception.category}:`,
-      exception.message,
-      {
-        id: exception.id,
-        timestamp: exception.timestamp,
-        context: exception.context,
-        stack: exception.stackTrace,
-      }
-    );
-
-    return true;
-  }
-
-  /**
-   * Report to external service
-   */
-  private async reportToExternalService(exception: ExceptionEntity): Promise<boolean> {
-    if (!this.config.endpoint) {
-      return false;
-    }
-
-    const response = await fetch(this.config.endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(this.config.apiKey && { 'Authorization': `Bearer ${this.config.apiKey}` }),
-      },
-      body: JSON.stringify({
-        id: exception.id,
-        message: exception.message,
-        severity: exception.severity,
-        category: exception.category,
-        timestamp: exception.timestamp,
-        context: exception.context,
-        stackTrace: exception.stackTrace,
-        environment: this.config.environment,
-      }),
-    });
-
-    return response.ok;
-  }
-
-  /**
-   * Get console level for severity
-   */
-  private getConsoleLevel(severity: ExceptionEntity['severity']): 'log' | 'warn' | 'error' {
-    switch (severity) {
-      case 'fatal':
-      case 'error':
-        return 'error';
-      case 'warning':
-        return 'warn';
-      default:
-        return 'log';
-    }
-  }
-
-  /**
-   * Update reporter configuration
-   */
-  updateConfig(config: Partial<ExceptionReporterConfig>): void {
-    this.config = { ...this.config, ...config };
-  }
-}
-
-
-
-
-
-
-
-
-
-

package/src/exception/infrastructure/services/ExceptionService.ts

@@ -1,166 +0,0 @@
-/**
- * Exception Service - Infrastructure Layer
- *
- * Facade for exception handling using composition.
- * Delegates to specialized services for specific operations.
- *
- * SOLID: Facade pattern - Single entry point, delegates to specialists
- * DRY: Avoids code duplication by composing smaller services
- * KISS: Simple interface, complex operations delegated
- */
-
-import type {
-  ExceptionEntity,
-  ExceptionContext,
-  ExceptionSeverity,
-  ExceptionCategory,
-} from '../../domain/entities/ExceptionEntity';
-import { ExceptionHandler } from './ExceptionHandler';
-import { ExceptionReporter } from './ExceptionReporter';
-import { ExceptionLogger } from './ExceptionLogger';
-import { useExceptionStore } from '../storage/ExceptionStore';
-
-export class ExceptionService {
-  private logger: ExceptionLogger | null = null;
-  private reporter: ExceptionReporter | null = null;
-  private reporterConfig: ExceptionReporter['config'];
-
-  constructor(reporterConfig?: ExceptionReporter['config']) {
-    this.reporterConfig = reporterConfig || {
-      enabled: false,
-      environment: 'development'
-    };
-  }
-
-  private ensureInitialized() {
-    if (!this.logger) {
-      this.logger = new ExceptionLogger();
-      this.reporter = new ExceptionReporter(this.reporterConfig);
-    }
-  }
-
-  /**
-   * Handle an exception
-   */
-  async handleException(
-    error: Error,
-    severity: ExceptionSeverity = 'error',
-    category: ExceptionCategory = 'unknown',
-    context: ExceptionContext = {},
-  ): Promise<void> {
-    this.ensureInitialized();
-
-    const exception = ExceptionHandler.createException(error, severity, category, context);
-
-    // Add to store
-    useExceptionStore.getState().addException(exception);
-
-    // Log locally
-    await this.logger!.logException(exception);
-
-    // Report to external service if needed
-    if (ExceptionHandler.shouldReportException(exception)) {
-      await this.reporter!.reportException(exception);
-    }
-
-    // Mark as handled
-    useExceptionStore.getState().markAsHandled(exception.id);
-  }
-
-  /**
-   * Handle network errors
-   */
-  async handleNetworkError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'error', 'network', context);
-  }
-
-  /**
-   * Handle validation errors
-   */
-  async handleValidationError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'warning', 'validation', context);
-  }
-
-  /**
-   * Handle authentication errors
-   */
-  async handleAuthError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'error', 'authentication', context);
-  }
-
-  /**
-   * Handle system errors
-   */
-  async handleSystemError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'fatal', 'system', context);
-  }
-
-  /**
-   * Get stored exceptions
-   */
-  async getStoredExceptions(): Promise<ExceptionEntity[]> {
-    this.ensureInitialized();
-    return this.logger!.getStoredExceptions();
-  }
-
-  /**
-   * Get exception statistics
-   */
-  async getExceptionStats() {
-    this.ensureInitialized();
-    return this.logger!.getExceptionStats();
-  }
-
-  /**
-   * Clear stored exceptions
-   */
-  async clearStoredExceptions(): Promise<void> {
-    this.ensureInitialized();
-    await this.logger!.clearStoredExceptions();
-  }
-
-  /**
-   * Update reporter configuration
-   */
-  updateReporterConfig(config: Partial<ExceptionReporter['config']>): void {
-    this.ensureInitialized();
-    this.reporter!.updateConfig(config);
-  }
-
-  /**
-   * Set max stored exceptions
-   */
-  setMaxStoredExceptions(limit: number): void {
-    this.ensureInitialized();
-    this.logger!.setMaxStoredExceptions(limit);
-  }
-
-  /**
-   * Handle storage/permission errors
-   */
-  async handleStorageError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'error', 'storage', context);
-  }
-
-  /**
-   * Handle fatal errors
-   */
-  async handleFatalError(error: Error, context: ExceptionContext = {}): Promise<void> {
-    await this.handleException(error, 'fatal', 'system', context);
-  }
-
-  /**
-   * Clear all exceptions
-   */
-  clearExceptions(): void {
-    useExceptionStore.getState().clearExceptions();
-  }
-}
-
-// Export default instance - lazy initialization
-export const exceptionService = new ExceptionService();
-
-
-
-
-

package/src/exception/infrastructure/storage/ExceptionStore.ts

@@ -1,44 +0,0 @@
-/**
- * Exception Store
- * Zustand store for exception state management
- */
-
-import { createStore } from '../../../storage';
-import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
-
-interface ExceptionState {
-    exceptions: ExceptionEntity[];
-}
-
-interface ExceptionActions {
-    addException: (exception: ExceptionEntity) => void;
-    clearExceptions: () => void;
-    markAsHandled: (id: string) => void;
-}
-
-export const useExceptionStore = createStore<ExceptionState, ExceptionActions>({
-    name: 'exception-store',
-    initialState: {
-        exceptions: [],
-    },
-    persist: false,
-    actions: (set: (state: Partial<ExceptionState>) => void, get: () => ExceptionState) => ({
-        addException: (exception: ExceptionEntity) =>
-            set({ exceptions: [...get().exceptions, exception] }),
-        clearExceptions: () => set({ exceptions: [] }),
-        markAsHandled: (id: string) =>
-            set({
-                exceptions: get().exceptions.map((e: ExceptionEntity) =>
-                    e.id === id ? { ...e, handled: true } : e
-                ),
-            }),
-    }),
-});
-
-/**
- * Hook to get exceptions from store
- */
-export const useExceptions = () => {
-    const exceptions = useExceptionStore((state: ExceptionState) => state.exceptions);
-    return exceptions;
-};

package/src/exception/presentation/components/ErrorBoundary.tsx

@@ -1,129 +0,0 @@
-/**
- * Error Boundary Component
- * React 19 compatible - Functional component with hooks
- */
-
-import React, { ReactNode, useState, useCallback } from 'react';
-import { View, StyleSheet, TouchableOpacity } from 'react-native';
-import { AtomicText } from '../../../atoms';
-import { exceptionService } from '../../infrastructure/services/ExceptionService';
-import { useAppDesignTokens } from '../../../theme';
-
-interface Props {
-  children: ReactNode;
-  fallback?: ReactNode;
-  onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
-}
-
-interface ErrorInfo {
-  error: Error;
-  componentStack: string | null;
-}
-
-export const ErrorBoundary: React.FC<Props> = ({
-  children,
-  fallback,
-  onError
-}) => {
-  const [errorState, setErrorState] = useState<{
-    hasError: boolean;
-    error: Error | null;
-  }>({
-    hasError: false,
-    error: null,
-  });
-
-  const tokens = useAppDesignTokens();
-
-  // Global error handler for React 19
-  useCallback((error: Error, errorInfo: React.ErrorInfo) => {
-    // Log error to exception service
-    exceptionService.handleFatalError(error, {
-      componentStack: errorInfo.componentStack ?? undefined,
-      screen: 'ErrorBoundary',
-    });
-
-    // Update state
-    setErrorState({
-      hasError: true,
-      error,
-    });
-
-    // Call external onError if provided
-    if (onError) {
-      onError(error, errorInfo);
-    }
-  }, [onError]);
-
-  // Reset error state
-  const resetError = useCallback(() => {
-    setErrorState({
-      hasError: false,
-      error: null,
-    });
-  }, []);
-
-  // If there's an error, render fallback
-  if (errorState.hasError) {
-    if (fallback) {
-      return <>{fallback}</>;
-    }
-
-    return (
-      <View style={[styles.container, { backgroundColor: tokens.colors.error.background }]}>
-        <View style={styles.content}>
-          <AtomicText variant="h3" style={styles.title}>
-            Something went wrong
-          </AtomicText>
-
-          {errorState.error && (
-            <AtomicText variant="body" style={styles.message}>
-              {errorState.error.message}
-            </AtomicText>
-          )}
-
-          <TouchableOpacity
-            style={[styles.button, { backgroundColor: tokens.colors.primary }]}
-            onPress={resetError}
-          >
-            <AtomicText variant="button" style={styles.buttonText}>
-              Try Again
-            </AtomicText>
-          </TouchableOpacity>
-        </View>
-      </View>
-    );
-  }
-
-  return <>{children}</>;
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-    padding: 20,
-  },
-  content: {
-    alignItems: 'center',
-    maxWidth: 400,
-  },
-  title: {
-    marginBottom: 10,
-    textAlign: 'center',
-  },
-  message: {
-    marginBottom: 20,
-    textAlign: 'center',
-    opacity: 0.7,
-  },
-  button: {
-    paddingHorizontal: 20,
-    paddingVertical: 12,
-    borderRadius: 8,
-  },
-  buttonText: {
-    color: '#fff',
-  },
-});

package/src/exception/presentation/components/ExceptionEmptyState.tsx

@@ -1,123 +0,0 @@
-/**
- * Empty State Component
- * Displays when no data is available
- *
- * Presentation Layer - UI Component
- */
-
-import React, { useMemo } from "react";
-import { View, StyleSheet, TouchableOpacity } from "react-native";
-import { AtomicIcon, AtomicText } from "../../../atoms";
-import { useAppDesignTokens } from "../../../theme";
-
-export interface ExceptionEmptyStateProps {
-  icon?: string;
-  title: string;
-  description?: string;
-  actionLabel?: string;
-  onAction?: () => void;
-  illustration?: React.ReactNode;
-}
-
-export const ExceptionEmptyState: React.FC<ExceptionEmptyStateProps> = ({
-  icon = "inbox",
-  title,
-  description,
-  actionLabel,
-  onAction,
-  illustration,
-}) => {
-  const tokens = useAppDesignTokens();
-
-  const styles = useMemo(
-    () =>
-      StyleSheet.create({
-        actionButton: {
-          borderRadius: tokens.borders.radius.md,
-          marginTop: tokens.spacing.sm,
-          paddingHorizontal: tokens.spacing.lg,
-          paddingVertical: tokens.spacing.md,
-        },
-        actionButtonText: {
-          // AtomicText handles typography
-        },
-        container: {
-          alignItems: "center",
-          flex: 1,
-          justifyContent: "center",
-          padding: tokens.spacing.xl,
-        },
-        description: {
-          marginBottom: tokens.spacing.lg,
-          maxWidth: 280,
-        },
-        iconContainer: {
-          alignItems: "center",
-          borderRadius: 60,
-          height: 120,
-          justifyContent: "center",
-          marginBottom: tokens.spacing.lg,
-          width: 120,
-        },
-        title: {
-          marginBottom: tokens.spacing.sm,
-        },
-      }),
-    [tokens],
-  );
-
-  return (
-    <View style={styles.container}>
-      {illustration ? (
-        illustration
-      ) : (
-        <View
-          style={[
-            styles.iconContainer,
-            { backgroundColor: tokens.colors.surface },
-          ]}
-        >
-          <AtomicIcon name={icon} size="xxl" color="secondary" />
-        </View>
-      )}
-
-      <AtomicText
-        type="headlineSmall"
-        color="primary"
-        style={[styles.title, { textAlign: "center" }]}
-      >
-        {title}
-      </AtomicText>
-
-      {description && (
-        <AtomicText
-          type="bodyMedium"
-          color="secondary"
-          style={[styles.description, { textAlign: "center" }]}
-        >
-          {description}
-        </AtomicText>
-      )}
-
-      {actionLabel && onAction && (
-        <TouchableOpacity
-          style={[
-            styles.actionButton,
-            { backgroundColor: tokens.colors.primary },
-          ]}
-          onPress={onAction}
-          activeOpacity={0.8}
-        >
-          <AtomicText
-            type="labelLarge"
-            color="onPrimary"
-            style={styles.actionButtonText}
-          >
-            {actionLabel}
-          </AtomicText>
-        </TouchableOpacity>
-      )}
-    </View>
-  );
-};
-

package/src/exception/presentation/components/ExceptionErrorState.tsx

@@ -1,122 +0,0 @@
-/**
- * Error State Component
- * Generic error display with retry action
- *
- * Presentation Layer - UI Component
- */
-
-import React, { useMemo } from "react";
-import { View, StyleSheet, TouchableOpacity } from "react-native";
-import {
-  AtomicIcon,
-  AtomicText,
-  useIconName,
-} from "../../../atoms";
-import {
-  useAppDesignTokens,
-} from "../../../theme";
-
-export interface ExceptionErrorStateProps {
-  /** Icon name (interpreted by app's icon renderer) */
-  icon?: string;
-  /** Error title */
-  title: string;
-  /** Error description */
-  description?: string;
-  /** Retry button label */
-  actionLabel?: string;
-  /** Retry action callback */
-  onAction?: () => void;
-  /** Custom illustration instead of icon */
-  illustration?: React.ReactNode;
-}
-
-export const ExceptionErrorState: React.FC<ExceptionErrorStateProps> = ({
-  icon,
-  title,
-  description,
-  actionLabel,
-  onAction,
-  illustration,
-}) => {
-  const tokens = useAppDesignTokens();
-  const alertCircleIcon = useIconName('alertCircle');
-  const refreshIcon = useIconName('refresh');
-  const displayIcon = icon || alertCircleIcon;
-
-  const styles = useMemo(
-    () =>
-      StyleSheet.create({
-        actionButton: {
-          alignItems: "center",
-          borderRadius: tokens.borders.radius.full,
-          flexDirection: "row",
-          gap: tokens.spacing.sm,
-          marginTop: tokens.spacing.sm,
-          paddingHorizontal: tokens.spacing.lg,
-          paddingVertical: tokens.spacing.md,
-        },
-        container: {
-          alignItems: "center",
-          flex: 1,
-          justifyContent: "center",
-          padding: tokens.spacing.xl,
-        },
-        description: {
-          marginBottom: tokens.spacing.lg,
-          maxWidth: 280,
-          textAlign: "center",
-        },
-        iconContainer: {
-          alignItems: "center",
-          borderRadius: 60,
-          height: 120,
-          justifyContent: "center",
-          marginBottom: tokens.spacing.lg,
-          width: 120,
-        },
-        title: {
-          marginBottom: tokens.spacing.sm,
-          textAlign: "center",
-        },
-      }),
-    [tokens],
-  );
-
-  return (
-    <View style={styles.container}>
-      {illustration ? (
-        illustration
-      ) : (
-        <View
-          style={[styles.iconContainer, { backgroundColor: tokens.colors.surface }]}
-        >
-          <AtomicIcon name={displayIcon as never} size="xxl" color="secondary" />
-        </View>
-      )}
-
-      <AtomicText type="headlineSmall" color="primary" style={styles.title}>
-        {title}
-      </AtomicText>
-
-      {description && (
-        <AtomicText type="bodyMedium" color="secondary" style={styles.description}>
-          {description}
-        </AtomicText>
-      )}
-
-      {actionLabel && onAction && (
-        <TouchableOpacity
-          style={[styles.actionButton, { backgroundColor: tokens.colors.primary }]}
-          onPress={onAction}
-          activeOpacity={0.8}
-        >
-          <AtomicIcon name={refreshIcon} size="sm" color="onPrimary" />
-          <AtomicText type="labelLarge" color="onPrimary">
-            {actionLabel}
-          </AtomicText>
-        </TouchableOpacity>
-      )}
-    </View>
-  );
-};