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

package/src/media/infrastructure/hooks/useGenericMediaGeneration.ts

@@ -1,170 +0,0 @@
-/**
- * Generic Media Generation Hook
- * Shared implementation for both Media and CardMedia generation
- * Eliminates ~600 LOC duplication
- */
-
-import { useState, useCallback } from "react";
-
-interface GenericMediaAttachment {
-  id: string;
-  type: string;
-  position: string;
-  url: string;
-  filename: string;
-  fileSize: number;
-  mimeType: string;
-  duration?: number;
-  thumbnailUrl?: string;
-  caption?: string;
-  isDownloaded: boolean;
-  createdAt: string;
-}
-
-interface GenericMediaGenerationRequest {
-  type: "text_to_image" | "text_to_audio" | "image_search";
-  input: {
-    text?: string;
-    prompt?: string;
-    language?: string;
-    voice?: "male" | "female" | "neutral";
-    style?: "realistic" | "cartoon" | "artistic";
-  };
-  options: {
-    maxResults?: number;
-    quality?: "low" | "medium" | "high";
-    format?: "jpeg" | "png" | "mp3" | "wav";
-  };
-}
-
-interface GenericMediaGenerationResult<TAttachment> {
-  success: boolean;
-  attachments: TAttachment[];
-  creditsUsed: number;
-  processingTime: number;
-  error?: string;
-  requestId: string;
-}
-
-export interface UseGenericMediaGenerationResult<TAttachment, TRequest> {
-  generateMedia: (request: TRequest) => Promise<GenericMediaGenerationResult<TAttachment>>;
-  isGenerating: boolean;
-  generationResult: GenericMediaGenerationResult<TAttachment> | null;
-  error: string | null;
-}
-
-/**
- * Generic implementation of media generation logic
- * Type-safe through attachment factory pattern
- */
-export function useGenericMediaGeneration<
-  TAttachment extends GenericMediaAttachment,
-  TRequest extends GenericMediaGenerationRequest
->(
-  attachmentFactory: (baseAttachment: GenericMediaAttachment) => TAttachment
-): UseGenericMediaGenerationResult<TAttachment, TRequest> {
-  const [isGenerating, setIsGenerating] = useState(false);
-  const [generationResult, setGenerationResult] =
-    useState<GenericMediaGenerationResult<TAttachment> | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const generateMedia = useCallback(
-    async (request: TRequest): Promise<GenericMediaGenerationResult<TAttachment>> => {
-      try {
-        setIsGenerating(true);
-        setError(null);
-
-        // Simulate generation
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-
-        const baseAttachments: GenericMediaAttachment[] = [];
-
-        switch (request.type) {
-          case "text_to_image":
-            for (let i = 0; i < (request.options.maxResults || 1); i++) {
-              baseAttachments.push({
-                id: `ai_img_${Date.now()}_${i}`,
-                type: "image",
-                position: "both",
-                url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
-                filename: `ai_generated_${i}.jpg`,
-                fileSize: 150000,
-                mimeType: "image/jpeg",
-                isDownloaded: false,
-                createdAt: new Date().toISOString(),
-              });
-            }
-            break;
-
-          case "text_to_audio":
-            baseAttachments.push({
-              id: `ai_audio_${Date.now()}`,
-              type: "audio",
-              position: "back",
-              url: `https://example.com/audio_${Date.now()}.mp3`,
-              filename: `ai_generated_${Date.now()}.mp3`,
-              fileSize: 80000,
-              mimeType: "audio/mp3",
-              duration: 10,
-              isDownloaded: false,
-              createdAt: new Date().toISOString(),
-            });
-            break;
-
-          case "image_search":
-            for (let i = 0; i < (request.options.maxResults || 5); i++) {
-              baseAttachments.push({
-                id: `search_img_${Date.now()}_${i}`,
-                type: "image",
-                position: "both",
-                url: `https://picsum.photos/400/300?random=${Date.now() + i}`,
-                filename: `search_result_${i}.jpg`,
-                fileSize: 120000,
-                mimeType: "image/jpeg",
-                isDownloaded: false,
-                createdAt: new Date().toISOString(),
-              });
-            }
-            break;
-        }
-
-        const attachments = baseAttachments.map(attachmentFactory);
-
-        const result: GenericMediaGenerationResult<TAttachment> = {
-          success: true,
-          attachments,
-          creditsUsed: request.type === "text_to_image" ? 5 : request.type === "text_to_audio" ? 3 : 2,
-          processingTime: 3000,
-          requestId: `req_${Date.now()}`,
-        };
-
-        setGenerationResult(result);
-        return result;
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Generation failed";
-        setError(errorMessage);
-        setIsGenerating(false);
-
-        return {
-          success: false,
-          attachments: [],
-          creditsUsed: 0,
-          processingTime: 0,
-          error: errorMessage,
-          requestId: "",
-        };
-      } finally {
-        setIsGenerating(false);
-      }
-    },
-    [attachmentFactory],
-  );
-
-  return {
-    generateMedia,
-    isGenerating,
-    generationResult,
-    error,
-  };
-}

package/src/molecules/ConfirmationModal.tsx

@@ -1,42 +0,0 @@
-/**
- * ConfirmationModal - Universal Confirmation Dialog
- *
- * A reusable confirmation modal for destructive and important actions.
- * Follows Material Design 3 dialog patterns and accessibility guidelines.
- *
- * Features:
- * - Multiple variants (default, destructive, warning, success)
- * - Configurable text and icons
- * - Backdrop dismissal
- * - Full keyboard and screen reader support
- * - Theme-aware styling
- *
- * @example
- * ```tsx
- * // Destructive confirmation (delete)
- * <ConfirmationModal
- *   visible={showDeleteModal}
- *   variant="destructive"
- *   title="Delete Item?"
- *   message="This action cannot be undone. All data will be permanently deleted."
- *   confirmText="Delete"
- *   cancelText="Cancel"
- *   onConfirm={handleDelete}
- *   onCancel={() => setShowDeleteModal(false)}
- * />
- *
- * // Generic confirmation
- * <ConfirmationModal
- *   visible={showConfirmModal}
- *   variant="default"
- *   title="Confirm Action"
- *   message="Are you sure you want to proceed?"
- *   onConfirm={handleConfirm}
- *   onCancel={() => setShowConfirmModal(false)}
- * />
- * ```
- */
-
-export { ConfirmationModal } from './ConfirmationModalMain';
-export { useConfirmationModal } from './confirmation-modal/useConfirmationModal';
-export type { ConfirmationModalProps, ConfirmationModalVariant } from './confirmation-modal/types';

package/src/molecules/calendar/infrastructure/storage/CalendarStore.types.ts

@@ -1,64 +0,0 @@
-/**
- * Calendar Store Types
- * Type definitions for calendar store
- */
-
-import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
-
-/**
- * Calendar view mode
- */
-export type CalendarViewMode = 'month' | 'week' | 'day' | 'list';
-
-/**
- * Calendar state (data only)
- */
-export interface CalendarState {
-  events: CalendarEvent[];
-  selectedDate: Date;
-  currentMonth: Date;
-  viewMode: CalendarViewMode;
-  isLoading: boolean;
-  error: string | null;
-}
-
-/**
- * Calendar actions
- */
-export interface CalendarActions {
-  // Event CRUD
-  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>;
-
-  // Navigation
-  setSelectedDate: (date: Date) => void;
-  goToToday: () => void;
-  navigateMonth: (direction: 'prev' | 'next') => void;
-  navigateWeek: (direction: 'prev' | 'next') => void;
-  setCurrentMonth: (date: Date) => void;
-
-  // View mode
-  setViewMode: (mode: CalendarViewMode) => void;
-
-  // Utilities
-  getEventsForDate: (date: Date) => CalendarEvent[];
-  getEventsForMonth: (year: number, month: number) => CalendarEvent[];
-  clearError: () => void;
-  clearAllEvents: () => Promise<void>;
-}
-
-/**
- * Initial state
- */
-export const initialState: CalendarState = {
-  events: [],
-  selectedDate: new Date(),
-  currentMonth: new Date(),
-  viewMode: 'month',
-  isLoading: false,
-  error: null,
-};

package/src/molecules/calendar/infrastructure/storage/CalendarStore.utils.ts

@@ -1,56 +0,0 @@
-/**
- * Calendar Store Utilities
- * Helper functions for calendar store operations
- */
-
-import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
-import type { CalendarState } from './CalendarStore.types';
-
-/**
- * Storage key for calendar events
- */
-export const STORAGE_KEY = 'calendar_events';
-
-/**
- * Generate unique ID for events
- */
-export const generateId = (): string => {
-  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-};
-
-/**
- * Hydrate date strings in events back to Date objects
- */
-export const hydrateEvents = (events: CalendarEvent[]): CalendarEvent[] => {
-  return events.map((event) => ({
-    ...event,
-    createdAt: new Date(event.createdAt),
-    updatedAt: new Date(event.updatedAt),
-  }));
-};
-
-/**
- * Handle storage operation error
- */
-export const handleStorageError = (
-  set: (state: Partial<CalendarState>) => void,
-  errorMessage: string
-): void => {
-  set({
-    error: errorMessage,
-    isLoading: false,
-  });
-};
-
-/**
- * Handle storage operation success
- */
-export const handleStorageSuccess = (
-  set: (state: Partial<CalendarState>) => void,
-  updates: Partial<CalendarState>
-): void => {
-  set({
-    ...updates,
-    isLoading: false,
-  });
-};

package/src/molecules/calendar/infrastructure/storage/EventActions.ts

@@ -1,140 +0,0 @@
-/**
- * Calendar Event Actions
- * Event CRUD operations for calendar store
- */
-
-import { storageRepository, unwrap } from '../../../../storage';
-import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
-import { generateId, STORAGE_KEY, hydrateEvents, handleStorageError, handleStorageSuccess } from './CalendarStore.utils';
-import type { CalendarState } from './CalendarStore.types';
-
-/**
- * Load events from storage
- */
-export const loadEvents = async (
-  set: (state: Partial<CalendarState>) => void
-): Promise<void> => {
-  set({ isLoading: true, error: null });
-  try {
-    const result = await storageRepository.getItem<CalendarEvent[]>(STORAGE_KEY, []);
-    const events = unwrap(result, []);
-
-    if (events && events.length > 0) {
-      const hydratedEvents = hydrateEvents(events);
-      set({ events: hydratedEvents, isLoading: false });
-    } else {
-      set({ isLoading: false });
-    }
-  } catch {
-    handleStorageError(set, 'Failed to load events');
-  }
-};
-
-/**
- * Add a new event
- */
-export const addEvent = async (
-  request: CreateCalendarEventRequest,
-  set: (state: Partial<CalendarState>) => void,
-  get: () => CalendarState
-): Promise<void> => {
-  set({ isLoading: true, error: null });
-  try {
-    const newEvent: CalendarEvent = {
-      id: generateId(),
-      ...request,
-      isCompleted: false,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    const events = [...get().events, newEvent];
-    await storageRepository.setItem(STORAGE_KEY, events);
-    handleStorageSuccess(set, { events });
-  } catch {
-    handleStorageError(set, 'Failed to add event');
-  }
-};
-
-/**
- * Update an existing event
- */
-export const updateEvent = async (
-  request: UpdateCalendarEventRequest,
-  set: (state: Partial<CalendarState>) => void,
-  get: () => CalendarState
-): Promise<void> => {
-  set({ isLoading: true, error: null });
-  try {
-    const events = get().events.map((event) => {
-      if (event.id === request.id) {
-        return {
-          ...event,
-          ...request,
-          updatedAt: new Date(),
-        };
-      }
-      return event;
-    });
-
-    await storageRepository.setItem(STORAGE_KEY, events);
-    handleStorageSuccess(set, { events });
-  } catch {
-    handleStorageError(set, 'Failed to update event');
-  }
-};
-
-/**
- * Delete an event
- */
-export const deleteEvent = async (
-  id: string,
-  set: (state: Partial<CalendarState>) => void,
-  get: () => CalendarState
-): Promise<void> => {
-  set({ isLoading: true, error: null });
-  try {
-    const events = get().events.filter((event) => event.id !== id);
-    await storageRepository.setItem(STORAGE_KEY, events);
-    handleStorageSuccess(set, { events });
-  } catch {
-    handleStorageError(set, 'Failed to delete event');
-  }
-};
-
-/**
- * Mark event as completed
- */
-export const completeEvent = async (
-  id: string,
-  get: () => CalendarState,
-  updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>
-): Promise<void> => {
-  await updateEvent({ id, isCompleted: true });
-};
-
-/**
- * Mark event as incomplete
- */
-export const uncompleteEvent = async (
-  id: string,
-  get: () => CalendarState,
-  updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>
-): Promise<void> => {
-  await updateEvent({ id, isCompleted: false });
-};
-
-/**
- * Clear all events (for testing/reset)
- */
-export const clearAllEvents = async (
-  set: (state: Partial<CalendarState>) => void
-): Promise<void> => {
-  set({ isLoading: true, error: null });
-  try {
-    await storageRepository.removeItem(STORAGE_KEY);
-    handleStorageSuccess(set, { events: [] });
-  } catch {
-    handleStorageError(set, 'Failed to clear events');
-  }
-};

package/src/molecules/calendar/infrastructure/storage/NavigationActions.ts

@@ -1,118 +0,0 @@
-/**
- * Calendar Navigation Actions
- * Navigation and view mode operations for calendar store
- */
-
-import { CalendarService } from '../services/CalendarService';
-import type { CalendarState, CalendarViewMode } from './CalendarStore.types';
-
-/**
- * Set selected date
- */
-export const setSelectedDate = (
-  date: Date,
-  set: (state: Partial<CalendarState>) => void
-): void => {
-  set({ selectedDate: date });
-};
-
-/**
- * Go to today's date
- */
-export const goToToday = (
-  set: (state: Partial<CalendarState>) => void
-): void => {
-  const today = new Date();
-  set({
-    selectedDate: today,
-    currentMonth: today,
-  });
-};
-
-/**
- * Navigate to previous/next month
- */
-export const navigateMonth = (
-  direction: 'prev' | 'next',
-  set: (state: Partial<CalendarState>) => void,
-  get: () => CalendarState
-): void => {
-  const currentMonth = get().currentMonth;
-  const newMonth =
-    direction === 'prev'
-      ? CalendarService.getPreviousMonth(currentMonth)
-      : CalendarService.getNextMonth(currentMonth);
-
-  set({ currentMonth: newMonth });
-};
-
-/**
- * Navigate to previous/next week
- */
-export const navigateWeek = (
-  direction: 'prev' | 'next',
-  set: (state: Partial<CalendarState>) => void,
-  get: () => CalendarState
-): void => {
-  const selectedDate = get().selectedDate;
-  const newDate =
-    direction === 'prev'
-      ? CalendarService.getPreviousWeek(selectedDate)
-      : CalendarService.getNextWeek(selectedDate);
-
-  set({ selectedDate: newDate });
-};
-
-/**
- * Set current month directly
- */
-export const setCurrentMonth = (
-  date: Date,
-  set: (state: Partial<CalendarState>) => void
-): void => {
-  set({ currentMonth: date });
-};
-
-/**
- * Set view mode
- */
-export const setViewMode = (
-  mode: CalendarViewMode,
-  set: (state: Partial<CalendarState>) => void
-): void => {
-  set({ viewMode: mode });
-};
-
-/**
- * Get events for a specific date
- */
-export const getEventsForDate = (
-  date: Date,
-  get: () => CalendarState
-): ReturnType<typeof CalendarService.getEventsForDate> => {
-  const events = get().events;
-  return CalendarService.getEventsForDate(date, events);
-};
-
-/**
- * Get events for a specific month
- */
-export const getEventsForMonth = (
-  year: number,
-  month: number,
-  get: () => CalendarState
-): ReturnType<typeof CalendarService.getEventsInRange> => {
-  const events = get().events;
-  const firstDay = new Date(year, month, 1);
-  const lastDay = new Date(year, month + 1, 0);
-  return CalendarService.getEventsInRange(firstDay, lastDay, events);
-};
-
-/**
- * Clear error state
- */
-export const clearError = (
-  set: (state: Partial<CalendarState>) => void
-): void => {
-  set({ error: null });
-};