Calendar/src/index.ts

// Main entry point for Calendar Plantempus
import { eventBus } from './core/EventBus';
import { calendarConfig } from './core/CalendarConfig';
import { CalendarTypeFactory } from './factories/CalendarTypeFactory';
import { createContainer } from './di/container';
import { TOKENS } from './di/tokens';
import { URLManager } from './utils/URLManager';
import { EventManager } from './managers/EventManager';

/**
 * Handle deep linking functionality after managers are initialized
 */
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 = eventManager.navigateToEvent(eventId);
        if (!success) {
          console.warn(`Deep linking failed: Event with ID ${eventId} not found`);
        }
      }, 500);
    }
  } catch (error) {
    console.warn('Deep linking failed:', error);
  }
}

/**
 * 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 Brandi DI container (all managers instantiated here)
    const container = createContainer();

    // Enable debug mode for development
    eventBus.setDebug(true);

    // 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(eventManager);

    // Expose to window for debugging (with proper typing)
    (window as Window & {
      calendarDebug?: {
        eventBus: typeof eventBus;
        container: typeof container;
        calendarManager: typeof calendarManager;
        eventManager: typeof eventManager;
      };
    }).calendarDebug = {
      eventBus,
      container,
      calendarManager,
      eventManager,
    };

  } catch (error) {
    throw error;
  }
}

// Initialize when DOM is ready - now handles async properly
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', () => {
    initializeCalendar().catch(error => {
      });
  });
} else {
  initializeCalendar().catch(error => {
  });
}