@umituz/react-native-design-system 2.3.13 → 2.3.15

package/src/molecules/calendar/domain/repositories/ICalendarRepository.ts

@@ -0,0 +1,120 @@
+/**
+ * ICalendarRepository Interface
+ *
+ * Port (interface) for calendar data access operations.
+ * Implementations can use any storage mechanism (AsyncStorage, SQLite, etc.)
+ *
+ * Design Philosophy:
+ * - Repository pattern (DDD)
+ * - Storage-agnostic
+ * - CRUD operations for calendar events
+ * - Query methods for finding events
+ */
+
+import type {
+  CalendarEvent,
+  CreateCalendarEventRequest,
+  UpdateCalendarEventRequest,
+} from '../entities/CalendarEvent.entity';
+
+export interface ICalendarRepository {
+  /**
+   * Get all calendar events
+   * @returns Promise resolving to array of all events
+   */
+  getAllEvents(): Promise<CalendarEvent[]>;
+
+  /**
+   * Get a calendar event by ID
+   * @param id - Event ID
+   * @returns Promise resolving to event or null if not found
+   */
+  getEventById(id: string): Promise<CalendarEvent | null>;
+
+  /**
+   * Get events for a specific date
+   * @param date - Date string in YYYY-MM-DD format
+   * @returns Promise resolving to array of events for that date
+   */
+  getEventsByDate(date: string): Promise<CalendarEvent[]>;
+
+  /**
+   * Get events within a date range
+   * @param startDate - Start date (YYYY-MM-DD)
+   * @param endDate - End date (YYYY-MM-DD)
+   * @returns Promise resolving to array of events in range
+   */
+  getEventsByDateRange(startDate: string, endDate: string): Promise<CalendarEvent[]>;
+
+  /**
+   * Get events for a specific month
+   * @param year - Year (e.g., 2024)
+   * @param month - Month (0-indexed: 0 = January, 11 = December)
+   * @returns Promise resolving to array of events in that month
+   */
+  getEventsByMonth(year: number, month: number): Promise<CalendarEvent[]>;
+
+  /**
+   * Create a new calendar event
+   * @param request - Event creation data
+   * @returns Promise resolving to created event
+   */
+  createEvent(request: CreateCalendarEventRequest): Promise<CalendarEvent>;
+
+  /**
+   * Update an existing calendar event
+   * @param request - Event update data (must include id)
+   * @returns Promise resolving to updated event
+   */
+  updateEvent(request: UpdateCalendarEventRequest): Promise<CalendarEvent>;
+
+  /**
+   * Delete a calendar event
+   * @param id - Event ID to delete
+   * @returns Promise resolving to void
+   */
+  deleteEvent(id: string): Promise<void>;
+
+  /**
+   * Delete all events for a specific date
+   * @param date - Date string in YYYY-MM-DD format
+   * @returns Promise resolving to number of deleted events
+   */
+  deleteEventsByDate(date: string): Promise<number>;
+
+  /**
+   * Mark an event as completed
+   * @param id - Event ID
+   * @returns Promise resolving to updated event
+   */
+  completeEvent(id: string): Promise<CalendarEvent>;
+
+  /**
+   * Mark an event as incomplete
+   * @param id - Event ID
+   * @returns Promise resolving to updated event
+   */
+  uncompleteEvent(id: string): Promise<CalendarEvent>;
+
+  /**
+   * Search events by title
+   * @param query - Search query string
+   * @returns Promise resolving to array of matching events
+   */
+  searchEvents(query: string): Promise<CalendarEvent[]>;
+
+  /**
+   * Get upcoming events (from today onwards)
+   * @param limit - Maximum number of events to return
+   * @returns Promise resolving to array of upcoming events
+   */
+  getUpcomingEvents(limit?: number): Promise<CalendarEvent[]>;
+
+  /**
+   * Get completed events count for a date range
+   * @param startDate - Start date (YYYY-MM-DD)
+   * @param endDate - End date (YYYY-MM-DD)
+   * @returns Promise resolving to count of completed events
+   */
+  getCompletedEventsCount(startDate: string, endDate: string): Promise<number>;
+}

package/src/molecules/calendar/index.ts

@@ -0,0 +1,98 @@
+/**
+ * Calendar Domain - Barrel Export
+ *
+ * Public API for the calendar domain.
+ * Provides generic, reusable calendar functionality for all factory-generated apps.
+ *
+ * Features:
+ * - Timezone-aware calendar generation (built-in DateUtilities)
+ * - Generic event system (workouts, habits, tasks, etc.)
+ * - Month/Week/Day views
+ * - Event CRUD operations with persistence
+ * - Completion tracking
+ * - Recurring events support
+ * - **NEW:** System calendar sync (expo-calendar) - iOS/Android only
+ *
+ * Usage:
+ * ```tsx
+ * import { useCalendar, AtomicCalendar, useSystemCalendar } from '@umituz/react-native-calendar';
+ *
+ * const MyScreen = () => {
+ *   const { days, selectedDate, actions } = useCalendar();
+ *   const {
+ *     systemCalendars,
+ *     permission,
+ *     requestPermission,
+ *     syncEventToCalendar,
+ *   } = useSystemCalendar();
+ *
+ *   // Request permission to access device calendar
+ *   useEffect(() => {
+ *     requestPermission();
+ *   }, []);
+ *
+ *   // Sync event to device calendar
+ *   const handleCreateEvent = async (eventData) => {
+ *     const event = await actions.addEvent(eventData);
+ *     await syncEventToCalendar(event); // Sync to iOS/Android calendar
+ *   };
+ *
+ *   return (
+ *     <AtomicCalendar
+ *       days={days}
+ *       selectedDate={selectedDate}
+ *       onDateSelect={actions.setSelectedDate}
+ *     />
+ *   );
+ * };
+ * ```
+ */
+
+// Domain Entities
+export type {
+  CalendarEvent,
+  CreateCalendarEventRequest,
+  UpdateCalendarEventRequest,
+  SystemCalendar,
+  CalendarPermissionResult,
+} from './domain/entities/CalendarEvent.entity';
+
+export type {
+  CalendarDay,
+  CalendarMonth,
+  CalendarWeek,
+} from './domain/entities/CalendarDay.entity';
+
+// Domain Repositories
+export type { ICalendarRepository } from './domain/repositories/ICalendarRepository';
+
+// Infrastructure Services
+export { CalendarService } from './infrastructure/services/CalendarService';
+export { CalendarPermissions } from './infrastructure/services/CalendarPermissions';
+export { CalendarEvents } from './infrastructure/services/CalendarEvents';
+export { CalendarGeneration } from './infrastructure/services/CalendarGeneration';
+export { CalendarSync } from './infrastructure/services/CalendarSync';
+
+// Infrastructure Utils
+export { DateUtilities } from './infrastructure/utils/DateUtilities';
+
+// Infrastructure Storage
+export {
+  useCalendarStore,
+  type CalendarViewMode,
+} from './infrastructure/storage/CalendarStore';
+
+// Presentation Hooks
+export {
+  useCalendar,
+  useCalendarNavigation,
+  useCalendarEvents,
+  useSystemCalendar,
+  type UseCalendarReturn,
+} from './presentation/hooks/useCalendar';
+
+// Presentation Components
+export {
+  AtomicCalendar,
+  type AtomicCalendarProps,
+} from './presentation/components/AtomicCalendar';

package/src/molecules/calendar/infrastructure/services/CalendarEvents.ts

@@ -0,0 +1,196 @@
+/**
+ * Calendar Events Service
+ *
+ * Handles CRUD operations for calendar events.
+ *
+ * SOLID: Single Responsibility - Only event operations
+ * DRY: Centralized event management
+ * KISS: Simple event interface
+ */
+
+import * as Calendar from 'expo-calendar';
+import { Platform } from 'react-native';
+import { DateUtilities } from '../utils/DateUtilities';
+import { CalendarPermissions } from './CalendarPermissions';
+import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarEvents {
+  /**
+   * Create event in system calendar
+   */
+  static async createEvent(
+    event: CalendarEvent,
+    calendar: SystemCalendar
+  ): Promise<{ success: boolean; eventId?: string; error?: string }> {
+    try {
+      if (Platform.OS === 'web') {
+        return { success: false, error: 'Calendar sync not supported on web' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      const eventData = this.buildEventData(event);
+      const systemEventId = await Calendar.createEventAsync(calendar.id, eventData);
+
+      return {
+        success: true,
+        eventId: systemEventId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create event'
+      };
+    }
+  }
+
+  /**
+   * Update event in system calendar
+   */
+  static async updateEvent(
+    event: CalendarEvent
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      if (Platform.OS === 'web' || !event.systemCalendar?.eventId) {
+        return { success: false, error: 'No system calendar data' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      const eventData = this.buildEventData(event);
+      await Calendar.updateEventAsync(event.systemCalendar.eventId, eventData);
+
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to update event'
+      };
+    }
+  }
+
+  /**
+   * Delete event from system calendar
+   */
+  static async deleteEvent(
+    eventId: string
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      if (Platform.OS === 'web') {
+        return { success: false, error: 'Calendar sync not supported on web' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      await Calendar.deleteEventAsync(eventId);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to delete event'
+      };
+    }
+  }
+
+  /**
+   * Get events from system calendar
+   */
+  static async getSystemEvents(
+    calendarId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<CalendarEvent[]> {
+    try {
+      if (Platform.OS === 'web') {
+        return [];
+      }
+
+      const permission = await CalendarPermissions.hasPermissions();
+      if (!permission) {
+        return [];
+      }
+
+      const systemEvents = await Calendar.getEventsAsync(
+        [calendarId],
+        startDate,
+        endDate
+      );
+
+      return systemEvents.map((event: Calendar.Event) => this.mapSystemEventToCalendarEvent(event));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Build event data for system calendar
+   */
+  private static buildEventData(event: CalendarEvent) {
+    const [year, month, day] = event.date.split('-').map(Number);
+    let startDate = new Date(year, month - 1, day);
+    let endDate = new Date(startDate);
+
+    // Set time if provided
+    if (event.time) {
+      const [hours, minutes] = event.time.split(':').map(Number);
+      startDate.setHours(hours, minutes, 0, 0);
+      endDate.setHours(hours, minutes, 0, 0);
+    }
+
+    // Set duration
+    if (event.duration) {
+      endDate.setMinutes(endDate.getMinutes() + event.duration);
+    } else {
+      endDate.setHours(endDate.getHours() + 1); // Default 1 hour
+    }
+
+    // Create reminders
+    const alarms = event.reminders?.map(minutesBefore => ({
+      relativeOffset: -minutesBefore
+    }));
+
+    return {
+      title: event.title,
+      startDate,
+      endDate,
+      notes: event.description,
+      location: event.location,
+      alarms,
+      timeZone: DateUtilities.getCurrentTimezone()
+    };
+  }
+
+  /**
+   * Map system calendar event to domain event
+   */
+  private static mapSystemEventToCalendarEvent(systemEvent: any): CalendarEvent {
+    return {
+      id: systemEvent.id,
+      title: systemEvent.title || '',
+      description: systemEvent.notes || '',
+      date: DateUtilities.formatDateToString(systemEvent.startDate),
+      time: DateUtilities.formatTimeToString(systemEvent.startDate),
+      duration: systemEvent.endDate && systemEvent.startDate
+        ? (systemEvent.endDate.getTime() - systemEvent.startDate.getTime()) / (1000 * 60)
+        : undefined,
+      location: systemEvent.location || '',
+      reminders: systemEvent.alarms?.map((alarm: any) => -alarm.relativeOffset) || [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      systemCalendar: {
+        calendarId: systemEvent.calendarId,
+        eventId: systemEvent.id,
+        lastSyncedAt: new Date()
+      }
+    };
+  }
+}

package/src/molecules/calendar/infrastructure/services/CalendarGeneration.ts

@@ -0,0 +1,172 @@
+/**
+ * Calendar Generation Service
+ *
+ * Generates calendar grids and layouts.
+ *
+ * SOLID: Single Responsibility - Only calendar generation
+ * DRY: Reusable calendar generation logic
+ * KISS: Simple calendar grid creation
+ */
+
+import { DateUtilities } from '../utils/DateUtilities';
+import type { CalendarDay } from '../../domain/entities/CalendarDay.entity';
+import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarGeneration {
+  /**
+   * Generate calendar days for a specific month
+   * Returns 42 days (6 weeks) including days from prev/next months
+   */
+  static generateMonthDays(
+    year: number,
+    month: number,
+    events: CalendarEvent[] = []
+  ): CalendarDay[] {
+    const firstDay = new Date(year, month, 1);
+    const startDate = new Date(firstDay);
+
+    // Start from Sunday of the week containing the 1st
+    startDate.setDate(startDate.getDate() - firstDay.getDay());
+
+    const days: CalendarDay[] = [];
+    const today = new Date();
+
+    // Generate 42 days (6 weeks)
+    for (let i = 0; i < 42; i++) {
+      const currentDate = DateUtilities.addDays(startDate, i);
+      const dayEvents = this.getEventsForDate(currentDate, events);
+
+      days.push({
+        date: currentDate,
+        isCurrentMonth: currentDate.getMonth() === month,
+        isToday: DateUtilities.isSameDay(currentDate, today),
+        isSelected: false,
+        events: dayEvents
+      });
+    }
+
+    return days;
+  }
+
+  /**
+   * Generate calendar days for a specific week
+   */
+  static generateWeekDays(
+    startDate: Date,
+    events: CalendarEvent[] = []
+  ): CalendarDay[] {
+    const days: CalendarDay[] = [];
+    const today = new Date();
+
+    for (let i = 0; i < 7; i++) {
+      const currentDate = DateUtilities.addDays(startDate, i);
+      const dayEvents = this.getEventsForDate(currentDate, events);
+
+      days.push({
+        date: currentDate,
+        isCurrentMonth: true, // All days in week view are "current"
+        isToday: DateUtilities.isSameDay(currentDate, today),
+        isSelected: false,
+        events: dayEvents
+      });
+    }
+
+    return days;
+  }
+
+  /**
+   * Get events for a specific date
+   */
+  static getEventsForDate(date: Date, allEvents: CalendarEvent[]): CalendarEvent[] {
+    const dateStr = DateUtilities.formatDateToString(date);
+    return allEvents.filter(event => event.date === dateStr);
+  }
+
+  /**
+   * Get events in date range
+   */
+  static getEventsInRange(
+    startDate: Date,
+    endDate: Date,
+    events: CalendarEvent[]
+  ): CalendarEvent[] {
+    const startStr = DateUtilities.formatDateToString(startDate);
+    const endStr = DateUtilities.formatDateToString(endDate);
+
+    return events.filter(event => event.date >= startStr && event.date <= endStr);
+  }
+
+  /**
+   * Navigate to previous month
+   */
+  static getPreviousMonth(currentDate: Date): Date {
+    const newDate = new Date(currentDate);
+    newDate.setMonth(newDate.getMonth() - 1);
+    return newDate;
+  }
+
+  /**
+   * Navigate to next month
+   */
+  static getNextMonth(currentDate: Date): Date {
+    const newDate = new Date(currentDate);
+    newDate.setMonth(newDate.getMonth() + 1);
+    return newDate;
+  }
+
+  /**
+   * Navigate to previous week
+   */
+  static getPreviousWeek(currentDate: Date): Date {
+    return DateUtilities.addDays(currentDate, -7);
+  }
+
+  /**
+   * Navigate to next week
+   */
+  static getNextWeek(currentDate: Date): Date {
+    return DateUtilities.addDays(currentDate, 7);
+  }
+
+  /**
+   * Check if date is today
+   */
+  static isToday(date: Date): boolean {
+    return DateUtilities.isToday(date);
+  }
+
+  /**
+   * Check if two dates are the same day
+   */
+  static isSameDay(date1: Date, date2: Date): boolean {
+    return DateUtilities.isSameDay(date1, date2);
+  }
+
+  /**
+   * Format date for display
+   */
+  static formatDate(date: Date): string {
+    return DateUtilities.formatDateToString(date);
+  }
+
+  /**
+   * Get month name
+   */
+  static getMonthName(date: Date): string {
+    return date.toLocaleDateString('en-US', { month: 'long' });
+  }
+
+  /**
+   * Get weekday name
+   */
+  static getWeekdayName(date: Date): string {
+    return date.toLocaleDateString('en-US', { weekday: 'long' });
+  }
+
+  /**
+   * Get short weekday name
+   */
+  static getShortWeekdayName(date: Date): string {
+    return date.toLocaleDateString('en-US', { weekday: 'short' });
+  }
+}

package/src/molecules/calendar/infrastructure/services/CalendarPermissions.ts

@@ -0,0 +1,92 @@
+/**
+ * Calendar Permissions Service
+ *
+ * Handles calendar permission requests and status checks.
+ *
+ * SOLID: Single Responsibility - Only permission operations
+ * DRY: Centralized permission logic
+ * KISS: Simple permission interface
+ */
+
+import * as Calendar from 'expo-calendar';
+import { Platform } from 'react-native';
+import type { CalendarPermissionResult } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarPermissions {
+  /**
+   * Request calendar permissions
+   *
+   * @returns Promise with permission result
+   */
+  static async requestPermissions(): Promise<CalendarPermissionResult> {
+    try {
+      if (Platform.OS === 'web') {
+        return {
+          granted: false,
+          canAskAgain: false,
+          status: 'denied'
+        };
+      }
+
+      const { status, canAskAgain } = await Calendar.requestCalendarPermissionsAsync();
+
+      return {
+        granted: status === 'granted',
+        canAskAgain,
+        status
+      };
+    } catch {
+      return {
+        granted: false,
+        canAskAgain: false,
+        status: 'error'
+      };
+    }
+  }
+
+  /**
+   * Check if calendar permissions are granted
+   *
+   * @returns Promise with permission status
+   */
+  static async hasPermissions(): Promise<boolean> {
+    try {
+      if (Platform.OS === 'web') {
+        return false;
+      }
+
+      const { status } = await Calendar.getCalendarPermissionsAsync();
+      return status === 'granted';
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get current permission status
+   *
+   * @returns Promise with current status
+   */
+  static async getPermissionStatus(): Promise<CalendarPermissionResult['status']> {
+    try {
+      if (Platform.OS === 'web') {
+        return 'denied';
+      }
+
+      const { status } = await Calendar.getCalendarPermissionsAsync();
+      return status;
+    } catch {
+      return 'error';
+    }
+  }
+}
+
+
+
+
+
+
+
+
+
+