@mintplayer/ng-bootstrap 21.22.0 → 21.23.0

package/fesm2022/mintplayer-ng-bootstrap-web-components-scheduler-core.mjs

@@ -0,0 +1,1356 @@
+/**
+ * Type guard to check if an item is a Resource
+ */
+function isResource(item) {
+    return 'events' in item || !('children' in item);
+}
+/**
+ * Type guard to check if an item is a ResourceGroup
+ */
+function isResourceGroup(item) {
+    return 'children' in item;
+}
+
+/**
+ * Default options for the scheduler
+ */
+const DEFAULT_OPTIONS = {
+    initialView: 'week',
+    initialDate: new Date(),
+    locale: 'en-US',
+    firstDayOfWeek: 1,
+    timeZone: 'local',
+    slotDuration: 1800,
+    slotLabelInterval: 3600,
+    slotMinTime: '00:00:00',
+    slotMaxTime: '24:00:00',
+    timeFormat: '24h',
+    businessHours: {
+        daysOfWeek: [1, 2, 3, 4, 5],
+        startTime: '09:00',
+        endTime: '17:00',
+    },
+    height: 'auto',
+    contentHeight: 'auto',
+    aspectRatio: 1.35,
+    expandRows: false,
+    headerToolbar: {
+        start: 'prev,next today',
+        center: 'title',
+        end: 'year,month,week,day,timeline',
+    },
+    editable: true,
+    selectable: true,
+    selectMirror: true,
+    eventDurationEditable: true,
+    eventStartEditable: true,
+    dragRevertDuration: 500,
+    dragScroll: true,
+    snapDuration: 1800,
+    nowIndicator: true,
+    weekNumbers: false,
+    weekText: 'W',
+    dayMaxEvents: true,
+};
+
+// Types
+
+/**
+ * Service for date calculations and formatting
+ */
+class DateService {
+    /**
+     * Get the start of the week for a given date
+     */
+    getWeekStart(date, firstDayOfWeek = 1) {
+        const d = new Date(date);
+        const day = d.getDay();
+        const diff = (day < firstDayOfWeek ? 7 : 0) + day - firstDayOfWeek;
+        d.setDate(d.getDate() - diff);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    /**
+     * Get all days in a week starting from a given date
+     */
+    getWeekDays(date, firstDayOfWeek = 1) {
+        const weekStart = this.getWeekStart(date, firstDayOfWeek);
+        const days = [];
+        for (let i = 0; i < 7; i++) {
+            const day = new Date(weekStart);
+            day.setDate(weekStart.getDate() + i);
+            days.push(day);
+        }
+        return days;
+    }
+    /**
+     * Get the start of the month for a given date
+     */
+    getMonthStart(date) {
+        return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+    }
+    /**
+     * Get the end of the month for a given date
+     */
+    getMonthEnd(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+    }
+    /**
+     * Get all days in a month
+     */
+    getMonthDays(date) {
+        const start = this.getMonthStart(date);
+        const end = this.getMonthEnd(date);
+        const days = [];
+        const current = new Date(start);
+        while (current <= end) {
+            days.push(new Date(current));
+            current.setDate(current.getDate() + 1);
+        }
+        return days;
+    }
+    /**
+     * Get weeks for a month view (includes days from adjacent months)
+     */
+    getMonthWeeks(date, firstDayOfWeek = 1) {
+        const monthStart = this.getMonthStart(date);
+        const monthEnd = this.getMonthEnd(date);
+        const viewStart = this.getWeekStart(monthStart, firstDayOfWeek);
+        const weeks = [];
+        let current = new Date(viewStart);
+        // Generate 6 weeks to ensure consistent grid
+        for (let w = 0; w < 6; w++) {
+            const week = [];
+            for (let d = 0; d < 7; d++) {
+                week.push(new Date(current));
+                current.setDate(current.getDate() + 1);
+            }
+            weeks.push(week);
+            // Stop if we've passed the end of the month and completed the week
+            if (current > monthEnd && weeks.length >= 4) {
+                break;
+            }
+        }
+        return weeks;
+    }
+    /**
+     * Get the start of the year for a given date
+     */
+    getYearStart(date) {
+        return new Date(date.getFullYear(), 0, 1, 0, 0, 0, 0);
+    }
+    /**
+     * Get all months in a year
+     */
+    getYearMonths(date) {
+        const months = [];
+        for (let i = 0; i < 12; i++) {
+            months.push(new Date(date.getFullYear(), i, 1));
+        }
+        return months;
+    }
+    /**
+     * Get time slots for a day
+     */
+    getTimeSlots(date, slotDuration = 1800, minTime = '00:00:00', maxTime = '24:00:00') {
+        const slots = [];
+        const [minHour, minMinute] = minTime.split(':').map(Number);
+        const [maxHour, maxMinute] = maxTime.split(':').map(Number);
+        const startSeconds = minHour * 3600 + minMinute * 60;
+        const endSeconds = maxHour * 3600 + maxMinute * 60;
+        for (let seconds = startSeconds; seconds < endSeconds; seconds += slotDuration) {
+            const slotStart = new Date(date);
+            slotStart.setHours(0, 0, 0, 0);
+            slotStart.setSeconds(seconds);
+            const slotEnd = new Date(slotStart);
+            slotEnd.setSeconds(slotStart.getSeconds() + slotDuration);
+            slots.push({ start: slotStart, end: slotEnd });
+        }
+        return slots;
+    }
+    /**
+     * Generate a scheduler grid for week view
+     */
+    getWeekGrid(date, firstDayOfWeek = 1, slotDuration = 1800, minTime = '00:00:00', maxTime = '24:00:00', timeFormat = '24h') {
+        const columns = this.getWeekDays(date, firstDayOfWeek);
+        const rows = [];
+        const allSlots = [];
+        // Get time slots for the first day to determine row structure
+        const daySlots = this.getTimeSlots(columns[0], slotDuration, minTime, maxTime);
+        for (const slot of daySlots) {
+            const rowSlots = [];
+            for (const day of columns) {
+                const slotStart = new Date(day);
+                slotStart.setHours(slot.start.getHours(), slot.start.getMinutes(), 0, 0);
+                const slotEnd = new Date(day);
+                slotEnd.setHours(slot.end.getHours(), slot.end.getMinutes(), 0, 0);
+                const timeSlot = { start: slotStart, end: slotEnd };
+                rowSlots.push(timeSlot);
+                allSlots.push(timeSlot);
+            }
+            rows.push({
+                time: slot.start,
+                label: this.formatTime(slot.start, timeFormat),
+                slots: rowSlots,
+            });
+        }
+        return { columns, rows, allSlots };
+    }
+    /**
+     * Round a date to the nearest slot
+     */
+    roundToSlot(date, slotDuration) {
+        const ms = date.getTime();
+        const slotMs = slotDuration * 1000;
+        const rounded = Math.round(ms / slotMs) * slotMs;
+        return new Date(rounded);
+    }
+    /**
+     * Floor a date to the slot start
+     */
+    floorToSlot(date, slotDuration) {
+        const ms = date.getTime();
+        const slotMs = slotDuration * 1000;
+        const floored = Math.floor(ms / slotMs) * slotMs;
+        return new Date(floored);
+    }
+    /**
+     * Ceiling a date to the slot end
+     */
+    ceilToSlot(date, slotDuration) {
+        const ms = date.getTime();
+        const slotMs = slotDuration * 1000;
+        const ceiled = Math.ceil(ms / slotMs) * slotMs;
+        return new Date(ceiled);
+    }
+    /**
+     * Detect time format preference based on locale
+     * Uses the Intl API to determine if the locale uses 12-hour or 24-hour time
+     */
+    detectTimeFormat(locale) {
+        const resolvedLocale = locale || (typeof navigator !== 'undefined' ? navigator.language : 'en-US');
+        try {
+            const options = new Intl.DateTimeFormat(resolvedLocale, { hour: 'numeric' }).resolvedOptions();
+            return options.hour12 ? '12h' : '24h';
+        }
+        catch {
+            // Fallback to 24h if detection fails
+            return '24h';
+        }
+    }
+    /**
+     * Format time according to format preference
+     */
+    formatTime(date, format = '24h') {
+        const hours = date.getHours();
+        const minutes = date.getMinutes();
+        if (format === '12h') {
+            const period = hours >= 12 ? 'PM' : 'AM';
+            const hour12 = hours % 12 || 12;
+            return `${hour12}:${minutes.toString().padStart(2, '0')} ${period}`;
+        }
+        return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
+    }
+    /**
+     * Format date for display
+     */
+    formatDate(date, locale = 'en-US', options) {
+        return date.toLocaleDateString(locale, options);
+    }
+    /**
+     * Format date with weekday
+     */
+    formatDateWithWeekday(date, locale = 'en-US') {
+        return this.formatDate(date, locale, { weekday: 'short', month: 'short', day: 'numeric' });
+    }
+    /**
+     * Get month name
+     */
+    getMonthName(date, locale = 'en-US', format = 'long') {
+        return date.toLocaleDateString(locale, { month: format });
+    }
+    /**
+     * Get day name
+     */
+    getDayName(date, locale = 'en-US', format = 'short') {
+        return date.toLocaleDateString(locale, { weekday: format });
+    }
+    /**
+     * Check if two dates are the same day
+     */
+    isSameDay(date1, date2) {
+        return (date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth() &&
+            date1.getDate() === date2.getDate());
+    }
+    /**
+     * Check if two dates are the same month
+     */
+    isSameMonth(date1, date2) {
+        return (date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth());
+    }
+    /**
+     * Check if a date is today
+     */
+    isToday(date) {
+        return this.isSameDay(date, new Date());
+    }
+    /**
+     * Check if a date is in the past
+     */
+    isPast(date) {
+        const now = new Date();
+        now.setHours(0, 0, 0, 0);
+        const check = new Date(date);
+        check.setHours(0, 0, 0, 0);
+        return check < now;
+    }
+    /**
+     * Check if a date falls within a range
+     */
+    isInRange(date, start, end) {
+        return date >= start && date <= end;
+    }
+    /**
+     * Get the number of days between two dates
+     */
+    getDaysDifference(date1, date2) {
+        const d1 = new Date(date1);
+        d1.setHours(0, 0, 0, 0);
+        const d2 = new Date(date2);
+        d2.setHours(0, 0, 0, 0);
+        return Math.round((d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
+    }
+    /**
+     * Add days to a date
+     */
+    addDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+    /**
+     * Add weeks to a date
+     */
+    addWeeks(date, weeks) {
+        return this.addDays(date, weeks * 7);
+    }
+    /**
+     * Add months to a date
+     */
+    addMonths(date, months) {
+        const result = new Date(date);
+        result.setMonth(result.getMonth() + months);
+        return result;
+    }
+    /**
+     * Add years to a date
+     */
+    addYears(date, years) {
+        const result = new Date(date);
+        result.setFullYear(result.getFullYear() + years);
+        return result;
+    }
+    /**
+     * Get week number of the year
+     */
+    getWeekNumber(date) {
+        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+        const dayNum = d.getUTCDay() || 7;
+        d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+        const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+        return Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    }
+    /**
+     * Get seconds from midnight for a date
+     */
+    getSecondsFromMidnight(date) {
+        return date.getHours() * 3600 + date.getMinutes() * 60 + date.getSeconds();
+    }
+    /**
+     * Get duration in seconds between two dates
+     */
+    getDurationInSeconds(start, end) {
+        return Math.round((end.getTime() - start.getTime()) / 1000);
+    }
+}
+/**
+ * Singleton instance of DateService
+ */
+const dateService = new DateService();
+
+/**
+ * Service for timeline calculations and event track assignment
+ */
+class TimelineService {
+    /**
+     * Split an event into daily parts
+     * Each part represents one day of a multi-day event
+     */
+    splitInParts(event) {
+        const parts = [];
+        let currentStart = new Date(event.start);
+        let dayIndex = 0;
+        // Calculate total days
+        const totalDays = this.getTotalDays(event.start, event.end);
+        // For events within the same day
+        if (dateService.isSameDay(event.start, event.end)) {
+            const isFullEvent = 'id' in event;
+            parts.push({
+                id: isFullEvent ? `${event.id}-0` : `preview-0`,
+                event: isFullEvent ? event : null,
+                start: event.start,
+                end: event.end,
+                isStart: true,
+                isEnd: true,
+                dayIndex: 0,
+                totalDays: 1,
+            });
+            return {
+                event: isFullEvent ? event : null,
+                parts,
+            };
+        }
+        // For multi-day events
+        while (!dateService.isSameDay(currentStart, event.end)) {
+            const dayEnd = new Date(currentStart);
+            dayEnd.setDate(dayEnd.getDate() + 1);
+            dayEnd.setHours(0, 0, 0, 0);
+            const isFullEvent = 'id' in event;
+            parts.push({
+                id: isFullEvent ? `${event.id}-${dayIndex}` : `preview-${dayIndex}`,
+                event: isFullEvent ? event : null,
+                start: new Date(currentStart),
+                end: dayEnd,
+                isStart: dayIndex === 0,
+                isEnd: false,
+                dayIndex,
+                totalDays,
+            });
+            currentStart = dayEnd;
+            dayIndex++;
+        }
+        // Add final part if the end time is not midnight
+        if (event.end.getHours() !== 0 || event.end.getMinutes() !== 0 || event.end.getSeconds() !== 0) {
+            const isFullEvent = 'id' in event;
+            parts.push({
+                id: isFullEvent ? `${event.id}-${dayIndex}` : `preview-${dayIndex}`,
+                event: isFullEvent ? event : null,
+                start: new Date(currentStart),
+                end: event.end,
+                isStart: false,
+                isEnd: true,
+                dayIndex,
+                totalDays,
+            });
+        }
+        return {
+            event: 'id' in event ? event : null,
+            parts,
+        };
+    }
+    /**
+     * Calculate total days an event spans
+     */
+    getTotalDays(start, end) {
+        const startDay = new Date(start);
+        startDay.setHours(0, 0, 0, 0);
+        const endDay = new Date(end);
+        endDay.setHours(0, 0, 0, 0);
+        const diffMs = endDay.getTime() - startDay.getTime();
+        const days = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+        // If end time is not midnight, add 1
+        if (end.getHours() !== 0 || end.getMinutes() !== 0 || end.getSeconds() !== 0) {
+            return days + 1;
+        }
+        return Math.max(1, days);
+    }
+    /**
+     * Assign events to tracks (rails) to minimize overlapping
+     * This method should be called when events are updated, NOT during drag operations
+     */
+    getTimeline(events) {
+        if (events.length === 0) {
+            return [];
+        }
+        // Get all unique timestamps and sort them
+        const timestamps = this.getUniqueTimestamps(events);
+        const tracks = [];
+        // Process events starting at each timestamp
+        for (const timestamp of timestamps) {
+            const startingEvents = events.filter((e) => e.start.getTime() === timestamp.getTime());
+            for (const event of startingEvents) {
+                // Find a free track for this event
+                const freeTrack = tracks.find((track) => this.isTrackFreeForEvent(track, event));
+                if (freeTrack) {
+                    freeTrack.events.push(event);
+                }
+                else {
+                    // Create a new track
+                    tracks.push({
+                        index: tracks.length,
+                        events: [event],
+                    });
+                }
+            }
+        }
+        return tracks;
+    }
+    /**
+     * Get track assignment for event parts using colspan algorithm (for rendering)
+     *
+     * This uses a colspan-based algorithm similar to Outlook/Google Calendar:
+     * 1. Build overlap groups (connected components of overlapping events)
+     * 2. Assign columns within each group using a greedy algorithm
+     * 3. Compute colspan - how many columns each event can span
+     *
+     * This ensures events are displayed as wide as possible:
+     * - An event with no overlapping events gets 100% width
+     * - Events only share space with events they actually overlap with
+     * - An event can span multiple columns if there's no blocking event to its right
+     */
+    getTimelinedParts(eventParts) {
+        // Collect unique events in a single pass (O(N) instead of O(N*M))
+        const eventMap = new Map();
+        for (const part of eventParts) {
+            if (part.event && !eventMap.has(part.event.id)) {
+                eventMap.set(part.event.id, part.event);
+            }
+        }
+        const events = Array.from(eventMap.values());
+        // Get layout info using colspan algorithm
+        const layoutMap = this.getColspanLayout(events);
+        // Map parts to their layout info
+        return eventParts.map((part) => {
+            if (!part.event) {
+                return { part, trackIndex: 0, totalTracks: 1, colspan: 1 };
+            }
+            const layout = layoutMap.get(part.event.id);
+            if (!layout) {
+                return { part, trackIndex: 0, totalTracks: 1, colspan: 1 };
+            }
+            return {
+                part,
+                trackIndex: layout.col,
+                totalTracks: layout.columnCount,
+                colspan: layout.colspan,
+            };
+        });
+    }
+    /**
+     * Compute colspan-based layout for events (Outlook/Google Calendar algorithm)
+     *
+     * Phase 1: Build overlap groups (connected components)
+     * Phase 2: Assign columns within each group
+     * Phase 3: Compute colspan for each event
+     */
+    getColspanLayout(events) {
+        const layoutMap = new Map();
+        if (events.length === 0) {
+            return layoutMap;
+        }
+        // Phase 1: Build overlap groups
+        const groups = this.buildOverlapGroups(events);
+        for (const group of groups) {
+            // Phase 2: Assign columns (returns assignments and column count)
+            const { assignments, columnCount } = this.assignColumns(group);
+            // Phase 3: Compute colspan for each event
+            for (const event of group) {
+                const col = assignments.get(event.id) ?? 0;
+                const colspan = this.computeColspan(event, col, group, assignments, columnCount);
+                layoutMap.set(event.id, {
+                    col,
+                    colspan,
+                    columnCount,
+                });
+            }
+        }
+        return layoutMap;
+    }
+    /**
+     * Build overlap groups (connected components)
+     * Events belong to the same group if they overlap directly or indirectly
+     *
+     * Optimized to reduce comparisons by pre-sorting events by start time
+     * and breaking early when events can no longer overlap
+     */
+    buildOverlapGroups(events) {
+        if (events.length === 0)
+            return [];
+        const groups = [];
+        const visited = new Set();
+        // Sort events by start time for efficient overlap checking
+        const sorted = [...events].sort((a, b) => a.start.getTime() - b.start.getTime());
+        for (const event of sorted) {
+            if (visited.has(event.id))
+                continue;
+            // BFS to find all connected events
+            // Use pointer-based iteration instead of shift() to avoid O(N) re-indexing
+            const group = [];
+            const queue = [event];
+            let queueHead = 0;
+            while (queueHead < queue.length) {
+                const current = queue[queueHead++];
+                if (visited.has(current.id))
+                    continue;
+                visited.add(current.id);
+                group.push(current);
+                const currentEnd = current.end.getTime();
+                // Find overlapping events efficiently using sorted order
+                for (const other of sorted) {
+                    if (visited.has(other.id))
+                        continue;
+                    // Since sorted by start time, if other starts at or after current ends,
+                    // no more events in sorted order can overlap with current
+                    if (other.start.getTime() >= currentEnd)
+                        break;
+                    if (this.eventsOverlap(current, other)) {
+                        queue.push(other);
+                    }
+                }
+            }
+            groups.push(group);
+        }
+        return groups;
+    }
+    /**
+     * Assign columns to events within an overlap group
+     * Uses a greedy algorithm: place each event in the first available column
+     * Returns the column assignments and total column count
+     */
+    assignColumns(group) {
+        const assignments = new Map();
+        // Sort by start time, then end time, then id (for stability)
+        const sorted = [...group].sort((a, b) => a.start.getTime() - b.start.getTime() ||
+            a.end.getTime() - b.end.getTime() ||
+            a.id.localeCompare(b.id));
+        // Track end time of each column
+        const colEnds = [];
+        for (const event of sorted) {
+            let col = -1;
+            // Find first available column
+            for (let i = 0; i < colEnds.length; i++) {
+                if (colEnds[i] <= event.start.getTime()) {
+                    col = i;
+                    break;
+                }
+            }
+            if (col === -1) {
+                col = colEnds.length;
+                colEnds.push(event.end.getTime());
+            }
+            else {
+                colEnds[col] = event.end.getTime();
+            }
+            assignments.set(event.id, col);
+        }
+        return { assignments, columnCount: colEnds.length };
+    }
+    /**
+     * Compute colspan for an event
+     * An event can span multiple columns if there's no overlapping event to its right
+     */
+    computeColspan(event, eventCol, group, assignments, columnCount) {
+        // Find the nearest blocking column to the right
+        let block = Infinity;
+        for (const other of group) {
+            if (other.id === event.id)
+                continue;
+            if (!this.eventsOverlap(event, other))
+                continue;
+            const otherCol = assignments.get(other.id) ?? 0;
+            if (otherCol > eventCol) {
+                block = Math.min(block, otherCol);
+            }
+        }
+        // Calculate colspan
+        if (block !== Infinity) {
+            return block - eventCol;
+        }
+        else {
+            return columnCount - eventCol;
+        }
+    }
+    /**
+     * Check if two events overlap in time
+     */
+    eventsOverlap(a, b) {
+        return a.start < b.end && b.start < a.end;
+    }
+    /**
+     * Calculate the relative track position for an event part (legacy method)
+     * @deprecated Use getColspanLayout instead for better layout
+     */
+    getRelativeTrackPosition(tracks, part, globalTrackIndex) {
+        // Find all track indices that have events overlapping with this part
+        const overlappingTrackIndices = [];
+        for (const track of tracks) {
+            const hasOverlap = track.events.some((event) => event.start < part.end && event.end > part.start);
+            if (hasOverlap) {
+                overlappingTrackIndices.push(track.index);
+            }
+        }
+        // Sort to ensure consistent ordering
+        overlappingTrackIndices.sort((a, b) => a - b);
+        // Find the relative position of this event's track among overlapping tracks
+        const relativeIndex = overlappingTrackIndices.indexOf(globalTrackIndex);
+        return {
+            relativeIndex: relativeIndex >= 0 ? relativeIndex : 0,
+            overlappingCount: Math.max(1, overlappingTrackIndices.length),
+        };
+    }
+    /**
+     * Filter events that fall within a date range
+     */
+    filterByRange(events, start, end) {
+        return events.filter((event) => {
+            // Event overlaps with range if:
+            // event.start < rangeEnd AND event.end > rangeStart
+            return event.start < end && event.end > start;
+        });
+    }
+    /**
+     * Filter event parts that fall within a date range
+     */
+    filterPartsByRange(parts, start, end) {
+        return parts.filter((part) => {
+            return part.start < end && part.end > start;
+        });
+    }
+    /**
+     * Get all unique timestamps from events (both start and end times)
+     */
+    getUniqueTimestamps(events) {
+        const timestampSet = new Set();
+        for (const event of events) {
+            timestampSet.add(event.start.getTime());
+            timestampSet.add(event.end.getTime());
+        }
+        return Array.from(timestampSet)
+            .sort((a, b) => a - b)
+            .map((ts) => new Date(ts));
+    }
+    /**
+     * Check if a track has space for an event (no overlapping)
+     */
+    isTrackFreeForEvent(track, event) {
+        return track.events.every((existingEvent) => {
+            // No overlap if: existingEvent ends before event starts OR event ends before existingEvent starts
+            return existingEvent.end <= event.start || event.end <= existingEvent.start;
+        });
+    }
+    /**
+     * Get events for a specific day
+     */
+    getEventsForDay(events, day) {
+        const dayStart = new Date(day);
+        dayStart.setHours(0, 0, 0, 0);
+        const dayEnd = new Date(day);
+        dayEnd.setHours(23, 59, 59, 999);
+        return this.filterByRange(events, dayStart, dayEnd);
+    }
+    /**
+     * Get event parts for a specific day
+     */
+    getPartsForDay(parts, day) {
+        const dayStart = new Date(day);
+        dayStart.setHours(0, 0, 0, 0);
+        const dayEnd = new Date(day);
+        dayEnd.setHours(23, 59, 59, 999);
+        return this.filterPartsByRange(parts, dayStart, dayEnd);
+    }
+}
+/**
+ * Singleton instance of TimelineService
+ */
+const timelineService = new TimelineService();
+
+/**
+ * Service for calculating event positions within the grid
+ */
+class PositionService {
+    /**
+     * Calculate position for an event part in week/day view
+     */
+    calculateWeekPosition(part, trackIndex, totalTracks, dayIndex, totalDays, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const slotDuration = opts.slotDuration;
+        // Calculate vertical position (top and height)
+        const dayStart = new Date(part.start);
+        dayStart.setHours(0, 0, 0, 0);
+        const startSeconds = dateService.getSecondsFromMidnight(part.start);
+        const endSeconds = dateService.getSecondsFromMidnight(part.end);
+        const durationSeconds = endSeconds - startSeconds;
+        // Parse min/max time
+        const [minHour] = opts.slotMinTime.split(':').map(Number);
+        const [maxHour] = opts.slotMaxTime.split(':').map(Number);
+        const visibleSeconds = (maxHour - minHour) * 3600;
+        const offsetSeconds = startSeconds - minHour * 3600;
+        // Top position as percentage
+        const top = (offsetSeconds / visibleSeconds) * 100;
+        const height = (durationSeconds / visibleSeconds) * 100;
+        // Calculate horizontal position (left and width)
+        // Account for time gutter width (assumed 60px or ~10%)
+        const gutterWidth = 10; // percentage
+        const availableWidth = 100 - gutterWidth;
+        const dayWidth = availableWidth / totalDays;
+        // Position within the day column based on track
+        const trackWidth = dayWidth / totalTracks;
+        const left = gutterWidth + dayIndex * dayWidth + trackIndex * trackWidth;
+        const width = trackWidth;
+        return {
+            top,
+            left,
+            width,
+            height,
+            zIndex: trackIndex + 1,
+        };
+    }
+    /**
+     * Calculate position for an event in timeline view
+     */
+    calculateTimelinePosition(part, trackIndex, totalTracks, viewStart, viewEnd, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        // Calculate horizontal position based on time
+        const totalDuration = viewEnd.getTime() - viewStart.getTime();
+        const eventStart = Math.max(part.start.getTime(), viewStart.getTime());
+        const eventEnd = Math.min(part.end.getTime(), viewEnd.getTime());
+        const startOffset = eventStart - viewStart.getTime();
+        const duration = eventEnd - eventStart;
+        const left = (startOffset / totalDuration) * 100;
+        const width = (duration / totalDuration) * 100;
+        // Calculate vertical position based on track
+        const trackHeight = 100 / totalTracks;
+        const top = trackIndex * trackHeight;
+        const height = trackHeight;
+        return {
+            top,
+            left,
+            width,
+            height,
+            zIndex: 1,
+        };
+    }
+    /**
+     * Calculate position for an all-day event in month view
+     */
+    calculateMonthEventPosition(part, rowIndex, maxRows, startDayIndex, endDayIndex, totalDays = 7) {
+        const dayWidth = 100 / totalDays;
+        const rowHeight = 100 / maxRows;
+        const left = startDayIndex * dayWidth;
+        const width = (endDayIndex - startDayIndex + 1) * dayWidth;
+        const top = rowIndex * rowHeight;
+        const height = rowHeight;
+        return {
+            top,
+            left,
+            width,
+            height,
+            zIndex: rowIndex + 1,
+        };
+    }
+    /**
+     * Convert percentage-based position to pixel-based
+     */
+    toPixelPosition(position, containerWidth, containerHeight) {
+        return {
+            top: (position.top / 100) * containerHeight,
+            left: (position.left / 100) * containerWidth,
+            width: (position.width / 100) * containerWidth,
+            height: (position.height / 100) * containerHeight,
+            zIndex: position.zIndex,
+        };
+    }
+    /**
+     * Generate CSS styles from position
+     */
+    toStyleString(position, unit = '%') {
+        return `
+      position: absolute;
+      top: ${position.top}${unit};
+      left: ${position.left}${unit};
+      width: ${position.width}${unit};
+      height: ${position.height}${unit};
+      z-index: ${position.zIndex};
+    `.trim().replace(/\s+/g, ' ');
+    }
+    /**
+     * Generate CSS object from position
+     */
+    toStyleObject(position, unit = '%') {
+        return {
+            position: 'absolute',
+            top: `${position.top}${unit}`,
+            left: `${position.left}${unit}`,
+            width: `${position.width}${unit}`,
+            height: `${position.height}${unit}`,
+            zIndex: String(position.zIndex),
+        };
+    }
+}
+/**
+ * Singleton instance of PositionService
+ */
+const positionService = new PositionService();
+
+/**
+ * Service for resource and resource group operations
+ */
+class ResourceService {
+    /**
+     * Flatten a hierarchical resource structure for rendering
+     */
+    flatten(items, collapsedIds = new Set(), depth = 0, parentId, parentCollapsed = false) {
+        const result = [];
+        for (const item of items) {
+            const visible = !parentCollapsed;
+            result.push({ item, depth, visible, parentId });
+            if (isResourceGroup(item)) {
+                const isCollapsed = collapsedIds.has(item.id);
+                const children = this.flatten(item.children, collapsedIds, depth + 1, item.id, parentCollapsed || isCollapsed);
+                result.push(...children);
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all resources (leaf nodes) from a hierarchical structure
+     */
+    getAllResources(items) {
+        const resources = [];
+        for (const item of items) {
+            if (isResource(item)) {
+                resources.push(item);
+            }
+            else if (isResourceGroup(item)) {
+                resources.push(...this.getAllResources(item.children));
+            }
+        }
+        return resources;
+    }
+    /**
+     * Get all events from all resources
+     */
+    getAllEvents(items) {
+        const resources = this.getAllResources(items);
+        return resources.flatMap((r) => r.events ?? []);
+    }
+    /**
+     * Find a resource by ID
+     */
+    findResourceById(items, id) {
+        for (const item of items) {
+            if (isResource(item) && item.id === id) {
+                return item;
+            }
+            if (isResourceGroup(item)) {
+                const found = this.findResourceById(item.children, id);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find a resource group by ID
+     */
+    findGroupById(items, id) {
+        for (const item of items) {
+            if (isResourceGroup(item)) {
+                if (item.id === id)
+                    return item;
+                const found = this.findGroupById(item.children, id);
+                if (found)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find any item (resource or group) by ID
+     */
+    findById(items, id) {
+        return this.findResourceById(items, id) ?? this.findGroupById(items, id);
+    }
+    /**
+     * Add an event to a resource
+     */
+    addEventToResource(items, resourceId, event) {
+        return this.mapResources(items, (resource) => {
+            if (resource.id === resourceId) {
+                return {
+                    ...resource,
+                    events: [...(resource.events ?? []), event],
+                };
+            }
+            return resource;
+        });
+    }
+    /**
+     * Update an event in a resource
+     */
+    updateEventInResource(items, event) {
+        return this.mapResources(items, (resource) => {
+            const eventIndex = resource.events?.findIndex((e) => e.id === event.id);
+            if (eventIndex !== undefined && eventIndex >= 0 && resource.events) {
+                const newEvents = [...resource.events];
+                newEvents[eventIndex] = event;
+                return { ...resource, events: newEvents };
+            }
+            return resource;
+        });
+    }
+    /**
+     * Remove an event from all resources
+     */
+    removeEvent(items, eventId) {
+        return this.mapResources(items, (resource) => {
+            if (resource.events?.some((e) => e.id === eventId)) {
+                return {
+                    ...resource,
+                    events: resource.events.filter((e) => e.id !== eventId),
+                };
+            }
+            return resource;
+        });
+    }
+    /**
+     * Move an event from one resource to another
+     */
+    moveEventToResource(items, eventId, newResourceId, updatedEvent) {
+        // Find the event first
+        let foundEvent;
+        for (const resource of this.getAllResources(items)) {
+            foundEvent = resource.events?.find((e) => e.id === eventId);
+            if (foundEvent)
+                break;
+        }
+        if (!foundEvent)
+            return items;
+        // Merge with updates
+        const newEvent = {
+            ...foundEvent,
+            ...updatedEvent,
+            resourceId: newResourceId,
+        };
+        // Remove from old resource and add to new
+        let result = this.removeEvent(items, eventId);
+        result = this.addEventToResource(result, newResourceId, newEvent);
+        return result;
+    }
+    /**
+     * Toggle collapse state of a group
+     */
+    toggleGroupCollapse(items, groupId) {
+        return this.mapGroups(items, (group) => {
+            if (group.id === groupId) {
+                return { ...group, collapsed: !group.collapsed };
+            }
+            return group;
+        });
+    }
+    /**
+     * Set collapse state of a group
+     */
+    setGroupCollapse(items, groupId, collapsed) {
+        return this.mapGroups(items, (group) => {
+            if (group.id === groupId) {
+                return { ...group, collapsed };
+            }
+            return group;
+        });
+    }
+    /**
+     * Collapse all groups
+     */
+    collapseAll(items) {
+        return this.mapGroups(items, (group) => ({ ...group, collapsed: true }));
+    }
+    /**
+     * Expand all groups
+     */
+    expandAll(items) {
+        return this.mapGroups(items, (group) => ({ ...group, collapsed: false }));
+    }
+    /**
+     * Map over all resources in the hierarchy
+     */
+    mapResources(items, mapper) {
+        return items.map((item) => {
+            if (isResource(item)) {
+                return mapper(item);
+            }
+            return {
+                ...item,
+                children: this.mapResources(item.children, mapper),
+            };
+        });
+    }
+    /**
+     * Map over all groups in the hierarchy
+     */
+    mapGroups(items, mapper) {
+        return items.map((item) => {
+            if (isResourceGroup(item)) {
+                const mappedGroup = mapper(item);
+                return {
+                    ...mappedGroup,
+                    children: this.mapGroups(mappedGroup.children, mapper),
+                };
+            }
+            return item;
+        });
+    }
+    /**
+     * Get the total count of visible resources
+     */
+    getVisibleResourceCount(items, collapsedIds = new Set()) {
+        const flattened = this.flatten(items, collapsedIds);
+        return flattened.filter((f) => f.visible && isResource(f.item)).length;
+    }
+    /**
+     * Sort resources by order property
+     */
+    sortByOrder(items) {
+        const sorted = [...items].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        return sorted.map((item) => {
+            if (isResourceGroup(item)) {
+                return {
+                    ...item,
+                    children: this.sortByOrder(item.children),
+                };
+            }
+            return item;
+        });
+    }
+}
+/**
+ * Singleton instance of ResourceService
+ */
+const resourceService = new ResourceService();
+
+/**
+ * Generate a unique ID
+ */
+function generateId(prefix = 'evt') {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 9);
+    return `${prefix}-${timestamp}-${random}`;
+}
+/**
+ * Generate a unique event ID
+ */
+function generateEventId() {
+    return generateId('evt');
+}
+/**
+ * Generate a unique resource ID
+ */
+function generateResourceId() {
+    return generateId('res');
+}
+/**
+ * Generate a unique group ID
+ */
+function generateGroupId() {
+    return generateId('grp');
+}
+
+/**
+ * Default colors for events
+ */
+const DEFAULT_COLORS = [
+    '#3788d8', // Blue
+    '#28a745', // Green
+    '#dc3545', // Red
+    '#ffc107', // Yellow
+    '#17a2b8', // Cyan
+    '#6f42c1', // Purple
+    '#fd7e14', // Orange
+    '#20c997', // Teal
+    '#e83e8c', // Pink
+    '#6c757d', // Gray
+];
+/**
+ * Get a color by index (cycles through default colors)
+ */
+function getColorByIndex(index) {
+    return DEFAULT_COLORS[index % DEFAULT_COLORS.length];
+}
+/**
+ * Calculate contrasting text color (black or white) for a background
+ */
+function getContrastColor(backgroundColor) {
+    // Convert hex to RGB
+    let hex = backgroundColor.replace('#', '');
+    if (hex.length === 3) {
+        hex = hex.split('').map((c) => c + c).join('');
+    }
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    // Calculate relative luminance
+    const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    return luminance > 0.5 ? '#000000' : '#ffffff';
+}
+/**
+ * Lighten a color by a percentage
+ */
+function lightenColor(color, percent) {
+    let hex = color.replace('#', '');
+    if (hex.length === 3) {
+        hex = hex.split('').map((c) => c + c).join('');
+    }
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    const newR = Math.min(255, Math.round(r + (255 - r) * (percent / 100)));
+    const newG = Math.min(255, Math.round(g + (255 - g) * (percent / 100)));
+    const newB = Math.min(255, Math.round(b + (255 - b) * (percent / 100)));
+    return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+}
+/**
+ * Darken a color by a percentage
+ */
+function darkenColor(color, percent) {
+    let hex = color.replace('#', '');
+    if (hex.length === 3) {
+        hex = hex.split('').map((c) => c + c).join('');
+    }
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    const newR = Math.max(0, Math.round(r * (1 - percent / 100)));
+    const newG = Math.max(0, Math.round(g * (1 - percent / 100)));
+    const newB = Math.max(0, Math.round(b * (1 - percent / 100)));
+    return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+}
+/**
+ * Add alpha (opacity) to a color
+ */
+function addAlpha(color, alpha) {
+    let hex = color.replace('#', '');
+    if (hex.length === 3) {
+        hex = hex.split('').map((c) => c + c).join('');
+    }
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+
+/**
+ * Get element by data attributes (used for finding time slots)
+ */
+function getElementByData(container, dataAttributes) {
+    const selector = Object.entries(dataAttributes)
+        .map(([key, value]) => `[data-${key}="${value}"]`)
+        .join('');
+    return container.querySelector(selector);
+}
+/**
+ * Get data attributes from an element
+ */
+function getDataAttributes(element) {
+    const dataset = element.dataset;
+    const result = {};
+    for (const key in dataset) {
+        const value = dataset[key];
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Find closest ancestor with a data attribute
+ */
+function findClosestWithData(element, dataAttribute) {
+    return element.closest(`[data-${dataAttribute}]`);
+}
+/**
+ * Get scroll position relative to an element
+ */
+function getScrollPosition(element) {
+    return {
+        top: element.scrollTop,
+        left: element.scrollLeft,
+    };
+}
+/**
+ * Scroll to a specific time in the scheduler
+ */
+function scrollToTime(container, timeElement, behavior = 'smooth') {
+    const containerRect = container.getBoundingClientRect();
+    const timeRect = timeElement.getBoundingClientRect();
+    const relativeTop = timeRect.top - containerRect.top + container.scrollTop;
+    container.scrollTo({
+        top: relativeTop,
+        behavior,
+    });
+}
+/**
+ * Check if an element is in viewport
+ */
+function isInViewport(element, container) {
+    const rect = element.getBoundingClientRect();
+    const containerRect = container
+        ? container.getBoundingClientRect()
+        : { top: 0, left: 0, bottom: window.innerHeight, right: window.innerWidth };
+    return (rect.top >= containerRect.top &&
+        rect.left >= containerRect.left &&
+        rect.bottom <= containerRect.bottom &&
+        rect.right <= containerRect.right);
+}
+/**
+ * Get pointer position relative to an element
+ */
+function getRelativePosition(event, element) {
+    const rect = element.getBoundingClientRect();
+    const clientX = 'touches' in event ? event.touches[0].clientX : event.clientX;
+    const clientY = 'touches' in event ? event.touches[0].clientY : event.clientY;
+    return {
+        x: clientX - rect.left,
+        y: clientY - rect.top,
+    };
+}
+/**
+ * Create a CSS variable setter for theming
+ */
+function setCSSVariable(element, name, value) {
+    element.style.setProperty(`--${name}`, value);
+}
+/**
+ * Get computed CSS variable value
+ */
+function getCSSVariable(element, name) {
+    return getComputedStyle(element).getPropertyValue(`--${name}`).trim();
+}
+/**
+ * Add multiple CSS classes
+ */
+function addClasses(element, ...classes) {
+    element.classList.add(...classes.filter(Boolean));
+}
+/**
+ * Remove multiple CSS classes
+ */
+function removeClasses(element, ...classes) {
+    element.classList.remove(...classes.filter(Boolean));
+}
+/**
+ * Toggle CSS class based on condition
+ */
+function toggleClass(element, className, condition) {
+    element.classList.toggle(className, condition);
+}
+
+// Models
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_COLORS, DEFAULT_OPTIONS, DateService, PositionService, ResourceService, TimelineService, addAlpha, addClasses, darkenColor, dateService, findClosestWithData, generateEventId, generateGroupId, generateId, generateResourceId, getCSSVariable, getColorByIndex, getContrastColor, getDataAttributes, getElementByData, getRelativePosition, getScrollPosition, isInViewport, isResource, isResourceGroup, lightenColor, positionService, removeClasses, resourceService, scrollToTime, setCSSVariable, timelineService, toggleClass };
+//# sourceMappingURL=mintplayer-ng-bootstrap-web-components-scheduler-core.mjs.map