Implements dependency injection with Brandi

Introduces Brandi DI container for managing application dependencies.

This change replaces the existing factory pattern with a proper
dependency injection mechanism, improving code modularity,
testability, and maintainability. It configures all managers and core
services within the container, ensuring proper dependency resolution.

src/di/container.ts

@@ -0,0 +1,85 @@
+/**
+ * Brandi Dependency Injection Container Configuration
+ * Configures all bindings with proper dependency resolution
+ */
+
+import { Container } from 'brandi';
+import { TOKENS } from './tokens';
+import { eventBus } from '../core/EventBus';
+
+// Import all managers
+import { EventManager } from '../managers/EventManager';
+import { EventRenderingService } from '../renderers/EventRendererManager';
+import { GridManager } from '../managers/GridManager';
+import { ScrollManager } from '../managers/ScrollManager';
+import { NavigationManager } from '../managers/NavigationManager';
+import { ViewManager } from '../managers/ViewManager';
+import { CalendarManager } from '../managers/CalendarManager';
+import { DragDropManager } from '../managers/DragDropManager';
+import { AllDayManager } from '../managers/AllDayManager';
+import { ResizeHandleManager } from '../managers/ResizeHandleManager';
+import { EdgeScrollManager } from '../managers/EdgeScrollManager';
+import { DragHoverManager } from '../managers/DragHoverManager';
+import { HeaderManager } from '../managers/HeaderManager';
+
+/**
+ * Create and configure the DI container
+ * Using manual instantiation instead of automatic injection
+ */
+export function createContainer(): Container {
+  const container = new Container();
+
+  // Bind core services as constant
+  container.bind(TOKENS.eventBus).toConstant(eventBus);
+
+  // Create instances manually and bind as constants (singletons)
+  // This is simpler than using decorators or complex factory setup
+
+  const eventManager = new EventManager(eventBus);
+  container.bind(TOKENS.eventManager).toConstant(eventManager);
+
+  const eventRenderer = new EventRenderingService(eventBus, eventManager);
+  container.bind(TOKENS.eventRenderer).toConstant(eventRenderer);
+
+  const gridManager = new GridManager();
+  container.bind(TOKENS.gridManager).toConstant(gridManager);
+
+  const scrollManager = new ScrollManager();
+  container.bind(TOKENS.scrollManager).toConstant(scrollManager);
+
+  const navigationManager = new NavigationManager(eventBus, eventRenderer);
+  container.bind(TOKENS.navigationManager).toConstant(navigationManager);
+
+  const viewManager = new ViewManager(eventBus);
+  container.bind(TOKENS.viewManager).toConstant(viewManager);
+
+  const dragDropManager = new DragDropManager(eventBus);
+  container.bind(TOKENS.dragDropManager).toConstant(dragDropManager);
+
+  const allDayManager = new AllDayManager(eventManager);
+  container.bind(TOKENS.allDayManager).toConstant(allDayManager);
+
+  const resizeHandleManager = new ResizeHandleManager();
+  container.bind(TOKENS.resizeHandleManager).toConstant(resizeHandleManager);
+
+  const edgeScrollManager = new EdgeScrollManager(eventBus);
+  container.bind(TOKENS.edgeScrollManager).toConstant(edgeScrollManager);
+
+  const dragHoverManager = new DragHoverManager(eventBus);
+  container.bind(TOKENS.dragHoverManager).toConstant(dragHoverManager);
+
+  const headerManager = new HeaderManager();
+  container.bind(TOKENS.headerManager).toConstant(headerManager);
+
+  // CalendarManager depends on multiple managers
+  const calendarManager = new CalendarManager(
+    eventBus,
+    eventManager,
+    gridManager,
+    eventRenderer,
+    scrollManager
+  );
+  container.bind(TOKENS.calendarManager).toConstant(calendarManager);
+
+  return container;
+}

src/di/tokens.ts

@@ -0,0 +1,43 @@
+/**
+ * Dependency Injection Tokens for Brandi Container
+ * Type-safe tokens for all managers and services
+ */
+
+import { token } from 'brandi';
+import { IEventBus } from '../types/CalendarTypes';
+import { EventManager } from '../managers/EventManager';
+import { EventRenderingService } from '../renderers/EventRendererManager';
+import { GridManager } from '../managers/GridManager';
+import { ScrollManager } from '../managers/ScrollManager';
+import { NavigationManager } from '../managers/NavigationManager';
+import { ViewManager } from '../managers/ViewManager';
+import { CalendarManager } from '../managers/CalendarManager';
+import { DragDropManager } from '../managers/DragDropManager';
+import { AllDayManager } from '../managers/AllDayManager';
+import { ResizeHandleManager } from '../managers/ResizeHandleManager';
+import { EdgeScrollManager } from '../managers/EdgeScrollManager';
+import { DragHoverManager } from '../managers/DragHoverManager';
+import { HeaderManager } from '../managers/HeaderManager';
+
+/**
+ * DI Tokens - Type-safe identifiers for dependency injection
+ */
+export const TOKENS = {
+  // Core services
+  eventBus: token<IEventBus>('eventBus'),
+
+  // Managers
+  eventManager: token<EventManager>('eventManager'),
+  eventRenderer: token<EventRenderingService>('eventRenderer'),
+  gridManager: token<GridManager>('gridManager'),
+  scrollManager: token<ScrollManager>('scrollManager'),
+  navigationManager: token<NavigationManager>('navigationManager'),
+  viewManager: token<ViewManager>('viewManager'),
+  calendarManager: token<CalendarManager>('calendarManager'),
+  dragDropManager: token<DragDropManager>('dragDropManager'),
+  allDayManager: token<AllDayManager>('allDayManager'),
+  resizeHandleManager: token<ResizeHandleManager>('resizeHandleManager'),
+  edgeScrollManager: token<EdgeScrollManager>('edgeScrollManager'),
+  dragHoverManager: token<DragHoverManager>('dragHoverManager'),
+  headerManager: token<HeaderManager>('headerManager'),
+};

src/index.ts

@@ -2,24 +2,25 @@
 import { eventBus } from './core/EventBus';
 import { calendarConfig } from './core/CalendarConfig';
 import { CalendarTypeFactory } from './factories/CalendarTypeFactory';
-import { ManagerFactory } from './factories/ManagerFactory';
+import { createContainer } from './di/container';
+import { TOKENS } from './di/tokens';
 import { URLManager } from './utils/URLManager';
-import { CalendarManagers } from './types/ManagerTypes';
+import { EventManager } from './managers/EventManager';
 
 /**
  * Handle deep linking functionality after managers are initialized
  */
-async function handleDeepLinking(managers: CalendarManagers): Promise<void> {
+async function handleDeepLinking(eventManager: EventManager): Promise<void> {
   try {
     const urlManager = new URLManager(eventBus);
     const eventId = urlManager.parseEventIdFromURL();
-    
+
     if (eventId) {
       console.log(`Deep linking to event ID: ${eventId}`);
-      
+
       // Wait a bit for managers to be fully ready
       setTimeout(() => {
-        const success = managers.eventManager.navigateToEvent(eventId);
+        const success = eventManager.navigateToEvent(eventId);
         if (!success) {
           console.warn(`Deep linking failed: Event with ID ${eventId} not found`);
         }
@@ -31,40 +32,49 @@ async function handleDeepLinking(managers: CalendarManagers): Promise<void> {
 }
 
 /**
- * Initialize the calendar application with simple direct calls
+ * Initialize the calendar application using Brandi DI
  */
 async function initializeCalendar(): Promise<void> {
-  
   try {
     // Use the singleton calendar configuration
     const config = calendarConfig;
-    
+
     // Initialize the CalendarTypeFactory before creating managers
     CalendarTypeFactory.initialize();
-    
-    // Create managers using factory pattern
-    const managerFactory = ManagerFactory.getInstance();
-    const managers = managerFactory.createManagers(eventBus);
-    
+
+    // Create Brandi DI container (all managers instantiated here)
+    const container = createContainer();
+
     // Enable debug mode for development
     eventBus.setDebug(true);
-    
-    // Initialize all managers
-    await managerFactory.initializeManagers(managers);
-    
+
+    // Get managers from container
+    const calendarManager = container.get(TOKENS.calendarManager);
+    const eventManager = container.get(TOKENS.eventManager);
+    const resizeHandleManager = container.get(TOKENS.resizeHandleManager);
+
+    // Initialize managers
+    await calendarManager.initialize?.();
+    await resizeHandleManager.initialize?.();
+
     // Handle deep linking after managers are initialized
-    await handleDeepLinking(managers);
-    
+    await handleDeepLinking(eventManager);
+
     // Expose to window for debugging (with proper typing)
-    (window as Window & { 
+    (window as Window & {
       calendarDebug?: {
         eventBus: typeof eventBus;
-      } & CalendarManagers;
+        container: typeof container;
+        calendarManager: typeof calendarManager;
+        eventManager: typeof eventManager;
+      };
     }).calendarDebug = {
       eventBus,
-      ...managers
+      container,
+      calendarManager,
+      eventManager,
     };
-    
+
   } catch (error) {
     throw error;
   }