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

package/src/molecules/calendar/presentation/hooks/useCalendar.ts

@@ -1,185 +0,0 @@
-/**
- * useCalendar Hook
- *
- * Main hook for calendar functionality.
- * Provides calendar state, events, and actions.
- *
- * Usage:
- * ```tsx
- * const {
- *   days,
- *   events,
- *   selectedDate,
- *   viewMode,
- *   actions
- * } = useCalendar();
- *
- * // Navigate calendar
- * actions.navigateMonth('next');
- *
- * // Add event
- * actions.addEvent({
- *   title: 'Team Meeting',
- *   date: '2024-10-30',
- *   time: '14:00',
- * });
- * ```
- */
-
-import { useMemo, useEffect } from 'react';
-import { useCalendarStore, type CalendarViewMode } from '../../infrastructure/storage/CalendarStore';
-import type { CalendarDay } from '../../domain/entities/CalendarDay.entity';
-import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
-
-/**
- * Calendar hook return type
- */
-export interface UseCalendarReturn {
-  // Calendar data
-  days: CalendarDay[];
-  events: CalendarEvent[];
-  selectedDate: Date;
-  currentMonth: Date;
-  viewMode: CalendarViewMode;
-
-  // Computed data
-  selectedDateEvents: CalendarEvent[];
-  currentMonthEvents: CalendarEvent[];
-
-  // State
-  isLoading: boolean;
-  error: string | null;
-
-  // Actions
-  actions: {
-    loadEvents: () => Promise<void>;
-    addEvent: (request: CreateCalendarEventRequest) => Promise<void>;
-    updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>;
-    deleteEvent: (id: string) => Promise<void>;
-    completeEvent: (id: string) => Promise<void>;
-    uncompleteEvent: (id: string) => Promise<void>;
-    setSelectedDate: (date: Date) => void;
-    goToToday: () => void;
-    navigateMonth: (direction: 'prev' | 'next') => void;
-    setCurrentMonth: (date: Date) => void;
-    setViewMode: (mode: CalendarViewMode) => void;
-    getEventsForDate: (date: Date) => CalendarEvent[];
-    getEventsForMonth: (year: number, month: number) => CalendarEvent[];
-    clearError: () => void;
-    clearAllEvents: () => Promise<void>;
-  };
-}
-
-/**
- * Main calendar hook
- */
-export const useCalendarPresentation = (): UseCalendarReturn => {
-  const store = useCalendarStore();
-  const {
-    events,
-    selectedDate,
-    currentMonth,
-    viewMode,
-    isLoading,
-    error,
-    actions,
-  } = store;
-
-  // Load events on mount
-  useEffect(() => {
-    actions.loadEvents();
-  }, [actions.loadEvents]);
-
-  // Get events for selected date
-  const selectedDateEvents = useMemo(() => {
-    return events.filter(event => {
-      const eventDate = new Date(event.date);
-      return eventDate.toDateString() === selectedDate.toDateString();
-    });
-  }, [selectedDate, events]);
-
-  // Get events for current month
-  const currentMonthEvents = useMemo(() => {
-    const year = currentMonth.getFullYear();
-    const month = currentMonth.getMonth();
-    return events.filter(event => {
-      const eventDate = new Date(event.date);
-      return eventDate.getFullYear() === year && eventDate.getMonth() === month;
-    });
-  }, [currentMonth, events]);
-
-  return {
-    days: store.days,
-    events,
-    selectedDate,
-    currentMonth,
-    viewMode,
-    selectedDateEvents,
-    currentMonthEvents,
-    isLoading,
-    error,
-    actions,
-  };
-};
-
-/**
- * Hook for calendar navigation
- * Lightweight hook for just navigation actions
- */
-export const useCalendarNavigation = () => {
-  const store = useCalendarStore();
-  const {
-    selectedDate,
-    currentMonth,
-    actions: { setSelectedDate, navigateMonth, goToToday, setCurrentMonth },
-  } = store;
-
-  return {
-    selectedDate,
-    currentMonth,
-    setSelectedDate,
-    navigateMonth,
-    goToToday,
-    setCurrentMonth,
-  };
-};
-
-/**
- * Hook for calendar events only
- * Lightweight hook for just event operations
- */
-export const useCalendarEvents = () => {
-  const store = useCalendarStore();
-  const {
-    events,
-    isLoading,
-    error,
-    actions: {
-      loadEvents,
-      addEvent,
-      updateEvent,
-      deleteEvent,
-      completeEvent,
-      uncompleteEvent,
-      clearError,
-    },
-  } = store;
-
-  return {
-    events,
-    isLoading,
-    error,
-    loadEvents,
-    addEvent,
-    updateEvent,
-    deleteEvent,
-    completeEvent,
-    uncompleteEvent,
-    clearError,
-  };
-};
-
-// Re-export for convenience
-export { useCalendar, useCalendarStore } from '../../infrastructure/storage/CalendarStore';
-export type { CalendarViewMode } from '../../infrastructure/storage/CalendarStore';
-

package/src/molecules/confirmation-modal/index.ts

@@ -1,7 +0,0 @@
-/**
- * ConfirmationModal Module - Re-exports
- */
-
-export * from './types';
-export * from './styles/confirmationModalStyles';
-export { useConfirmationModal } from './useConfirmationModal';

package/src/molecules/listitem/index.ts

@@ -1,6 +0,0 @@
-/**
- * ListItem Module - Re-exports
- */
-
-export * from './types';
-export * from './styles/listItemStyles';

package/src/molecules/navigation/components/index.ts

@@ -1,4 +0,0 @@
-export { NavigationContainer } from "./NavigationContainer";
-export { NavigationHeader } from "./NavigationHeader";
-export { TabLabel } from "./TabLabel";
-export { FabButton } from "./FabButton";

package/src/molecules/navigation/utils/NavigationTheme.ts

@@ -1,21 +0,0 @@
-import { DefaultTheme as NavigationDefaultTheme, DarkTheme as NavigationDarkTheme, Theme } from '@react-navigation/native';
-
-/**
- * Create a navigation theme based on design tokens and mode
- */
-export const createNavigationTheme = (colors: Record<string, string>, mode: 'light' | 'dark'): Theme => {
-    const baseTheme = mode === 'dark' ? NavigationDarkTheme : NavigationDefaultTheme;
-
-    return {
-        ...baseTheme,
-        colors: {
-            ...baseTheme.colors,
-            primary: colors.primary ?? baseTheme.colors.primary,
-            background: colors.backgroundPrimary ?? baseTheme.colors.background,
-            card: colors.surface ?? baseTheme.colors.card,
-            text: colors.textPrimary ?? baseTheme.colors.text,
-            border: colors.border ?? baseTheme.colors.border,
-            notification: colors.error ?? baseTheme.colors.notification,
-        },
-    };
-};

package/src/presentation/utils/variants/compound.ts

@@ -1,34 +0,0 @@
-import { Style, VariantConfig, VariantProps, createVariants } from './core';
-
-export interface CompoundVariant<T extends Record<string, Record<string, Style>>> {
-  conditions: Partial<VariantProps<T>>;
-  style: Style;
-}
-
-export interface AdvancedVariantConfig<T extends Record<string, Record<string, Style>>>
-  extends VariantConfig<T> {
-  compoundVariants?: CompoundVariant<T>[];
-}
-
-export function createAdvancedVariants<T extends Record<string, Record<string, Style>>>(
-  config: AdvancedVariantConfig<T>
-) {
-  const baseVariantFn = createVariants(config);
-
-  return (props: VariantProps<T> = {}): Style => {
-    let result = baseVariantFn(props);
-
-    if (config.compoundVariants) {
-      config.compoundVariants.forEach(compound => {
-        const conditionsMet = Object.entries(compound.conditions).every(
-          ([key, value]) => props[key as keyof T] === value
-        );
-        if (conditionsMet) {
-          result = { ...result, ...compound.style };
-        }
-      });
-    }
-
-    return result;
-  };
-}

package/src/services/api/ApiClient.ts

@@ -1,180 +0,0 @@
-/**
- * API Client
- * Centralized HTTP client for API communication
- */
-
-import type {
-  ApiClientConfig,
-  ApiRequestConfig,
-  ApiResponse,
-  HttpMethod,
-} from './types/ApiTypes';
-import {
-  buildURL,
-  buildRequestConfig,
-} from './utils/requestBuilder';
-import {
-  parseResponse,
-  handleHttpError,
-  handleNetworkError,
-  isSuccessfulResponse,
-  fetchWithTimeout,
-} from './utils/responseHandler';
-import { retryWithBackoff, isNetworkError, isRetryableHttpStatus } from '../../utils/async';
-import { ErrorHandler } from '../../utils/errors';
-
-/**
- * Applies interceptors to a value
- */
-async function applyInterceptors<T>(
-  value: T,
-  interceptors: Array<(value: T) => T | Promise<T>> | undefined
-): Promise<T> {
-  let result = value;
-  for (const interceptor of interceptors || []) {
-    result = await interceptor(result);
-  }
-  return result;
-}
-
-export class ApiClient {
-  private config: ApiClientConfig;
-
-  constructor(config: ApiClientConfig) {
-    this.config = {
-      timeout: 30000,
-      ...config,
-    };
-  }
-
-  /**
-   * Makes an HTTP request with automatic retry for retryable errors
-   */
-  async request<T>(requestConfig: ApiRequestConfig): Promise<ApiResponse<T>> {
-    try {
-      const config = await applyInterceptors(requestConfig, this.config.requestInterceptors);
-
-      const fullURL = config.url.startsWith('http')
-        ? config.url
-        : buildURL(this.config.baseURL, config.url, config.params);
-
-      const fetchOptions = buildRequestConfig({
-        ...config,
-        headers: { ...this.config.headers, ...config.headers },
-      });
-
-      // Retry only for GET requests and retryable errors
-      const shouldRetry = config.method === 'GET';
-      const timeout = config.timeout || this.config.timeout || 30000;
-
-      const response = shouldRetry
-        ? await retryWithBackoff(
-            () => fetchWithTimeout(fullURL, fetchOptions, timeout),
-            {
-              maxRetries: 3,
-              baseDelay: 1000,
-              shouldRetry: (error) => {
-                // Retry on network errors
-                if (isNetworkError(error as Error)) return true;
-
-                // Retry on specific HTTP status codes (5xx, 429, 408)
-                if ('status' in error && typeof error.status === 'number') {
-                  return isRetryableHttpStatus(error.status);
-                }
-
-                return false;
-              },
-              onRetry: (error, attempt, delay) => {
-                if (__DEV__) {
-                  ErrorHandler.log({
-                    name: 'ApiRetry',
-                    message: `Retrying API request (attempt ${attempt}) after ${delay}ms`,
-                    context: { url: fullURL, error: error.message },
-                  });
-                }
-              },
-            }
-          )
-        : await fetchWithTimeout(fullURL, fetchOptions, timeout);
-
-      if (!isSuccessfulResponse(response)) {
-        const error = await handleHttpError(response);
-        throw await applyInterceptors(error, this.config.errorInterceptors);
-      }
-
-      let parsedResponse = await parseResponse<T>(response);
-      parsedResponse = await applyInterceptors(parsedResponse, this.config.responseInterceptors);
-
-      return parsedResponse;
-    } catch (error) {
-      const apiError = handleNetworkError(error);
-      ErrorHandler.log(apiError);
-      throw await applyInterceptors(apiError, this.config.errorInterceptors);
-    }
-  }
-
-  /**
-   * Makes an HTTP request with a specific method
-   */
-  private requestWithMethod<T>(
-    method: HttpMethod,
-    url: string,
-    bodyOrParams?: any,
-    config?: Partial<ApiRequestConfig>
-  ): Promise<ApiResponse<T>> {
-    const requestData: ApiRequestConfig = {
-      url,
-      method,
-      ...(method === 'GET' || method === 'DELETE' ? { params: bodyOrParams } : { body: bodyOrParams }),
-      ...config,
-    };
-    return this.request<T>(requestData);
-  }
-
-  get<T>(url: string, params?: Record<string, string | number | boolean | undefined>, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>> {
-    return this.requestWithMethod<T>('GET', url, params, config);
-  }
-
-  post<T>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>> {
-    return this.requestWithMethod<T>('POST', url, body, config);
-  }
-
-  put<T>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>> {
-    return this.requestWithMethod<T>('PUT', url, body, config);
-  }
-
-  patch<T>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>> {
-    return this.requestWithMethod<T>('PATCH', url, body, config);
-  }
-
-  delete<T>(url: string, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>> {
-    return this.requestWithMethod<T>('DELETE', url, undefined, config);
-  }
-
-  updateConfig(updates: Partial<ApiClientConfig>): void {
-    this.config = { ...this.config, ...updates };
-  }
-
-  getConfig(): ApiClientConfig {
-    return { ...this.config };
-  }
-}
-
-let apiClientInstance: ApiClient | null = null;
-
-export function createApiClient(config: ApiClientConfig): ApiClient {
-  if (!apiClientInstance) {
-    apiClientInstance = new ApiClient(config);
-  }
-  return apiClientInstance;
-}
-
-export function getApiClient(): ApiClient | null {
-  return apiClientInstance;
-}
-
-export function resetApiClient(): void {
-  apiClientInstance = null;
-}
-
-

package/src/services/api/index.ts

@@ -1,9 +0,0 @@
-/**
- * API Service Index
- * Centralized export of API service components
- */
-
-export * from './ApiClient';
-export * from './types/ApiTypes';
-export * from './utils/requestBuilder';
-export * from './utils/responseHandler';

package/src/services/api/types/ApiTypes.ts

@@ -1,50 +0,0 @@
-/**
- * API Service Types
- * Type definitions for API communication
- */
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
-export interface ApiRequestConfig {
-  url: string;
-  method: HttpMethod;
-  headers?: Record<string, string>;
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: any;
-  timeout?: number;
-}
-
-export interface ApiResponse<T = any> {
-  data: T;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-}
-
-export interface ApiError {
-  message: string;
-  status?: number;
-  code?: string;
-  details?: any;
-}
-
-export interface RequestInterceptor {
-  (config: ApiRequestConfig): ApiRequestConfig | Promise<ApiRequestConfig>;
-}
-
-export interface ResponseInterceptor {
-  (response: ApiResponse): ApiResponse | Promise<ApiResponse>;
-}
-
-export interface ErrorInterceptor {
-  (error: ApiError): ApiError | Promise<ApiError>;
-}
-
-export interface ApiClientConfig {
-  baseURL: string;
-  timeout?: number;
-  headers?: Record<string, string>;
-  requestInterceptors?: RequestInterceptor[];
-  responseInterceptors?: ResponseInterceptor[];
-  errorInterceptors?: ErrorInterceptor[];
-}

package/src/services/api/utils/requestBuilder.ts

@@ -1,92 +0,0 @@
-/**
- * Request Builder Utility
- * Builds HTTP requests with proper configuration
- */
-
-import type { ApiRequestConfig, HttpMethod } from '../types/ApiTypes';
-
-/**
- * Builds query string from params object
- *
- * @param params - Query parameters
- * @returns Query string
- */
-export function buildQueryString(params: Record<string, string | number | boolean | undefined>): string {
-  const searchParams = new URLSearchParams();
-
-  Object.entries(params).forEach(([key, value]) => {
-    if (value !== undefined) {
-      searchParams.append(key, String(value));
-    }
-  });
-
-  const queryString = searchParams.toString();
-  return queryString ? `?${queryString}` : '';
-}
-
-/**
- * Builds full URL with query parameters
- *
- * @param baseURL - Base URL
- * @param path - Request path
- * @param params - Query parameters
- * @returns Full URL
- */
-export function buildURL(
-  baseURL: string,
-  path: string,
-  params?: Record<string, string | number | boolean | undefined>
-): string {
-  const cleanPath = path.startsWith('/') ? path : `/${path}`;
-  const fullURL = `${baseURL}${cleanPath}`;
-
-  if (params) {
-    return `${fullURL}${buildQueryString(params)}`;
-  }
-
-  return fullURL;
-}
-
-/**
- * Builds request configuration
- *
- * @param config - Request configuration
- * @returns Built fetch options
- */
-export function buildRequestConfig(config: ApiRequestConfig): RequestInit {
-  const options: RequestInit = {
-    method: config.method,
-    headers: {
-      'Content-Type': 'application/json',
-      ...config.headers,
-    },
-  };
-
-  if (config.body) {
-    options.body = JSON.stringify(config.body);
-  }
-
-  return options;
-}
-
-/**
- * Creates a request builder function for a specific base URL
- *
- * @param baseURL - Base URL for all requests
- * @returns Request builder function
- */
-export function createRequestBuilder(baseURL: string) {
-  return (
-    path: string,
-    method: HttpMethod,
-    params?: Record<string, string | number | boolean | undefined>,
-    body?: any,
-    headers?: Record<string, string>
-  ): ApiRequestConfig => ({
-    url: buildURL(baseURL, path, params),
-    method,
-    params,
-    body,
-    headers,
-  });
-}