Implements offline-first calendar sync infrastructure

Adds IndexedDB and operation queue for robust offline synchronization
Introduces SyncManager to handle background data synchronization
Supports local event operations with automatic remote sync queuing

Enhances application reliability and user experience in low/no connectivity scenarios

src/repositories/ApiEventRepository.ts

@@ -0,0 +1,129 @@
+import { ICalendarEvent } from '../types/CalendarTypes';
+
+/**
+ * ApiEventRepository
+ * Handles communication with backend API
+ *
+ * Used by SyncManager to send queued operations to the server
+ * NOT used directly by EventManager (which uses IndexedDBEventRepository)
+ *
+ * Future enhancements:
+ * - SignalR real-time updates
+ * - Conflict resolution
+ * - Batch operations
+ */
+export class ApiEventRepository {
+  private apiEndpoint: string;
+
+  constructor(apiEndpoint: string) {
+    this.apiEndpoint = apiEndpoint;
+  }
+
+  /**
+   * Send create operation to API
+   */
+  async sendCreate(event: ICalendarEvent): Promise<ICalendarEvent> {
+    // TODO: Implement API call
+    // const response = await fetch(`${this.apiEndpoint}/events`, {
+    //   method: 'POST',
+    //   headers: { 'Content-Type': 'application/json' },
+    //   body: JSON.stringify(event)
+    // });
+    //
+    // if (!response.ok) {
+    //   throw new Error(`API create failed: ${response.statusText}`);
+    // }
+    //
+    // return await response.json();
+
+    throw new Error('ApiEventRepository.sendCreate not implemented yet');
+  }
+
+  /**
+   * Send update operation to API
+   */
+  async sendUpdate(id: string, updates: Partial<ICalendarEvent>): Promise<ICalendarEvent> {
+    // TODO: Implement API call
+    // const response = await fetch(`${this.apiEndpoint}/events/${id}`, {
+    //   method: 'PATCH',
+    //   headers: { 'Content-Type': 'application/json' },
+    //   body: JSON.stringify(updates)
+    // });
+    //
+    // if (!response.ok) {
+    //   throw new Error(`API update failed: ${response.statusText}`);
+    // }
+    //
+    // return await response.json();
+
+    throw new Error('ApiEventRepository.sendUpdate not implemented yet');
+  }
+
+  /**
+   * Send delete operation to API
+   */
+  async sendDelete(id: string): Promise<void> {
+    // TODO: Implement API call
+    // const response = await fetch(`${this.apiEndpoint}/events/${id}`, {
+    //   method: 'DELETE'
+    // });
+    //
+    // if (!response.ok) {
+    //   throw new Error(`API delete failed: ${response.statusText}`);
+    // }
+
+    throw new Error('ApiEventRepository.sendDelete not implemented yet');
+  }
+
+  /**
+   * Fetch all events from API
+   */
+  async fetchAll(): Promise<ICalendarEvent[]> {
+    // TODO: Implement API call
+    // const response = await fetch(`${this.apiEndpoint}/events`);
+    //
+    // if (!response.ok) {
+    //   throw new Error(`API fetch failed: ${response.statusText}`);
+    // }
+    //
+    // return await response.json();
+
+    throw new Error('ApiEventRepository.fetchAll not implemented yet');
+  }
+
+  // ========================================
+  // Future: SignalR Integration
+  // ========================================
+
+  /**
+   * Initialize SignalR connection
+   * Placeholder for future implementation
+   */
+  async initializeSignalR(): Promise<void> {
+    // TODO: Setup SignalR connection
+    // - Connect to hub
+    // - Register event handlers
+    // - Handle reconnection
+    //
+    // Example:
+    // const connection = new signalR.HubConnectionBuilder()
+    //   .withUrl(`${this.apiEndpoint}/hubs/calendar`)
+    //   .build();
+    //
+    // connection.on('EventCreated', (event: ICalendarEvent) => {
+    //   // Handle remote create
+    // });
+    //
+    // connection.on('EventUpdated', (event: ICalendarEvent) => {
+    //   // Handle remote update
+    // });
+    //
+    // connection.on('EventDeleted', (eventId: string) => {
+    //   // Handle remote delete
+    // });
+    //
+    // await connection.start();
+
+    throw new Error('SignalR not implemented yet');
+  }
+}