Some ignored filles was missing

wwwroot/js/managers/EventLayoutCoordinator.js

@@ -0,0 +1,201 @@
+/**
+ * EventLayoutCoordinator - Coordinates event layout calculations
+ *
+ * Separates layout logic from rendering concerns.
+ * Calculates stack levels, groups events, and determines rendering strategy.
+ */
+export class EventLayoutCoordinator {
+    constructor(stackManager, config, positionUtils) {
+        this.stackManager = stackManager;
+        this.config = config;
+        this.positionUtils = positionUtils;
+    }
+    /**
+     * Calculate complete layout for a column of events (recursive approach)
+     */
+    calculateColumnLayout(columnEvents) {
+        if (columnEvents.length === 0) {
+            return { gridGroups: [], stackedEvents: [] };
+        }
+        const gridGroupLayouts = [];
+        const stackedEventLayouts = [];
+        const renderedEventsWithLevels = [];
+        let remaining = [...columnEvents].sort((a, b) => a.start.getTime() - b.start.getTime());
+        // Process events recursively
+        while (remaining.length > 0) {
+            // Take first event
+            const firstEvent = remaining[0];
+            // Find events that could be in GRID with first event
+            // Use expanding search to find chains (A→B→C where each conflicts with next)
+            const gridSettings = this.config.gridSettings;
+            const thresholdMinutes = gridSettings.gridStartThresholdMinutes;
+            // Use refactored method for expanding grid candidates
+            const gridCandidates = this.expandGridCandidates(firstEvent, remaining, thresholdMinutes);
+            // Decide: should this group be GRID or STACK?
+            const group = {
+                events: gridCandidates,
+                containerType: 'NONE',
+                startTime: firstEvent.start
+            };
+            const containerType = this.stackManager.decideContainerType(group);
+            if (containerType === 'GRID' && gridCandidates.length > 1) {
+                // Render as GRID
+                const gridStackLevel = this.calculateGridGroupStackLevelFromRendered(gridCandidates, renderedEventsWithLevels);
+                // Ensure we get the earliest event (explicit sort for robustness)
+                const earliestEvent = [...gridCandidates].sort((a, b) => a.start.getTime() - b.start.getTime())[0];
+                const position = this.positionUtils.calculateEventPosition(earliestEvent.start, earliestEvent.end);
+                const columns = this.allocateColumns(gridCandidates);
+                gridGroupLayouts.push({
+                    events: gridCandidates,
+                    stackLevel: gridStackLevel,
+                    position: { top: position.top + 1 },
+                    columns
+                });
+                // Mark all events in grid with their stack level
+                gridCandidates.forEach(e => renderedEventsWithLevels.push({ event: e, level: gridStackLevel }));
+                // Remove all events in this grid from remaining
+                remaining = remaining.filter(e => !gridCandidates.includes(e));
+            }
+            else {
+                // Render first event as STACKED
+                const stackLevel = this.calculateStackLevelFromRendered(firstEvent, renderedEventsWithLevels);
+                const position = this.positionUtils.calculateEventPosition(firstEvent.start, firstEvent.end);
+                stackedEventLayouts.push({
+                    event: firstEvent,
+                    stackLink: { stackLevel },
+                    position: { top: position.top + 1, height: position.height - 3 }
+                });
+                // Mark this event with its stack level
+                renderedEventsWithLevels.push({ event: firstEvent, level: stackLevel });
+                // Remove only first event from remaining
+                remaining = remaining.slice(1);
+            }
+        }
+        return {
+            gridGroups: gridGroupLayouts,
+            stackedEvents: stackedEventLayouts
+        };
+    }
+    /**
+     * Calculate stack level for a grid group based on already rendered events
+     */
+    calculateGridGroupStackLevelFromRendered(gridEvents, renderedEventsWithLevels) {
+        // Find highest stack level of any rendered event that overlaps with this grid
+        let maxOverlappingLevel = -1;
+        for (const gridEvent of gridEvents) {
+            for (const rendered of renderedEventsWithLevels) {
+                if (this.stackManager.doEventsOverlap(gridEvent, rendered.event)) {
+                    maxOverlappingLevel = Math.max(maxOverlappingLevel, rendered.level);
+                }
+            }
+        }
+        return maxOverlappingLevel + 1;
+    }
+    /**
+     * Calculate stack level for a single stacked event based on already rendered events
+     */
+    calculateStackLevelFromRendered(event, renderedEventsWithLevels) {
+        // Find highest stack level of any rendered event that overlaps with this event
+        let maxOverlappingLevel = -1;
+        for (const rendered of renderedEventsWithLevels) {
+            if (this.stackManager.doEventsOverlap(event, rendered.event)) {
+                maxOverlappingLevel = Math.max(maxOverlappingLevel, rendered.level);
+            }
+        }
+        return maxOverlappingLevel + 1;
+    }
+    /**
+     * Detect if two events have a conflict based on threshold
+     *
+     * @param event1 - First event
+     * @param event2 - Second event
+     * @param thresholdMinutes - Threshold in minutes
+     * @returns true if events conflict
+     */
+    detectConflict(event1, event2, thresholdMinutes) {
+        // Check 1: Start-to-start conflict (starts within threshold)
+        const startToStartDiff = Math.abs(event1.start.getTime() - event2.start.getTime()) / (1000 * 60);
+        if (startToStartDiff <= thresholdMinutes && this.stackManager.doEventsOverlap(event1, event2)) {
+            return true;
+        }
+        // Check 2: End-to-start conflict (event1 starts within threshold before event2 ends)
+        const endToStartMinutes = (event2.end.getTime() - event1.start.getTime()) / (1000 * 60);
+        if (endToStartMinutes > 0 && endToStartMinutes <= thresholdMinutes) {
+            return true;
+        }
+        // Check 3: Reverse end-to-start (event2 starts within threshold before event1 ends)
+        const reverseEndToStart = (event1.end.getTime() - event2.start.getTime()) / (1000 * 60);
+        if (reverseEndToStart > 0 && reverseEndToStart <= thresholdMinutes) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Expand grid candidates to find all events connected by conflict chains
+     *
+     * Uses expanding search to find chains (A→B→C where each conflicts with next)
+     *
+     * @param firstEvent - The first event to start with
+     * @param remaining - Remaining events to check
+     * @param thresholdMinutes - Threshold in minutes
+     * @returns Array of all events in the conflict chain
+     */
+    expandGridCandidates(firstEvent, remaining, thresholdMinutes) {
+        const gridCandidates = [firstEvent];
+        let candidatesChanged = true;
+        // Keep expanding until no new candidates can be added
+        while (candidatesChanged) {
+            candidatesChanged = false;
+            for (let i = 1; i < remaining.length; i++) {
+                const candidate = remaining[i];
+                // Skip if already in candidates
+                if (gridCandidates.includes(candidate))
+                    continue;
+                // Check if candidate conflicts with ANY event in gridCandidates
+                for (const existingCandidate of gridCandidates) {
+                    if (this.detectConflict(candidate, existingCandidate, thresholdMinutes)) {
+                        gridCandidates.push(candidate);
+                        candidatesChanged = true;
+                        break; // Found conflict, move to next candidate
+                    }
+                }
+            }
+        }
+        return gridCandidates;
+    }
+    /**
+     * Allocate events to columns within a grid group
+     *
+     * Events that don't overlap can share the same column.
+     * Uses a greedy algorithm to minimize the number of columns.
+     *
+     * @param events - Events in the grid group (should already be sorted by start time)
+     * @returns Array of columns, where each column is an array of events
+     */
+    allocateColumns(events) {
+        if (events.length === 0)
+            return [];
+        if (events.length === 1)
+            return [[events[0]]];
+        const columns = [];
+        // For each event, try to place it in an existing column where it doesn't overlap
+        for (const event of events) {
+            let placed = false;
+            // Try to find a column where this event doesn't overlap with any existing event
+            for (const column of columns) {
+                const hasOverlap = column.some(colEvent => this.stackManager.doEventsOverlap(event, colEvent));
+                if (!hasOverlap) {
+                    column.push(event);
+                    placed = true;
+                    break;
+                }
+            }
+            // If no suitable column found, create a new one
+            if (!placed) {
+                columns.push([event]);
+            }
+        }
+        return columns;
+    }
+}
+//# sourceMappingURL=EventLayoutCoordinator.js.map