@umituz/react-native-design-system 2.5.9 → 2.5.11

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

@@ -1,19 +1,17 @@
 /**
- * Calendar Store (Zustand)
+ * Calendar Store (Zustand via @umituz/react-native-storage)
  *
  * Global state management for calendar functionality.
  * Manages calendar view state, selected date, and events.
  *
  * Design Philosophy:
- * - Zustand for lightweight state
- * - AsyncStorage for persistence
+ * - Uses createStore from @umituz/react-native-storage
+ * - AsyncStorage persistence built-in
  * - Generic event handling
  * - Timezone-aware via CalendarService
  */
 
-import { create, type StateCreator } from 'zustand';
-import { persist, createJSONStorage, type PersistOptions } from 'zustand/middleware';
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import { createStore, storageRepository } from '@umituz/react-native-storage';
 import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
 import { CalendarService } from '../services/CalendarService';
 
@@ -23,285 +21,285 @@ import { CalendarService } from '../services/CalendarService';
 export type CalendarViewMode = 'month' | 'week' | 'day' | 'list';
 
 /**
- * Calendar state interface
+ * Storage key for calendar events
+ */
+const STORAGE_KEY = 'calendar_events';
+
+/**
+ * Generate unique ID for events
+ */
+const generateId = (): string => {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+};
+
+/**
+ * Calendar state (data only)
  */
 interface CalendarState {
-  // State
   events: CalendarEvent[];
   selectedDate: Date;
   currentMonth: Date;
   viewMode: CalendarViewMode;
   isLoading: boolean;
   error: string | null;
+}
 
-  // Actions
-  actions: {
-    // 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>;
+/**
+ * Calendar actions
+ */
+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;
+  // 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;
+  // View mode
+  setViewMode: (mode: CalendarViewMode) => void;
 
-    // Utilities
-    getEventsForDate: (date: Date) => CalendarEvent[];
-    getEventsForMonth: (year: number, month: number) => CalendarEvent[];
-    clearError: () => void;
-    clearAllEvents: () => Promise<void>;
-  };
+  // Utilities
+  getEventsForDate: (date: Date) => CalendarEvent[];
+  getEventsForMonth: (year: number, month: number) => CalendarEvent[];
+  clearError: () => void;
+  clearAllEvents: () => Promise<void>;
 }
 
 /**
- * Storage key for calendar events
- */
-const STORAGE_KEY = 'calendar_events';
-
-/**
- * Generate unique ID for events
+ * Initial state
  */
-const generateId = (): string => {
-  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+const initialState: CalendarState = {
+  events: [],
+  selectedDate: new Date(),
+  currentMonth: new Date(),
+  viewMode: 'month',
+  isLoading: false,
+  error: null,
 };
 
 /**
  * Calendar Store
  */
-export const useCalendarStore = create<CalendarState>()(
-  persist(
-    (set, get) => ({
-      // Initial State
-      events: [],
-      selectedDate: new Date(),
-      currentMonth: new Date(),
-      viewMode: 'month',
-      isLoading: false,
-      error: null,
+export const useCalendarStore = createStore<CalendarState, CalendarActions>({
+  name: 'calendar-storage',
+  initialState,
+  persist: true,
+  partialize: (state) => ({ events: state.events }),
+  actions: (set, get) => ({
+    /**
+     * Load events from storage
+     */
+    loadEvents: async () => {
+      set({ isLoading: true, error: null });
+      try {
+        const stored = await storageRepository.getItem<CalendarEvent[]>(STORAGE_KEY);
+        if (stored) {
+          // Restore Date objects
+          const events = stored.map((event) => ({
+            ...event,
+            createdAt: new Date(event.createdAt),
+            updatedAt: new Date(event.updatedAt),
+          }));
+          set({ events, isLoading: false });
+        } else {
+          set({ isLoading: false });
+        }
+      } catch (error) {
+        set({
+          error: error instanceof Error ? error.message : 'Failed to load events',
+          isLoading: false,
+        });
+      }
+    },
 
-      // Actions
-      actions: {
-        /**
-         * Load events from storage
-         */
-        loadEvents: async () => {
-          set({ isLoading: true, error: null });
-          try {
-            const stored = await AsyncStorage.getItem(STORAGE_KEY);
-            if (stored) {
-              const events = JSON.parse(stored);
-              // Restore Date objects
-              events.forEach((event: CalendarEvent) => {
-                event.createdAt = new Date(event.createdAt);
-                event.updatedAt = new Date(event.updatedAt);
-              });
-              set({ events, isLoading: false });
-            } else {
-              set({ isLoading: false });
-            }
-          } catch (error) {
-            set({
-              error: error instanceof Error ? error.message : 'Failed to load events',
-              isLoading: false
-            });
-          }
-        },
+    /**
+     * Add a new event
+     */
+    addEvent: async (request: CreateCalendarEventRequest) => {
+      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);
+        set({ events, isLoading: false });
+      } catch (error) {
+        set({
+          error: error instanceof Error ? error.message : 'Failed to add event',
+          isLoading: false,
+        });
+      }
+    },
 
-        /**
-         * Add a new event
-         */
-        addEvent: async (request: CreateCalendarEventRequest) => {
-          set({ isLoading: true, error: null });
-          try {
-            const newEvent: CalendarEvent = {
-              id: generateId(),
+    /**
+     * Update an existing event
+     */
+    updateEvent: async (request: UpdateCalendarEventRequest) => {
+      set({ isLoading: true, error: null });
+      try {
+        const events = get().events.map((event) => {
+          if (event.id === request.id) {
+            return {
+              ...event,
               ...request,
-              isCompleted: false,
-              createdAt: new Date(),
               updatedAt: new Date(),
             };
-
-            const events = [...get().events, newEvent];
-            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
-            set({ events, isLoading: false });
-          } catch (error) {
-            set({
-              error: error instanceof Error ? error.message : 'Failed to add event',
-              isLoading: false
-            });
           }
-        },
+          return event;
+        });
 
-        /**
-         * Update an existing event
-         */
-        updateEvent: async (request: UpdateCalendarEventRequest) => {
-          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);
+        set({ events, isLoading: false });
+      } catch (error) {
+        set({
+          error: error instanceof Error ? error.message : 'Failed to update event',
+          isLoading: false,
+        });
+      }
+    },
 
-            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
-            set({ events, isLoading: false });
-          } catch (error) {
-            set({
-              error: error instanceof Error ? error.message : 'Failed to update event',
-              isLoading: false
-            });
-          }
-        },
+    /**
+     * Delete an event
+     */
+    deleteEvent: async (id: string) => {
+      set({ isLoading: true, error: null });
+      try {
+        const events = get().events.filter((event) => event.id !== id);
+        await storageRepository.setItem(STORAGE_KEY, events);
+        set({ events, isLoading: false });
+      } catch (error) {
+        set({
+          error: error instanceof Error ? error.message : 'Failed to delete event',
+          isLoading: false,
+        });
+      }
+    },
 
-        /**
-         * Delete an event
-         */
-        deleteEvent: async (id: string) => {
-          set({ isLoading: true, error: null });
-          try {
-            const events = get().events.filter(event => event.id !== id);
-            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
-            set({ events, isLoading: false });
-          } catch (error) {
-            set({
-              error: error instanceof Error ? error.message : 'Failed to delete event',
-              isLoading: false
-            });
-          }
-        },
-
-        /**
-         * Mark event as completed
-         */
-        completeEvent: async (id: string) => {
-          await get().actions.updateEvent({ id, isCompleted: true });
-        },
+    /**
+     * Mark event as completed
+     */
+    completeEvent: async (id: string) => {
+      await get().updateEvent({ id, isCompleted: true });
+    },
 
-        /**
-         * Mark event as incomplete
-         */
-        uncompleteEvent: async (id: string) => {
-          await get().actions.updateEvent({ id, isCompleted: false });
-        },
+    /**
+     * Mark event as incomplete
+     */
+    uncompleteEvent: async (id: string) => {
+      await get().updateEvent({ id, isCompleted: false });
+    },
 
-        /**
-         * Set selected date
-         */
-        setSelectedDate: (date: Date) => {
-          set({ selectedDate: date });
-        },
+    /**
+     * Set selected date
+     */
+    setSelectedDate: (date: Date) => {
+      set({ selectedDate: date });
+    },
 
-        /**
-         * Go to today's date
-         */
-        goToToday: () => {
-          const today = new Date();
-          set({
-            selectedDate: today,
-            currentMonth: today,
-          });
-        },
+    /**
+     * Go to today's date
+     */
+    goToToday: () => {
+      const today = new Date();
+      set({
+        selectedDate: today,
+        currentMonth: today,
+      });
+    },
 
-        /**
-         * Navigate to previous/next month
-         */
-        navigateMonth: (direction: 'prev' | 'next') => {
-          const currentMonth = get().currentMonth;
-          const newMonth = direction === 'prev'
-            ? CalendarService.getPreviousMonth(currentMonth)
-            : CalendarService.getNextMonth(currentMonth);
+    /**
+     * Navigate to previous/next month
+     */
+    navigateMonth: (direction: 'prev' | 'next') => {
+      const currentMonth = get().currentMonth;
+      const newMonth =
+        direction === 'prev'
+          ? CalendarService.getPreviousMonth(currentMonth)
+          : CalendarService.getNextMonth(currentMonth);
 
-          set({ currentMonth: newMonth });
-        },
+      set({ currentMonth: newMonth });
+    },
 
-        /**
-         * Navigate to previous/next week
-         */
-        navigateWeek: (direction: 'prev' | 'next') => {
-          const selectedDate = get().selectedDate;
-          const newDate = direction === 'prev'
-            ? CalendarService.getPreviousWeek(selectedDate)
-            : CalendarService.getNextWeek(selectedDate);
+    /**
+     * Navigate to previous/next week
+     */
+    navigateWeek: (direction: 'prev' | 'next') => {
+      const selectedDate = get().selectedDate;
+      const newDate =
+        direction === 'prev'
+          ? CalendarService.getPreviousWeek(selectedDate)
+          : CalendarService.getNextWeek(selectedDate);
 
-          set({ selectedDate: newDate });
-        },
+      set({ selectedDate: newDate });
+    },
 
-        /**
-         * Set current month directly
-         */
-        setCurrentMonth: (date: Date) => {
-          set({ currentMonth: date });
-        },
+    /**
+     * Set current month directly
+     */
+    setCurrentMonth: (date: Date) => {
+      set({ currentMonth: date });
+    },
 
-        /**
-         * Set view mode
-         */
-        setViewMode: (mode: CalendarViewMode) => {
-          set({ viewMode: mode });
-        },
+    /**
+     * Set view mode
+     */
+    setViewMode: (mode: CalendarViewMode) => {
+      set({ viewMode: mode });
+    },
 
-        /**
-         * Get events for a specific date
-         */
-        getEventsForDate: (date: Date) => {
-          const events = get().events;
-          return CalendarService.getEventsForDate(date, events);
-        },
+    /**
+     * Get events for a specific date
+     */
+    getEventsForDate: (date: Date) => {
+      const events = get().events;
+      return CalendarService.getEventsForDate(date, events);
+    },
 
-        /**
-         * Get events for a specific month
-         */
-        getEventsForMonth: (year: number, month: number) => {
-          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);
-        },
+    /**
+     * Get events for a specific month
+     */
+    getEventsForMonth: (year: number, month: number) => {
+      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
-         */
-        clearError: () => {
-          set({ error: null });
-        },
+    /**
+     * Clear error state
+     */
+    clearError: () => {
+      set({ error: null });
+    },
 
-        /**
-         * Clear all events (for testing/reset)
-         */
-        clearAllEvents: async () => {
-          set({ isLoading: true, error: null });
-          try {
-            await AsyncStorage.removeItem(STORAGE_KEY);
-            set({ events: [], isLoading: false });
-          } catch (error) {
-            set({
-              error: error instanceof Error ? error.message : 'Failed to clear events',
-              isLoading: false
-            });
-          }
-        },
-      },
-    }),
-    {
-      name: 'calendar-storage',
-      storage: createJSONStorage(() => AsyncStorage),
-      // Only persist events, not UI state
-      partialize: (state) => ({ events: state.events }),
-    }
-  )
-);
+    /**
+     * Clear all events (for testing/reset)
+     */
+    clearAllEvents: async () => {
+      set({ isLoading: true, error: null });
+      try {
+        await storageRepository.removeItem(STORAGE_KEY);
+        set({ events: [], isLoading: false });
+      } catch (error) {
+        set({
+          error: error instanceof Error ? error.message : 'Failed to clear events',
+          isLoading: false,
+        });
+      }
+    },
+  }),
+});

package/src/molecules/navigation/StackNavigator.tsx

@@ -22,14 +22,12 @@ export interface StackNavigatorProps<T extends ParamListBase> {
 export function StackNavigator<T extends ParamListBase>({ config }: StackNavigatorProps<T>) {
     const tokens = useAppDesignTokens();
 
-    // Validate configuration
-    if (__DEV__) {
-        try {
-            NavigationValidator.validateScreens(config.screens, "stack");
-            NavigationValidator.validateInitialRoute(config.initialRouteName, config.screens);
-        } catch (error) {
-            if (__DEV__) console.error('[StackNavigator] Configuration validation failed:', error);
-        }
+    // Validate configuration silently
+    try {
+        NavigationValidator.validateScreens(config.screens, "stack");
+        NavigationValidator.validateInitialRoute(config.initialRouteName, config.screens);
+    } catch {
+        // Silent validation failure
     }
 
     const { screens } = config;
@@ -55,7 +53,6 @@ export function StackNavigator<T extends ParamListBase>({ config }: StackNavigat
     }), [tokens]);
 
     if (screens.length === 0) {
-        if (__DEV__) console.warn('[StackNavigator] No screens found');
         return null;
     }
 

package/src/molecules/navigation/TabsNavigator.tsx

@@ -24,18 +24,15 @@ export function TabsNavigator<T extends ParamListBase>({
 }: TabsNavigatorProps<T>) {
     const tokens = useAppDesignTokens();
 
-    // Validate configuration
-    if (__DEV__) {
-        try {
-            NavigationValidator.validateScreens(config.screens, "tab");
-            NavigationValidator.validateInitialRoute(
-                config.initialRouteName,
-                config.screens
-            );
-        } catch (error) {
-            if (__DEV__)
-                console.error("[TabsNavigator] Configuration validation failed:", error);
-        }
+    // Validate configuration silently
+    try {
+        NavigationValidator.validateScreens(config.screens, "tab");
+        NavigationValidator.validateInitialRoute(
+            config.initialRouteName,
+            config.screens
+        );
+    } catch {
+        // Silent validation failure
     }
 
     // Memoize filtered screens
@@ -74,7 +71,6 @@ export function TabsNavigator<T extends ParamListBase>({
     );
 
     if (visibleScreens.length === 0) {
-        if (__DEV__) console.warn("[TabsNavigator] No visible screens found");
         return null;
     }
 

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

@@ -31,8 +31,6 @@ export class AppNavigation {
     static navigate(name: string, params?: object): void {
         if (this.navigationRef?.isReady()) {
             this.navigationRef.navigate(name, params);
-        } else if (__DEV__) {
-            console.warn('[AppNavigation] Navigation ref is not ready. Call setRef() first.');
         }
     }
 

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

@@ -28,10 +28,7 @@ export class LabelProcessor {
       try {
         const processedLabel = getLabel(label);
         result = typeof processedLabel === "string" ? processedLabel : label;
-      } catch (error) {
-        if (__DEV__) {
-          console.error(`[LabelProcessor] Error processing label: ${label}`, error);
-        }
+      } catch {
         result = label;
       }
     }
@@ -45,12 +42,6 @@ export class LabelProcessor {
     }
     this.labelCache.set(cacheKey, result);
     
-    // Log cache performance in development
-    if (__DEV__ && (this.cacheHits + this.cacheMisses) % 100 === 0) {
-      const hitRate = (this.cacheHits / (this.cacheHits + this.cacheMisses)) * 100;
-      console.log(`[LabelProcessor] Cache hit rate: ${hitRate.toFixed(1)}%`);
-    }
-    
     return result;
   }