@umituz/react-native-design-system 2.6.62 → 2.6.64

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

@@ -0,0 +1,116 @@
+/**
+ * Calendar Store - Combined Hook
+ * Convenience hook that combines all calendar stores
+ */
+
+import { useMemo } from 'react';
+import { useCalendarEvents } from '../stores/useCalendarEvents';
+import { useCalendarNavigation } from '../stores/useCalendarNavigation';
+import { useCalendarView } from '../stores/useCalendarView';
+import { CalendarService } from '../../services/CalendarService';
+import type { CalendarDay } from '../../../domain/entities/CalendarDay.entity';
+
+// Export individual stores
+export { useCalendarEvents } from '../stores/useCalendarEvents';
+export { useCalendarNavigation } from '../stores/useCalendarNavigation';
+export { useCalendarView } from '../stores/useCalendarView';
+
+// Export types
+export type { CalendarViewMode } from '../stores/useCalendarView';
+
+/**
+ * Combined calendar hook
+ * Use this for convenience, or use individual stores for fine-grained control
+ */
+export const useCalendar = () => {
+  const events = useCalendarEvents();
+  const navigation = useCalendarNavigation();
+  const view = useCalendarView();
+
+  // Utility functions for backward compatibility
+  const getEventsForDate = (date: Date) => {
+    return events.events.filter(event => {
+      const eventDate = new Date(event.date);
+      return eventDate.toDateString() === date.toDateString();
+    });
+  };
+
+  const getEventsForMonth = (year: number, month: number) => {
+    return events.events.filter(event => {
+      const eventDate = new Date(event.date);
+      return eventDate.getFullYear() === year && eventDate.getMonth() === month;
+    });
+  };
+
+  return {
+    // Events state and actions
+    events: events.events,
+    isLoading: events.isLoading,
+    error: events.error,
+    loadEvents: events.loadEvents,
+    addEvent: events.addEvent,
+    updateEvent: events.updateEvent,
+    deleteEvent: events.deleteEvent,
+    completeEvent: events.completeEvent,
+    uncompleteEvent: events.uncompleteEvent,
+    clearError: events.clearError,
+    clearAllEvents: events.clearAllEvents,
+
+    // Navigation state and actions
+    selectedDate: navigation.selectedDate,
+    currentMonth: navigation.currentMonth,
+    setSelectedDate: navigation.setSelectedDate,
+    goToToday: navigation.goToToday,
+    navigateMonth: navigation.navigateMonth,
+    setCurrentMonth: navigation.setCurrentMonth,
+
+    // View state and actions
+    viewMode: view.viewMode,
+    setViewMode: view.setViewMode,
+
+    // Utility functions
+    getEventsForDate,
+    getEventsForMonth,
+  };
+};
+
+/**
+ * Legacy alias for backward compatibility
+ * @deprecated Use useCalendar instead
+ */
+export const useCalendarStore = () => {
+  const calendar = useCalendar();
+
+  const days = useMemo(() => {
+    const year = calendar.currentMonth.getFullYear();
+    const month = calendar.currentMonth.getMonth();
+    return CalendarService.getMonthDays(year, month, calendar.events);
+  }, [calendar.currentMonth, calendar.events]);
+
+  return {
+    events: calendar.events,
+    selectedDate: calendar.selectedDate,
+    currentMonth: calendar.currentMonth,
+    viewMode: calendar.viewMode,
+    isLoading: calendar.isLoading,
+    error: calendar.error,
+    actions: {
+      loadEvents: calendar.loadEvents,
+      addEvent: calendar.addEvent,
+      updateEvent: calendar.updateEvent,
+      deleteEvent: calendar.deleteEvent,
+      completeEvent: calendar.completeEvent,
+      uncompleteEvent: calendar.uncompleteEvent,
+      setSelectedDate: calendar.setSelectedDate,
+      goToToday: calendar.goToToday,
+      navigateMonth: calendar.navigateMonth,
+      setCurrentMonth: calendar.setCurrentMonth,
+      setViewMode: calendar.setViewMode,
+      getEventsForDate: calendar.getEventsForDate,
+      getEventsForMonth: calendar.getEventsForMonth,
+      clearError: calendar.clearError,
+      clearAllEvents: calendar.clearAllEvents,
+    },
+    days,
+  };
+};

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

@@ -0,0 +1,64 @@
+/**
+ * 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

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -0,0 +1,140 @@
+/**
+ * Calendar Event Actions
+ * Event CRUD operations for calendar store
+ */
+
+import { storageRepository, unwrap } from '@umituz/react-native-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

@@ -0,0 +1,118 @@
+/**
+ * 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 });
+};

package/src/molecules/calendar/infrastructure/stores/storageAdapter.ts

@@ -0,0 +1,34 @@
+/**
+ * AsyncStorage Adapter for Zustand Persist
+ * Converts AsyncStorageRepository to Zustand-compatible storage
+ */
+
+import { storageRepository } from '@umituz/react-native-storage';
+
+export const zustandStorage = {
+  getItem: async (name: string): Promise<string | null> => {
+    try {
+      const result = await storageRepository.getItem<string>(name);
+      if (result.success && result.data) {
+        return result.data;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+  setItem: async (name: string, value: string): Promise<void> => {
+    try {
+      await storageRepository.setItem(name, value);
+    } catch {
+      // Silent fail
+    }
+  },
+  removeItem: async (name: string): Promise<void> => {
+    try {
+      await storageRepository.removeItem(name);
+    } catch {
+      // Silent fail
+    }
+  },
+};

package/src/molecules/calendar/infrastructure/stores/useCalendarEvents.ts

@@ -0,0 +1,168 @@
+/**
+ * Calendar Events Store
+ * Manages event CRUD operations only
+ * Uses manual persistence (no zustand persist middleware)
+ */
+
+import { create } from 'zustand';
+import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
+import { zustandStorage } from './storageAdapter';
+
+const STORAGE_KEY = 'calendar_events';
+
+interface CalendarEventsState {
+  readonly events: CalendarEvent[];
+  readonly isLoading: boolean;
+  readonly error: string | null;
+}
+
+interface CalendarEventsActions {
+  readonly loadEvents: () => Promise<void>;
+  readonly addEvent: (request: CreateCalendarEventRequest) => Promise<void>;
+  readonly updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>;
+  readonly deleteEvent: (id: string) => Promise<void>;
+  readonly completeEvent: (id: string) => Promise<void>;
+  readonly uncompleteEvent: (id: string) => Promise<void>;
+  readonly clearError: () => void;
+  readonly clearAllEvents: () => Promise<void>;
+}
+
+type CalendarEventsStore = CalendarEventsState & CalendarEventsActions;
+
+const generateId = (): string => `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+const persistEvents = async (events: CalendarEvent[]): Promise<void> => {
+  try {
+    await zustandStorage.setItem(STORAGE_KEY, JSON.stringify(events));
+  } catch {
+    // Silent fail
+  }
+};
+
+export const useCalendarEvents = create<CalendarEventsStore>()((set, get) => ({
+  events: [],
+  isLoading: false,
+  error: null,
+
+  loadEvents: async () => {
+    set({ isLoading: true, error: null });
+    try {
+      const json = await zustandStorage.getItem(STORAGE_KEY);
+      if (!json) {
+        set({ isLoading: false });
+        return;
+      }
+
+      const events = JSON.parse(json) as CalendarEvent[];
+
+      if (events && events.length > 0) {
+        const hydratedEvents = events.map((event) => ({
+          ...event,
+          createdAt: new Date(event.createdAt),
+          updatedAt: new Date(event.updatedAt),
+        }));
+        set({ events: hydratedEvents, isLoading: false });
+      } else {
+        set({ isLoading: false });
+      }
+    } catch {
+      set({ error: 'Failed to load events', isLoading: false });
+    }
+  },
+
+  addEvent: async (request) => {
+    set({ isLoading: true, error: null });
+    try {
+      const newEvent: CalendarEvent = {
+        id: generateId(),
+        ...request,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      const { events } = get();
+      const updatedEvents = [...events, newEvent];
+
+      await persistEvents(updatedEvents);
+      set({ events: updatedEvents, isLoading: false });
+    } catch {
+      set({ error: 'Failed to add event', isLoading: false });
+    }
+  },
+
+  updateEvent: async (request) => {
+    set({ isLoading: true, error: null });
+    try {
+      const { events } = get();
+      const updatedEvents = events.map((event) =>
+        event.id === request.id
+          ? { ...event, ...request, updatedAt: new Date() }
+          : event
+      );
+
+      await persistEvents(updatedEvents);
+      set({ events: updatedEvents, isLoading: false });
+    } catch {
+      set({ error: 'Failed to update event', isLoading: false });
+    }
+  },
+
+  deleteEvent: async (id) => {
+    set({ isLoading: true, error: null });
+    try {
+      const { events } = get();
+      const updatedEvents = events.filter((event) => event.id !== id);
+
+      await persistEvents(updatedEvents);
+      set({ events: updatedEvents, isLoading: false });
+    } catch {
+      set({ error: 'Failed to delete event', isLoading: false });
+    }
+  },
+
+  completeEvent: async (id) => {
+    set({ isLoading: true, error: null });
+    try {
+      const { events } = get();
+      const updatedEvents = events.map((event) =>
+        event.id === id
+          ? { ...event, completed: true, updatedAt: new Date() }
+          : event
+      );
+
+      await persistEvents(updatedEvents);
+      set({ events: updatedEvents, isLoading: false });
+    } catch {
+      set({ error: 'Failed to complete event', isLoading: false });
+    }
+  },
+
+  uncompleteEvent: async (id) => {
+    set({ isLoading: true, error: null });
+    try {
+      const { events } = get();
+      const updatedEvents = events.map((event) =>
+        event.id === id
+          ? { ...event, completed: false, updatedAt: new Date() }
+          : event
+      );
+
+      await persistEvents(updatedEvents);
+      set({ events: updatedEvents, isLoading: false });
+    } catch {
+      set({ error: 'Failed to uncomplete event', isLoading: false });
+    }
+  },
+
+  clearError: () => set({ error: null }),
+
+  clearAllEvents: async () => {
+    set({ isLoading: true, error: null });
+    try {
+      await zustandStorage.removeItem(STORAGE_KEY);
+      set({ events: [], isLoading: false });
+    } catch {
+      set({ error: 'Failed to clear events', isLoading: false });
+    }
+  },
+}));