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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.3.15",
+  "version": "2.3.17",
   "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive and safe area utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -60,7 +60,6 @@
     "@umituz/react-native-localization": "latest",
     "@umituz/react-native-uuid": "latest",
     "expo-application": ">=5.0.0",
-    "expo-calendar": ">=13.0.0",
     "expo-clipboard": ">=8.0.0",
     "expo-crypto": ">=13.0.0",
     "expo-device": ">=5.0.0",
@@ -114,7 +113,6 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-native": "^5.0.0",
     "expo-application": "~5.9.1",
-    "expo-calendar": "~14.0.0",
     "expo-clipboard": "~8.0.7",
     "expo-crypto": "~14.0.0",
     "expo-device": "~7.0.2",

package/src/index.ts

@@ -411,6 +411,20 @@ export {
   type CountdownTarget,
   type CountdownFormatOptions,
   type CountdownDisplayConfig,
+  // Animation
+  Animated,
+  useSharedValue,
+  useAnimatedStyle,
+  withTiming,
+  withSpring,
+  withSequence,
+  withRepeat,
+  runOnJS,
+  cancelAnimation,
+  Easing,
+  type SharedValue,
+  type WithTimingConfig,
+  type WithSpringConfig,
 } from './molecules';
 
 // =============================================================================

package/src/molecules/calendar/domain/entities/CalendarEvent.entity.ts

@@ -74,26 +74,6 @@ export interface CalendarEvent {
    */
   reminders?: number[];
 
-  /**
-   * System calendar sync (expo-calendar integration)
-   */
-  systemCalendar?: {
-    /**
-     * System calendar ID where event is synced
-     */
-    calendarId: string;
-
-    /**
-     * System event ID from device calendar
-     */
-    eventId: string;
-
-    /**
-     * Last sync timestamp
-     */
-    lastSyncedAt: Date;
-  };
-
   /**
    * App-specific metadata
    * Use this for domain-specific properties
@@ -158,7 +138,6 @@ export interface CreateCalendarEventRequest {
   reminders?: number[];
   metadata?: unknown;
   recurring?: CalendarEvent['recurring'];
-  syncToSystemCalendar?: boolean; // Auto-sync to device calendar
 }
 
 /**
@@ -177,26 +156,4 @@ export interface UpdateCalendarEventRequest {
   reminders?: number[];
   metadata?: unknown;
   recurring?: CalendarEvent['recurring'];
-  systemCalendar?: CalendarEvent['systemCalendar'];
-}
-
-/**
- * System calendar list item
- */
-export interface SystemCalendar {
-  id: string;
-  title: string;
-  color: string;
-  source: string;
-  isPrimary: boolean;
-  allowsModifications: boolean;
-}
-
-/**
- * Calendar permission result
- */
-export interface CalendarPermissionResult {
-  granted: boolean;
-  canAskAgain: boolean;
-  status: string;
 }

package/src/molecules/calendar/index.ts

@@ -11,31 +11,13 @@
  * - 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';
+ * import { useCalendar, AtomicCalendar } from '@umituz/react-native-design-system';
  *
  * 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
@@ -53,8 +35,6 @@ export type {
   CalendarEvent,
   CreateCalendarEventRequest,
   UpdateCalendarEventRequest,
-  SystemCalendar,
-  CalendarPermissionResult,
 } from './domain/entities/CalendarEvent.entity';
 
 export type {
@@ -68,10 +48,7 @@ export type { ICalendarRepository } from './domain/repositories/ICalendarReposit
 
 // 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';
@@ -87,7 +64,6 @@ export {
   useCalendar,
   useCalendarNavigation,
   useCalendarEvents,
-  useSystemCalendar,
   type UseCalendarReturn,
 } from './presentation/hooks/useCalendar';
 

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

@@ -10,12 +10,8 @@
  */
 
 import type { CalendarDay, CalendarWeek } from '../../domain/entities/CalendarDay.entity';
-import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
+import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
 import { CalendarGeneration } from './CalendarGeneration';
-import { CalendarPermissions } from './CalendarPermissions';
-// CalendarEvents is not used in this facade
-// import { CalendarEvents } from './CalendarEvents';
-import { CalendarSync } from './CalendarSync';
 import { DateUtilities } from '../utils/DateUtilities';
 
 /**
@@ -79,48 +75,6 @@ export class CalendarService {
     return CalendarGeneration.getNextWeek(currentDate);
   }
 
-  /**
-   * Request calendar permissions
-   */
-  static async requestPermissions() {
-    return CalendarPermissions.requestPermissions();
-  }
-
-  /**
-   * Check if permissions are granted
-   */
-  static async hasPermissions(): Promise<boolean> {
-    return CalendarPermissions.hasPermissions();
-  }
-
-  /**
-   * Sync event to system calendar
-   */
-  static async syncToSystemCalendar(event: CalendarEvent) {
-    return CalendarSync.syncToSystemCalendar(event);
-  }
-
-  /**
-   * Update system calendar event
-   */
-  static async updateSystemCalendarEvent(event: CalendarEvent) {
-    return CalendarSync.updateSystemCalendarEvent(event);
-  }
-
-  /**
-   * Remove event from system calendar
-   */
-  static async removeFromSystemCalendar(eventId: string) {
-    return CalendarSync.removeFromSystemCalendar(eventId);
-  }
-
-  /**
-   * Get system calendars
-   */
-  static async getSystemCalendars(): Promise<SystemCalendar[]> {
-    return CalendarSync.getSystemCalendars();
-  }
-
   /**
    * Get events for a specific date
    */

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

@@ -26,15 +26,11 @@
  * ```
  */
 
-import { useMemo, useEffect, useState, useCallback } from 'react';
+import { useMemo, useEffect } from 'react';
 import { useCalendarStore, type CalendarViewMode } from '../../infrastructure/storage/CalendarStore';
 import { CalendarService } from '../../infrastructure/services/CalendarService';
 import type { CalendarDay } from '../../domain/entities/CalendarDay.entity';
-import type {
-  CalendarEvent,
-  SystemCalendar,
-  CalendarPermissionResult,
-} from '../../domain/entities/CalendarEvent.entity';
+import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
 
 /**
  * Calendar hook return type
@@ -182,175 +178,3 @@ export const useCalendarEvents = () => {
     clearError,
   };
 };
-
-/**
- * Hook for system calendar integration (expo-calendar)
- *
- * USAGE:
- * ```tsx
- * const {
- *   systemCalendars,
- *   permission,
- *   requestPermission,
- *   syncEventToCalendar,
- *   updateSyncedEvent,
- *   deleteSyncedEvent,
- * } = useSystemCalendar();
- *
- * // Request permission
- * const granted = await requestPermission();
- *
- * // Sync event to device calendar
- * await syncEventToCalendar(event);
- * ```
- */
-export const useSystemCalendar = () => {
-  const [systemCalendars, setSystemCalendars] = useState<SystemCalendar[]>([]);
-  const [permission, setPermission] = useState<CalendarPermissionResult | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-
-  const { actions } = useCalendarStore((state) => state);
-
-  /**
-   * Request calendar permissions
-   */
-  const requestPermission = useCallback(async (): Promise<boolean> => {
-    setIsLoading(true);
-    try {
-      const result = await CalendarService.requestPermissions();
-      setPermission(result);
-      return result.granted;
-    } catch {
-      return false;
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-
-  /**
-   * Load system calendars
-   */
-  const loadSystemCalendars = useCallback(async () => {
-    setIsLoading(true);
-    try {
-      const calendars = await CalendarService.getSystemCalendars();
-      setSystemCalendars(calendars);
-    } catch {
-      setSystemCalendars([]);
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-
-  /**
-   * Sync event to system calendar
-   */
-  const syncEventToCalendar = useCallback(
-    async (event: CalendarEvent): Promise<boolean> => {
-      setIsLoading(true);
-      try {
-        const result = await CalendarService.syncToSystemCalendar(event);
-
-        if (result.success && result.eventId && result.calendarId) {
-          // Update event with system calendar info
-          await actions.updateEvent({
-            id: event.id,
-            systemCalendar: {
-              eventId: result.eventId,
-              calendarId: result.calendarId,
-              lastSyncedAt: new Date(),
-            },
-          });
-          return true;
-        }
-
-        return false;
-      } catch {
-        return false;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [actions]
-  );
-
-  /**
-   * Update synced event in system calendar
-   */
-  const updateSyncedEvent = useCallback(async (event: CalendarEvent): Promise<boolean> => {
-    if (!event.systemCalendar) return false;
-
-    setIsLoading(true);
-    try {
-      const result = await CalendarService.updateSystemCalendarEvent(event);
-
-      if (result.success) {
-        // Update last synced timestamp
-        await actions.updateEvent({
-          id: event.id,
-          systemCalendar: {
-            ...event.systemCalendar,
-            lastSyncedAt: new Date(),
-          },
-        });
-        return true;
-      }
-
-      return false;
-    } catch {
-      return false;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [actions]);
-
-  /**
-   * Delete synced event from system calendar
-   */
-  const deleteSyncedEvent = useCallback(
-    async (event: CalendarEvent): Promise<boolean> => {
-      if (!event.systemCalendar) return false;
-
-      setIsLoading(true);
-      try {
-        const result = await CalendarService.removeFromSystemCalendar(
-          event.systemCalendar.eventId
-        );
-
-        if (result.success) {
-          // Remove system calendar info from event
-          await actions.updateEvent({
-            id: event.id,
-            systemCalendar: undefined,
-          });
-          return true;
-        }
-
-        return false;
-      } catch {
-        return false;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [actions]
-  );
-
-  // Load calendars when permission is granted
-  useEffect(() => {
-    if (permission?.granted) {
-      loadSystemCalendars();
-    }
-  }, [permission, loadSystemCalendars]);
-
-  return {
-    systemCalendars,
-    permission,
-    isLoading,
-    requestPermission,
-    loadSystemCalendars,
-    syncEventToCalendar,
-    updateSyncedEvent,
-    deleteSyncedEvent,
-  };
-};

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

@@ -1,196 +0,0 @@
-/**
- * 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/CalendarPermissions.ts

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

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

@@ -1,205 +0,0 @@
-/**
- * Calendar Sync Service
- *
- * Handles synchronization with system calendar.
- *
- * SOLID: Single Responsibility - Only sync operations
- * DRY: Centralized sync logic
- * KISS: Simple sync interface
- */
-
-import * as Calendar from 'expo-calendar';
-import { Platform } from 'react-native';
-import { CalendarPermissions } from './CalendarPermissions';
-import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
-
-export class CalendarSync {
-  /**
-   * Sync event to system calendar
-   */
-  static async syncToSystemCalendar(
-    event: CalendarEvent
-  ): Promise<{
-    success: boolean;
-    eventId?: string;
-    calendarId?: 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 primaryCal = await this.getPrimaryCalendar();
-      if (!primaryCal) {
-        return { success: false, error: 'No writable calendar found' };
-      }
-
-      const eventData = this.buildSystemEventData(event);
-      const systemEventId = await Calendar.createEventAsync(primaryCal.id, eventData);
-
-      return {
-        success: true,
-        eventId: systemEventId,
-        calendarId: primaryCal.id
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to sync to calendar'
-      };
-    }
-  }
-
-  /**
-   * Update system calendar event
-   */
-  static async updateSystemCalendarEvent(
-    event: CalendarEvent
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      if (Platform.OS === 'web' || !event.systemCalendar) {
-        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.buildSystemEventData(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'
-      };
-    }
-  }
-
-  /**
-   * Remove event from system calendar
-   */
-  static async removeFromSystemCalendar(
-    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 remove from calendar'
-      };
-    }
-  }
-
-  /**
-   * Get primary writable calendar
-   */
-  static async getPrimaryCalendar(): Promise<SystemCalendar | null> {
-    try {
-      if (Platform.OS === 'web') {
-        return null;
-      }
-
-      const calendars = await Calendar.getCalendarsAsync();
-      const writableCalendars = calendars.filter((cal: Calendar.Calendar) =>
-        cal.allowsModifications &&
-        (cal.source.type === 'local' || cal.source.type === 'caldav')
-      );
-
-      // Prefer default calendar, fallback to first writable
-      const primaryCal = writableCalendars.find((cal: Calendar.Calendar) => cal.isPrimary) || writableCalendars[0];
-      if (!primaryCal) return null;
-
-      return {
-        id: primaryCal.id,
-        title: primaryCal.title,
-        color: primaryCal.color,
-        allowsModifications: primaryCal.allowsModifications,
-        source: primaryCal.source.name,
-        isPrimary: primaryCal.isPrimary || false
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Get all system calendars
-   */
-  static async getSystemCalendars(): Promise<SystemCalendar[]> {
-    try {
-      if (Platform.OS === 'web') {
-        return [];
-      }
-
-      const calendars = await Calendar.getCalendarsAsync();
-      return calendars.map((cal: Calendar.Calendar) => ({
-        id: cal.id,
-        title: cal.title,
-        color: cal.color,
-        allowsModifications: cal.allowsModifications,
-        source: cal.source.name,
-        isPrimary: cal.isPrimary || false
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Build system calendar event data
-   */
-  private static buildSystemEventData(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: Intl.DateTimeFormat().resolvedOptions().timeZone
-    };
-  }
-}