Janus007/Calendar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updates build config and removes unused dependencies

Browse source 
Migrates from Brandi DI to @novadi/core dependency injection
Simplifies project structure by removing deprecated modules
Adds Novadi unplugin to esbuild configuration for enhanced build process
This commit is contained in:
Janus C. H. Knudsen 2025-10-30 21:46:38 +01:00
parent a80e4a7603
commit 10cb3792f4
17 changed files with 531 additions and 2016 deletions
Download patch file Download diff file Expand all files Collapse all files

159
src/di/container.ts
View file

@ -1,159 +0,0 @@
/**
* Brandi Dependency Injection Container Configuration
* Configures all bindings with proper dependency resolution
*/
import { Container, injected } from 'brandi';
import { TOKENS } from './tokens';
import { eventBus } from '../core/EventBus';
import { calendarConfig } from '../core/CalendarConfig';
// 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';
// Import renderers
import { DateHeaderRenderer, ResourceHeaderRenderer } from '../renderers/HeaderRenderer';
import { DateColumnRenderer, ResourceColumnRenderer } from '../renderers/ColumnRenderer';
import { DateEventRenderer } from '../renderers/EventRenderer';
import { GridRenderer } from '../renderers/GridRenderer';
/**
* 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);
// Determine calendar mode at startup and bind appropriate renderers
const calendarMode = calendarConfig.getCalendarMode();
console.log('🔧 DI Container: Calendar mode detected:', calendarMode);
if (calendarMode === 'resource') {
// Resource mode renderers
console.log('🔧 DI Container: Binding DateHeaderRenderer for resource mode (TEST)');
container.bind(TOKENS.headerRenderer).toConstant(new DateHeaderRenderer());
container.bind(TOKENS.columnRenderer).toConstant(new DateColumnRenderer());
container.bind(TOKENS.eventRendererStrategy).toConstant(new DateEventRenderer()); // TODO: ResourceEventRenderer
} else {
// Date mode renderers (default)
console.log('🔧 DI Container: Binding DateHeaderRenderer for date mode');
container.bind(TOKENS.headerRenderer).toConstant(new DateHeaderRenderer());
container.bind(TOKENS.columnRenderer).toConstant(new DateColumnRenderer());
container.bind(TOKENS.eventRendererStrategy).toConstant(new DateEventRenderer());
}
// Proper Brandi DI bindings with injected() declarations
// EventManager
injected(EventManager, TOKENS.eventBus);
container
.bind(TOKENS.eventManager)
.toInstance(EventManager)
.inSingletonScope();
// EventRenderingService
injected(EventRenderingService, TOKENS.eventBus, TOKENS.eventManager, TOKENS.eventRendererStrategy);
container
.bind(TOKENS.eventRenderer)
.toInstance(EventRenderingService)
.inSingletonScope();
// GridRenderer
injected(GridRenderer, TOKENS.columnRenderer);
container
.bind(TOKENS.gridRenderer)
.toInstance(GridRenderer)
.inSingletonScope();
// GridManager
injected(GridManager, TOKENS.gridRenderer);
container
.bind(TOKENS.gridManager)
.toInstance(GridManager)
.inSingletonScope();
// ScrollManager (no dependencies)
container
.bind(TOKENS.scrollManager)
.toInstance(ScrollManager)
.inSingletonScope();
// NavigationManager
injected(NavigationManager, TOKENS.eventBus, TOKENS.eventRenderer, TOKENS.gridRenderer);
container
.bind(TOKENS.navigationManager)
.toInstance(NavigationManager)
.inSingletonScope();
// ViewManager
injected(ViewManager, TOKENS.eventBus);
container
.bind(TOKENS.viewManager)
.toInstance(ViewManager)
.inSingletonScope();
// DragDropManager
injected(DragDropManager, TOKENS.eventBus);
container
.bind(TOKENS.dragDropManager)
.toInstance(DragDropManager)
.inSingletonScope();
// AllDayManager
injected(AllDayManager, TOKENS.eventManager);
container
.bind(TOKENS.allDayManager)
.toInstance(AllDayManager)
.inSingletonScope();
// ResizeHandleManager (no dependencies)
container
.bind(TOKENS.resizeHandleManager)
.toInstance(ResizeHandleManager)
.inSingletonScope();
// EdgeScrollManager
injected(EdgeScrollManager, TOKENS.eventBus);
container
.bind(TOKENS.edgeScrollManager)
.toInstance(EdgeScrollManager)
.inSingletonScope();
// DragHoverManager
injected(DragHoverManager, TOKENS.eventBus);
container
.bind(TOKENS.dragHoverManager)
.toInstance(DragHoverManager)
.inSingletonScope();
// HeaderManager
injected(HeaderManager, TOKENS.headerRenderer);
container
.bind(TOKENS.headerManager)
.toInstance(HeaderManager)
.inSingletonScope();
// CalendarManager
injected(CalendarManager, TOKENS.eventBus, TOKENS.eventManager, TOKENS.gridManager, TOKENS.eventRenderer, TOKENS.scrollManager);
container
.bind(TOKENS.calendarManager)
.toInstance(CalendarManager)
.inSingletonScope();
return container;
}

53
src/di/tokens.ts
View file

@ -1,53 +0,0 @@
/**
* 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';
import { HeaderRenderer } from '../renderers/HeaderRenderer';
import { ColumnRenderer } from '../renderers/ColumnRenderer';
import { EventRendererStrategy } from '../renderers/EventRenderer';
import { GridRenderer } from '../renderers/GridRenderer';
/**
* DI Tokens - Type-safe identifiers for dependency injection
*/
export const TOKENS = {
// Core services
eventBus: token<IEventBus>('eventBus'),
// Renderers (polymorphic - resolved based on calendar mode)
headerRenderer: token<HeaderRenderer>('headerRenderer'),
columnRenderer: token<ColumnRenderer>('columnRenderer'),
eventRendererStrategy: token<EventRendererStrategy>('eventRendererStrategy'),
gridRenderer: token<GridRenderer>('gridRenderer'),
// 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'),
};

110
src/factories/CalendarTypeFactory.ts
View file

@ -1,110 +0,0 @@
// Factory for creating calendar type-specific renderers
import { CalendarMode } from '../types/CalendarTypes';
import { HeaderRenderer, DateHeaderRenderer, ResourceHeaderRenderer } from '../renderers/HeaderRenderer';
import { ColumnRenderer, DateColumnRenderer, ResourceColumnRenderer } from '../renderers/ColumnRenderer';
import { EventRendererStrategy, DateEventRenderer } from '../renderers/EventRenderer';
import { calendarConfig } from '../core/CalendarConfig';
/**
* Renderer configuration for a calendar type
*/
export interface RendererConfig {
headerRenderer: HeaderRenderer;
columnRenderer: ColumnRenderer;
eventRenderer: EventRendererStrategy;
}
/**
* Factory for creating calendar type-specific renderers
*/
export class CalendarTypeFactory {
private static renderers: Map<CalendarMode, RendererConfig> = new Map();
private static isInitialized: boolean = false;
/**
* Initialize the factory with default renderers (only runs once)
*/
static initialize(): void {
if (this.isInitialized) {
return;
}
// Register default renderers
this.registerRenderers('date', {
headerRenderer: new DateHeaderRenderer(),
columnRenderer: new DateColumnRenderer(),
eventRenderer: new DateEventRenderer()
});
//this.registerRenderers('resource', {
// headerRenderer: new ResourceHeaderRenderer(),
// columnRenderer: new ResourceColumnRenderer(),
// eventRenderer: new ResourceEventRenderer()
//});
this.isInitialized = true;
}
/**
* Register renderers for a calendar type
*/
static registerRenderers(type: CalendarMode, config: RendererConfig): void {
this.renderers.set(type, config);
}
/**
* Get renderers for a calendar type
*/
static getRenderers(type: CalendarMode): RendererConfig {
const renderers = this.renderers.get(type);
if (!renderers) {
return this.renderers.get('date')!;
}
return renderers;
}
/**
* Get header renderer for a calendar type
*/
static getHeaderRenderer(type: CalendarMode): HeaderRenderer {
return this.getRenderers(type).headerRenderer;
}
/**
* Get column renderer for a calendar type
*/
static getColumnRenderer(type: CalendarMode): ColumnRenderer {
return this.getRenderers(type).columnRenderer;
}
/**
* Get event renderer for a calendar type
*/
static getEventRenderer(type: CalendarMode): EventRendererStrategy {
return this.getRenderers(type).eventRenderer;
}
/**
* Check if a calendar type is supported
*/
static isSupported(type: CalendarMode): boolean {
return this.renderers.has(type);
}
/**
* Get all supported calendar types
*/
static getSupportedTypes(): CalendarMode[] {
return Array.from(this.renderers.keys());
}
/**
* Clear all registered renderers (useful for testing)
*/
static clear(): void {
this.renderers.clear();
}
}

101
src/index.ts
View file

@ -1,11 +1,30 @@
// Main entry point for Calendar Plantempus
import { Container } from '@novadi/core';
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 { IEventBus } from './types/CalendarTypes';
// 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';
// Import renderers
import { DateHeaderRenderer, type HeaderRenderer } from './renderers/HeaderRenderer';
import { DateColumnRenderer, type ColumnRenderer } from './renderers/ColumnRenderer';
import { DateEventRenderer, type EventRendererStrategy } from './renderers/EventRenderer';
import { GridRenderer } from './renderers/GridRenderer';
/**
* Handle deep linking functionality after managers are initialized
@ -32,33 +51,73 @@ async function handleDeepLinking(eventManager: EventManager): Promise<void> {
}
/**
* Initialize the calendar application using Brandi DI
* Initialize the calendar application using NovaDI
*/
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();
// Create NovaDI container
const container = new Container();
const builder = container.builder();
// Enable debug mode for development
eventBus.setDebug(true);
// Bind core services as instances
builder.registerInstance(eventBus).as<IEventBus>();
// Determine calendar mode and bind appropriate renderers
const calendarMode = calendarConfig.getCalendarMode();
console.log('🔧 DI Container: Calendar mode detected:', calendarMode);
if (calendarMode === 'resource') {
// Resource mode renderers
console.log('🔧 DI Container: Binding DateHeaderRenderer for resource mode (TEST)');
builder.registerInstance(new DateHeaderRenderer()).as<HeaderRenderer>();
builder.registerInstance(new DateColumnRenderer()).as<ColumnRenderer>();
builder.registerInstance(new DateEventRenderer()).as<EventRendererStrategy>();
} else {
// Date mode renderers (default)
console.log('🔧 DI Container: Binding DateHeaderRenderer for date mode');
builder.registerInstance(new DateHeaderRenderer()).as<HeaderRenderer>();
builder.registerInstance(new DateColumnRenderer()).as<ColumnRenderer>();
builder.registerInstance(new DateEventRenderer()).as<EventRendererStrategy>();
}
builder.registerType(EventRenderingService).as<EventRenderingService>().singleInstance();
builder.registerType(GridRenderer).as<GridRenderer>().singleInstance();
builder.registerType(GridManager).as<GridManager>().singleInstance();
builder.registerType(ScrollManager).as<ScrollManager>().singleInstance();
builder.registerType(NavigationManager).as<NavigationManager>().singleInstance();
builder.registerType(ViewManager).as<ViewManager>().singleInstance();
builder.registerType(DragDropManager).as<DragDropManager>().singleInstance();
builder.registerType(AllDayManager).as<AllDayManager>().singleInstance();
builder.registerType(ResizeHandleManager).as<ResizeHandleManager>().singleInstance();
builder.registerType(EdgeScrollManager).as<EdgeScrollManager>().singleInstance();
builder.registerType(DragHoverManager).as<DragHoverManager>().singleInstance();
builder.registerType(HeaderManager).as<HeaderManager>().singleInstance();
builder.registerType(CalendarManager).as<CalendarManager>().singleInstance();
builder.registerType(EventManager).as<EventManager>().singleInstance();
// Build the container
const app = builder.build();
// Get managers from container
const calendarManager = container.get(TOKENS.calendarManager);
const eventManager = container.get(TOKENS.eventManager);
const resizeHandleManager = container.get(TOKENS.resizeHandleManager);
const headerManager = container.get(TOKENS.headerManager);
const dragDropManager = container.get(TOKENS.dragDropManager);
const viewManager = container.get(TOKENS.viewManager);
const navigationManager = container.get(TOKENS.navigationManager);
const edgeScrollManager = container.get(TOKENS.edgeScrollManager);
const dragHoverManager = container.get(TOKENS.dragHoverManager);
const allDayManager = container.get(TOKENS.allDayManager);
const eb = app.resolveType<IEventBus>();
const calendarManager = app.resolveType<CalendarManager>();
const eventManager = app.resolveType<EventManager>();
const resizeHandleManager = app.resolveType<ResizeHandleManager>();
const headerManager = app.resolveType<HeaderManager>();
const dragDropManager = app.resolveType<DragDropManager>();
const viewManager = app.resolveType<ViewManager>();
const navigationManager = app.resolveType<NavigationManager>();
const edgeScrollManager = app.resolveType<EdgeScrollManager>();
const dragHoverManager = app.resolveType<DragHoverManager>();
const allDayManager = app.resolveType<AllDayManager>();
// Initialize managers
await calendarManager.initialize?.();
@ -71,13 +130,13 @@ async function initializeCalendar(): Promise<void> {
(window as Window & {
calendarDebug?: {
eventBus: typeof eventBus;
container: typeof container;
app: typeof app;
calendarManager: typeof calendarManager;
eventManager: typeof eventManager;
};
}).calendarDebug = {
eventBus,
container,
app,
calendarManager,
eventManager,
};

4
src/managers/CalendarManager.ts
View file

@ -24,13 +24,13 @@ export class CalendarManager {
eventBus: IEventBus,
eventManager: EventManager,
gridManager: GridManager,
eventRenderer: EventRenderingService,
eventRenderingService: EventRenderingService,
scrollManager: ScrollManager
) {
this.eventBus = eventBus;
this.eventManager = eventManager;
this.gridManager = gridManager;
this.eventRenderer = eventRenderer;
this.eventRenderer = eventRenderingService;
this.scrollManager = scrollManager;
const timezone = calendarConfig.getTimezone?.();
this.setupEventListeners();

6
src/managers/EventManager.ts
View file

@ -1,4 +1,3 @@
import { EventBus } from '../core/EventBus';
import { IEventBus, CalendarEvent, ResourceCalendarData } from '../types/CalendarTypes';
import { CoreEvents } from '../constants/CoreEvents';
import { calendarConfig } from '../core/CalendarConfig';
@ -21,15 +20,14 @@ interface RawEventData {
* Handles data loading with improved performance and caching
*/
export class EventManager {
private eventBus: IEventBus;
private events: CalendarEvent[] = [];
private rawData: ResourceCalendarData | RawEventData[] | null = null;
private eventCache = new Map<string, CalendarEvent[]>(); // Cache for period queries
private lastCacheKey: string = '';
private dateService: DateService;
constructor(eventBus: IEventBus) {
this.eventBus = eventBus;
constructor(private eventBus: IEventBus) {
const timezone = calendarConfig.getTimezone?.();
this.dateService = new DateService(timezone);
}

1
src/renderers/EventRendererManager.ts
View file

@ -2,7 +2,6 @@ import { EventBus } from '../core/EventBus';
import { IEventBus, CalendarEvent, RenderContext } from '../types/CalendarTypes';
import { CoreEvents } from '../constants/CoreEvents';
import { calendarConfig } from '../core/CalendarConfig';
import { CalendarTypeFactory } from '../factories/CalendarTypeFactory';
import { EventManager } from '../managers/EventManager';
import { EventRendererStrategy } from './EventRenderer';
import { SwpEventElement } from '../elements/SwpEventElement';

1
src/renderers/GridRenderer.ts
View file

@ -1,6 +1,5 @@
import { calendarConfig } from '../core/CalendarConfig';
import { ResourceCalendarData, CalendarView } from '../types/CalendarTypes';
import { CalendarTypeFactory } from '../factories/CalendarTypeFactory';
import { ColumnRenderer, ColumnRenderContext } from './ColumnRenderer';
import { eventBus } from '../core/EventBus';
import { DateService } from '../utils/DateService';

12
src/utils/DateService.ts
View file

@ -494,16 +494,4 @@ export class DateService {
return { valid: true };
}
/**
* Check if event spans multiple days
* @param start - Start date or ISO string
* @param end - End date or ISO string
* @returns True if spans multiple days
*/
public isMultiDay(start: Date | string, end: Date | string): boolean {
const startDate = typeof start === 'string' ? this.parseISO(start) : start;
const endDate = typeof end === 'string' ? this.parseISO(end) : end;
return !this.isSameDay(startDate, endDate);
}
}