@ngxsmk/cdk 1.3.2 → 3.0.0

package/fesm2022/ngxsmk-cdk-scheduler.mjs

@@ -0,0 +1,1035 @@
+import * as i0 from '@angular/core';
+import { signal, computed, Injectable } from '@angular/core';
+
+function startOfDay(date) {
+    const d = new Date(date);
+    d.setHours(0, 0, 0, 0);
+    return d;
+}
+function startOfWeek(date, firstDayOfWeek) {
+    const d = startOfDay(date);
+    const day = d.getDay();
+    const diff = (day - firstDayOfWeek + 7) % 7;
+    d.setDate(d.getDate() - diff);
+    return d;
+}
+function endOfWeek(date, firstDayOfWeek) {
+    const start = startOfWeek(date, firstDayOfWeek);
+    const end = new Date(start);
+    end.setDate(end.getDate() + 7);
+    end.setMilliseconds(-1);
+    return end;
+}
+function startOfMonth(date) {
+    const d = new Date(date.getFullYear(), date.getMonth(), 1);
+    d.setHours(0, 0, 0, 0);
+    return d;
+}
+function endOfMonth(date) {
+    const d = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    d.setHours(23, 59, 59, 999);
+    return d;
+}
+function addDays(date, days) {
+    const d = new Date(date);
+    d.setDate(d.getDate() + days);
+    return d;
+}
+function addMinutes(date, minutes) {
+    return new Date(date.getTime() + minutes * 60_000);
+}
+function addWeeks(date, weeks) {
+    return addDays(date, weeks * 7);
+}
+function diffMinutes(start, end) {
+    return (end.getTime() - start.getTime()) / 60_000;
+}
+function diffDays(start, end) {
+    const s = startOfDay(start);
+    const e = startOfDay(end);
+    return Math.round((e.getTime() - s.getTime()) / 86_400_000);
+}
+function isSameDay(a, b) {
+    return (a.getFullYear() === b.getFullYear() &&
+        a.getMonth() === b.getMonth() &&
+        a.getDate() === b.getDate());
+}
+function isSameWeek(a, b, firstDayOfWeek) {
+    return isSameDay(startOfWeek(a, firstDayOfWeek), startOfWeek(b, firstDayOfWeek));
+}
+function isToday(date) {
+    return isSameDay(date, new Date());
+}
+function isWeekend(date) {
+    const day = date.getDay();
+    return day === 0 || day === 6;
+}
+function isPast(date) {
+    return date.getTime() < Date.now();
+}
+function dateRangeOverlaps(aStart, aEnd, bStart, bEnd) {
+    return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime();
+}
+function clampDate(date, min, max) {
+    const t = date.getTime();
+    if (t < min.getTime())
+        return new Date(min);
+    if (t > max.getTime())
+        return new Date(max);
+    return new Date(date);
+}
+function getHoursInRange(start, end) {
+    const hours = [];
+    const d = new Date(start);
+    while (d < end) {
+        hours.push(d.getHours());
+        d.setHours(d.getHours() + 1, 0, 0, 0);
+    }
+    return hours;
+}
+function formatHour(h, locale = 'en-US') {
+    const d = new Date();
+    d.setHours(h, 0, 0, 0);
+    return d.toLocaleTimeString(locale, { hour: 'numeric', minute: undefined });
+}
+function formatDateRange(start, end, locale = 'en-US') {
+    const opts = { month: 'short', day: 'numeric' };
+    const yearOpts = { month: 'short', day: 'numeric', year: 'numeric' };
+    const sameYear = start.getFullYear() === end.getFullYear();
+    const fmt = new Intl.DateTimeFormat(locale, sameYear ? opts : yearOpts);
+    return `${fmt.format(start)} – ${fmt.format(end)}${sameYear ? `, ${start.getFullYear()}` : ''}`;
+}
+function getWeekDates(date, firstDayOfWeek) {
+    const start = startOfWeek(date, firstDayOfWeek);
+    return Array.from({ length: 7 }, (_, i) => addDays(start, i));
+}
+function getWorkWeekDates(date, firstDayOfWeek) {
+    const weekDates = getWeekDates(date, firstDayOfWeek);
+    return weekDates.filter((d) => !isWeekend(d));
+}
+function getMonthGrid(date, firstDayOfWeek) {
+    const monthStart = startOfMonth(date);
+    const gridStart = startOfWeek(monthStart, firstDayOfWeek);
+    const gridEnd = addDays(gridStart, 42);
+    const weeks = [];
+    let current = new Date(gridStart);
+    while (current < gridEnd) {
+        weeks.push(Array.from({ length: 7 }, (_, i) => addDays(current, i)));
+        current = addDays(current, 7);
+    }
+    return weeks;
+}
+function getDayNames(locale = 'en-US', format = 'short') {
+    return Array.from({ length: 7 }, (_, i) => {
+        const d = new Date(2026, 0, 4 + i);
+        return d.toLocaleDateString(locale, { weekday: format });
+    });
+}
+function getMonthNames(locale = 'en-US', format = 'long') {
+    return Array.from({ length: 12 }, (_, i) => {
+        const d = new Date(2026, i, 1);
+        return d.toLocaleDateString(locale, { month: format });
+    });
+}
+
+const HOUR_HEIGHT_MAP = {
+    compact: 48,
+    comfortable: 60,
+    dense: 36,
+};
+function computeRange(type, date, firstDayOfWeek) {
+    switch (type) {
+        case 'timeGridDay':
+        case 'dayGridDay':
+        case 'agenda':
+            return { start: startOfDay(date), end: addDays(startOfDay(date), 1) };
+        case 'timeGridWeek':
+        case 'dayGridWeek':
+            return { start: startOfWeek(date, firstDayOfWeek), end: endOfWeek(date, firstDayOfWeek) };
+        case 'timeGridWorkWeek': {
+            const weekStart = startOfWeek(date, firstDayOfWeek);
+            return { start: addDays(weekStart, 1), end: addDays(weekStart, 5) };
+        }
+        case 'timeGrid3Day':
+            return { start: startOfDay(date), end: addDays(startOfDay(date), 3) };
+        case 'dayGridMonth':
+            return { start: startOfMonth(date), end: endOfMonth(date) };
+        case 'timeline':
+            return { start: startOfWeek(date, firstDayOfWeek), end: endOfWeek(date, firstDayOfWeek) };
+        default:
+            return { start: startOfWeek(date, firstDayOfWeek), end: endOfWeek(date, firstDayOfWeek) };
+    }
+}
+class SchedulerEngine {
+    constructor(config = {}) {
+        this.now = signal(new Date());
+        this._config = config;
+        const firstDay = config.firstDayOfWeek ?? 1;
+        const date = config.date ?? new Date();
+        const view = config.defaultView ?? 'timeGridWeek';
+        const range = computeRange(view, date, firstDay);
+        this._lifecycle = {
+            beforeRender: signal(() => true),
+            afterRender: signal(() => {
+                /* noop */
+            }),
+            beforeCreate: signal(() => true),
+            afterCreate: signal(() => {
+                /* noop */
+            }),
+            beforeUpdate: signal(() => true),
+            afterUpdate: signal(() => {
+                /* noop */
+            }),
+            beforeDelete: signal(() => true),
+            afterDelete: signal(() => {
+                /* noop */
+            }),
+            beforeDrag: signal(() => true),
+            afterDrag: signal(() => {
+                /* noop */
+            }),
+            beforeResize: signal(() => true),
+            afterResize: signal(() => {
+                /* noop */
+            }),
+        };
+        this.events = signal(config.initialEvents ?? []);
+        this.resources = signal(config.initialResources ?? []);
+        this.plugins = signal(config.plugins ?? []);
+        this.viewState = signal({
+            type: view,
+            date: new Date(date),
+            rangeStart: range.start,
+            rangeEnd: range.end,
+            slotDuration: config.slotDuration ?? 30,
+            snapDuration: config.snapDuration ?? 15,
+            visibleHours: config.visibleHours ?? [0, 24],
+            firstDayOfWeek: firstDay,
+            locale: config.locale ?? 'en-US',
+            rtl: config.rtl ?? false,
+            density: config.density ?? 'comfortable',
+            showAllDay: config.showAllDay ?? true,
+            showWeekends: config.showWeekends ?? true,
+            showCurrentTime: config.showCurrentTime ?? true,
+        });
+        this.selection = signal({
+            selectedEventIds: new Set(),
+            selectedRange: null,
+            multiSelect: false,
+            focusedCell: null,
+        });
+        this.hourHeight = computed(() => HOUR_HEIGHT_MAP[this.viewState().density] ?? 60);
+        this.visibleEvents = computed(() => {
+            const vs = this.viewState();
+            const events = this.events();
+            return events.filter((e) => !e.allDay && dateRangeOverlaps(e.start, e.end, vs.rangeStart, vs.rangeEnd));
+        });
+        this.allDayEvents = computed(() => {
+            const vs = this.viewState();
+            const events = this.events();
+            return events.filter((e) => e.allDay && dateRangeOverlaps(e.start, e.end, vs.rangeStart, vs.rangeEnd));
+        });
+        this.timedEvents = computed(() => this.visibleEvents());
+        this.weekDates = computed(() => {
+            const vs = this.viewState();
+            const start = vs.rangeStart;
+            const dates = [];
+            let current = new Date(start);
+            while (current < vs.rangeEnd) {
+                dates.push(new Date(current));
+                current = addDays(current, 1);
+            }
+            return dates;
+        });
+        this.dayNames = computed(() => {
+            const locale = this.viewState().locale;
+            return Array.from({ length: 7 }, (_, i) => {
+                const d = startOfWeek(new Date(), this.viewState().firstDayOfWeek);
+                d.setDate(d.getDate() + i);
+                return d.toLocaleDateString(locale, { weekday: 'short' });
+            });
+        });
+        this.weekLabel = computed(() => {
+            const vs = this.viewState();
+            return (vs.rangeStart.toLocaleDateString(vs.locale, {
+                month: 'short',
+                day: 'numeric',
+            }) +
+                ' – ' +
+                vs.rangeEnd.toLocaleDateString(vs.locale, {
+                    month: 'short',
+                    day: 'numeric',
+                    year: 'numeric',
+                }));
+        });
+    }
+    get lifecycle() {
+        return this._lifecycle;
+    }
+    // ── Navigation ──
+    next() {
+        const vs = this.viewState();
+        const date = addDays(vs.date, this._viewSpan(vs.type));
+        this._navigateTo(date);
+    }
+    previous() {
+        const vs = this.viewState();
+        const date = addDays(vs.date, -this._viewSpan(vs.type));
+        this._navigateTo(date);
+    }
+    today() {
+        this._navigateTo(new Date());
+    }
+    goto(date) {
+        this._navigateTo(date);
+    }
+    setView(type, date) {
+        const vs = this.viewState();
+        const refDate = date ?? vs.date;
+        const range = computeRange(type, refDate, vs.firstDayOfWeek);
+        this.viewState.update((s) => ({
+            ...s,
+            type,
+            date: new Date(refDate),
+            rangeStart: range.start,
+            rangeEnd: range.end,
+        }));
+    }
+    // ── Event Mutations ──
+    addEvent(event) {
+        if (!this._runHook(this._lifecycle.beforeCreate, event))
+            return;
+        this.events.update((evts) => [...evts, event]);
+        this._lifecycle.afterCreate()(event);
+    }
+    updateEvent(id, patch) {
+        const existing = this.events().find((e) => e.id === id);
+        if (!existing)
+            return;
+        const updated = { ...existing, ...patch };
+        if (!this._runHook(this._lifecycle.beforeUpdate, updated))
+            return;
+        this.events.update((evts) => evts.map((e) => (e.id === id ? updated : e)));
+        this._lifecycle.afterUpdate()(updated);
+    }
+    removeEvent(id) {
+        const existing = this.events().find((e) => e.id === id);
+        if (!existing)
+            return;
+        if (!this._runHook(this._lifecycle.beforeDelete, existing))
+            return;
+        this.events.update((evts) => evts.filter((e) => e.id !== id));
+        this._lifecycle.afterDelete()(existing);
+    }
+    moveEvent(id, newStart, newEnd, resourceId) {
+        const existing = this.events().find((e) => e.id === id);
+        if (!existing)
+            return;
+        const move = {
+            event: existing,
+            from: existing.start,
+            to: newStart,
+            newStart,
+            newEnd,
+            resourceId,
+        };
+        if (!this._runHook(this._lifecycle.beforeDrag, existing))
+            return;
+        this.events.update((evts) => evts.map((e) => e.id === id
+            ? { ...e, start: newStart, end: newEnd, resourceId: resourceId ?? e.resourceId }
+            : e));
+        this._lifecycle.afterDrag()(move);
+    }
+    resizeEvent(id, newEnd) {
+        const existing = this.events().find((e) => e.id === id);
+        if (!existing)
+            return;
+        const resize = {
+            event: existing,
+            oldEnd: existing.end,
+            newEnd,
+        };
+        if (!this._runHook(this._lifecycle.beforeResize, existing))
+            return;
+        this.events.update((evts) => evts.map((e) => (e.id === id ? { ...e, end: newEnd } : e)));
+        this._lifecycle.afterResize()(resize);
+    }
+    // ── Selection ──
+    selectEvent(id, multi = false) {
+        this.selection.update((s) => {
+            const ids = new Set(multi ? s.selectedEventIds : []);
+            if (ids.has(id)) {
+                ids.delete(id);
+            }
+            else {
+                ids.add(id);
+            }
+            return { ...s, selectedEventIds: ids };
+        });
+    }
+    selectRange(start, end, resourceId) {
+        this.selection.update((s) => ({
+            ...s,
+            selectedRange: { start, end, resourceId },
+        }));
+    }
+    clearSelection() {
+        this.selection.update((s) => ({
+            ...s,
+            selectedEventIds: new Set(),
+            selectedRange: null,
+        }));
+    }
+    isEventSelected(id) {
+        return this.selection().selectedEventIds.has(id);
+    }
+    // ── Queries ──
+    eventsForDay(day) {
+        return this.visibleEvents().filter((e) => isSameDay(e.start, day));
+    }
+    allDayEventsForDay(day) {
+        return this.allDayEvents().filter((e) => e.start.getTime() <= day.getTime() + 86_400_000 && e.end.getTime() >= day.getTime());
+    }
+    getEventsInRange(start, end) {
+        return this.events().filter((e) => dateRangeOverlaps(e.start, e.end, start, end));
+    }
+    eventTop(event) {
+        const hh = this.hourHeight();
+        return ((event.start.getHours() * 60 + event.start.getMinutes()) / 60) * hh;
+    }
+    eventHeight(event) {
+        const hh = this.hourHeight();
+        const durationMin = diffMinutes(event.start, event.end);
+        return Math.max((durationMin / 60) * hh, 18);
+    }
+    currentTimeY() {
+        const hh = this.hourHeight();
+        const now = this.now();
+        return ((now.getHours() * 60 + now.getMinutes()) / 60) * hh;
+    }
+    // ── Private ──
+    _navigateTo(date) {
+        const vs = this.viewState();
+        const range = computeRange(vs.type, date, vs.firstDayOfWeek);
+        this.viewState.update((s) => ({
+            ...s,
+            date: new Date(date),
+            rangeStart: range.start,
+            rangeEnd: range.end,
+        }));
+    }
+    _viewSpan(type) {
+        switch (type) {
+            case 'timeGridDay':
+            case 'dayGridDay':
+            case 'agenda':
+                return 1;
+            case 'timeGrid3Day':
+                return 3;
+            case 'timeGridWorkWeek':
+            case 'timeGridWeek':
+            case 'dayGridWeek':
+                return 7;
+            case 'dayGridMonth':
+                return 30;
+            case 'timeline':
+                return 7;
+            default:
+                return 7;
+        }
+    }
+    _runHook(hook, arg) {
+        const fn = hook();
+        const result = fn(arg);
+        return result === false ? false : true;
+    }
+}
+
+const DEFAULT_WORKING_HOURS = {
+    days: [1, 2, 3, 4, 5],
+    ranges: [[480, 1020]],
+};
+
+function isTimeGridView(view) {
+    return view.startsWith('timeGrid');
+}
+function isDayGridView(view) {
+    return view.startsWith('dayGrid');
+}
+
+const DEFAULT_SELECTION = {
+    selectedEventIds: new Set(),
+    selectedRange: null,
+    multiSelect: false,
+    focusedCell: null,
+};
+
+class PluginHost {
+    constructor() {
+        this._plugins = new Map();
+        this._engine = null;
+    }
+    register(engine, plugins) {
+        this._engine = engine;
+        const sorted = [...plugins].sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+        for (const plugin of sorted) {
+            if (this._plugins.has(plugin.name))
+                continue;
+            this._plugins.set(plugin.name, plugin);
+            plugin.onInit?.(engine);
+        }
+    }
+    unregister(name) {
+        const plugin = this._plugins.get(name);
+        if (plugin) {
+            plugin.onDestroy?.();
+            this._plugins.delete(name);
+        }
+    }
+    notifyRender() {
+        for (const plugin of this._plugins.values()) {
+            plugin.onRender?.();
+        }
+    }
+    destroy() {
+        for (const plugin of this._plugins.values()) {
+            plugin.onDestroy?.();
+        }
+        this._plugins.clear();
+    }
+    has(name) {
+        return this._plugins.has(name);
+    }
+    get(name) {
+        return this._plugins.get(name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: PluginHost, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: PluginHost }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.0", ngImport: i0, type: PluginHost, decorators: [{
+            type: Injectable
+        }] });
+
+class DragPlugin {
+    constructor(options = {}) {
+        this.name = 'drag';
+        this.priority = 10;
+        this._dragging = null;
+        this._options = options;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    onDestroy() {
+        this._dragging = null;
+    }
+    startDrag(eventId, pointerY, dayEl, day) {
+        const event = this._engine.events().find((e) => e.id === eventId);
+        if (!event || event.draggable === false)
+            return false;
+        if (this._options.onDragStart && !this._options.onDragStart(event))
+            return false;
+        const scrollTop = dayEl.closest('.ngxsmk-sch__scroll')?.scrollTop ?? 0;
+        const colTop = dayEl.getBoundingClientRect().top;
+        const eventTop = this._engine.eventTop(event);
+        const offsetY = pointerY - colTop - eventTop + scrollTop;
+        this._dragging = {
+            eventId,
+            offsetY,
+            startTop: eventTop,
+            originDay: day,
+        };
+        return true;
+    }
+    moveDrag(pointerY, dayEl, day) {
+        if (!this._dragging)
+            return null;
+        const hh = this._engine.hourHeight();
+        const scrollTop = dayEl.closest('.ngxsmk-sch__scroll')?.scrollTop ?? 0;
+        const colTop = dayEl.getBoundingClientRect().top;
+        const rawY = pointerY - colTop + scrollTop - this._dragging.offsetY;
+        const snap = this._options.snapDuration ?? this._engine.viewState().snapDuration;
+        const snapPx = (snap / 60) * hh;
+        const top = Math.max(0, Math.round(rawY / snapPx) * snapPx);
+        return { top, day };
+    }
+    endDrag(top, day) {
+        if (!this._dragging)
+            return null;
+        const event = this._engine.events().find((e) => e.id === this._dragging.eventId);
+        if (!event) {
+            this._dragging = null;
+            return null;
+        }
+        const hh = this._engine.hourHeight();
+        const minutes = (top / hh) * 60;
+        const durationMs = event.end.getTime() - event.start.getTime();
+        const newStart = new Date(day);
+        newStart.setHours(0, 0, 0, 0);
+        newStart.setMinutes(minutes);
+        const newEnd = new Date(newStart.getTime() + durationMs);
+        const move = {
+            event,
+            from: event.start,
+            to: day,
+            newStart,
+            newEnd,
+            resourceId: event.resourceId,
+        };
+        this._engine.moveEvent(event.id, newStart, newEnd);
+        this._options.onDragEnd?.(move);
+        this._dragging = null;
+        return move;
+    }
+    cancelDrag() {
+        this._dragging = null;
+    }
+    get dragging() {
+        return this._dragging !== null;
+    }
+    get draggingEventId() {
+        return this._dragging?.eventId ?? null;
+    }
+}
+
+class ResizePlugin {
+    constructor(options = {}) {
+        this.name = 'resize';
+        this.priority = 11;
+        this._resizing = null;
+        this._options = options;
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    onDestroy() {
+        this._resizing = null;
+    }
+    startResize(eventId) {
+        const event = this._engine.events().find((e) => e.id === eventId);
+        if (!event || event.resizable === false)
+            return false;
+        if (this._options.onResizeStart && !this._options.onResizeStart(event))
+            return false;
+        this._resizing = { eventId, originEnd: new Date(event.end) };
+        return true;
+    }
+    moveResize(pointerY, dayEl) {
+        if (!this._resizing)
+            return null;
+        const event = this._engine.events().find((e) => e.id === this._resizing.eventId);
+        if (!event)
+            return null;
+        const hh = this._engine.hourHeight();
+        const scrollTop = dayEl.closest('.ngxsmk-sch__scroll')?.scrollTop ?? 0;
+        const colTop = dayEl.getBoundingClientRect().top;
+        const rawY = pointerY - colTop + scrollTop;
+        const snap = this._options.snapDuration ?? this._engine.viewState().snapDuration;
+        const snapPx = (snap / 60) * hh;
+        const y = Math.max(this._engine.eventTop(event) + snapPx, Math.round(rawY / snapPx) * snapPx);
+        const minutes = (y / hh) * 60;
+        const newEnd = new Date(event.start);
+        newEnd.setHours(0, 0, 0, 0);
+        newEnd.setMinutes(minutes);
+        const minDur = this._options.minDuration ?? 15;
+        if (newEnd.getTime() - event.start.getTime() < minDur * 60_000) {
+            newEnd.setTime(event.start.getTime() + minDur * 60_000);
+        }
+        return newEnd;
+    }
+    endResize() {
+        if (!this._resizing)
+            return null;
+        const event = this._engine.events().find((e) => e.id === this._resizing.eventId);
+        if (!event) {
+            this._resizing = null;
+            return null;
+        }
+        const resize = {
+            event,
+            oldEnd: this._resizing.originEnd,
+            newEnd: event.end,
+        };
+        this._engine.resizeEvent(event.id, event.end);
+        this._options.onResizeEnd?.(resize);
+        this._resizing = null;
+        return resize;
+    }
+    cancelResize() {
+        this._resizing = null;
+    }
+    get resizing() {
+        return this._resizing !== null;
+    }
+    get resizingEventId() {
+        return this._resizing?.eventId ?? null;
+    }
+}
+
+class SelectionPlugin {
+    constructor(options = {}) {
+        this.name = 'selection';
+        this.priority = 5;
+        this._rangeSelecting = false;
+        this._rangeStart = null;
+        this._options = options;
+    }
+    onInit(engine) {
+        this._engine = engine;
+        if (this._options.multiSelect) {
+            this._engine.selection.update((s) => ({ ...s, multiSelect: true }));
+        }
+    }
+    onDestroy() {
+        this._rangeSelecting = false;
+        this._rangeStart = null;
+    }
+    toggleEvent(eventId, modifierKey = false) {
+        const multi = this._options.multiSelect && modifierKey;
+        this._engine.selectEvent(eventId, multi);
+        const selectedIds = this._engine.selection().selectedEventIds;
+        const selectedEvents = this._engine.events().filter((e) => selectedIds.has(e.id));
+        if (selectedIds.has(eventId)) {
+            this._options.onSelect?.(selectedEvents);
+        }
+        else {
+            this._options.onDeselect?.(selectedEvents);
+        }
+    }
+    selectOnly(eventId) {
+        this._engine.clearSelection();
+        this._engine.selectEvent(eventId);
+        const event = this._engine.events().find((e) => e.id === eventId);
+        if (event)
+            this._options.onSelect?.([event]);
+    }
+    selectRange(start, end) {
+        this._engine.selectRange(start, end);
+        this._options.onRangeSelect?.(start, end);
+    }
+    startRangeSelect(date) {
+        this._rangeSelecting = true;
+        this._rangeStart = date;
+    }
+    updateRangeSelect(date) {
+        if (!this._rangeSelecting || !this._rangeStart)
+            return;
+        const s = this._rangeStart < date ? this._rangeStart : date;
+        const e = this._rangeStart < date ? date : this._rangeStart;
+        this._engine.selectRange(s, e);
+    }
+    endRangeSelect() {
+        if (!this._rangeSelecting || !this._rangeStart)
+            return null;
+        const range = this._engine.selection().selectedRange;
+        this._rangeSelecting = false;
+        this._rangeStart = null;
+        return range;
+    }
+    selectAll() {
+        const all = this._engine.events();
+        this._engine.selection.update((s) => ({
+            ...s,
+            selectedEventIds: new Set(all.map((e) => e.id)),
+        }));
+    }
+    clearSelection() {
+        this._engine.clearSelection();
+    }
+    get selectedIds() {
+        return this._engine.selection().selectedEventIds;
+    }
+    get selectedCount() {
+        return this._engine.selection().selectedEventIds.size;
+    }
+    get hasSelection() {
+        return this._engine.selection().selectedEventIds.size > 0;
+    }
+    get isRangeSelecting() {
+        return this._rangeSelecting;
+    }
+}
+
+function createDefaultTooltipState() {
+    return {
+        visible: false,
+        event: null,
+        x: 0,
+        y: 0,
+        placement: 'top',
+        content: '',
+    };
+}
+class TooltipPlugin {
+    constructor(options = {}) {
+        this.name = 'tooltip';
+        this.priority = 50;
+        this._timeout = null;
+        this._state = createDefaultTooltipState();
+        this._listeners = [];
+        this._options = {
+            delay: options.delay ?? 400,
+            showArrow: options.showArrow ?? true,
+            placement: options.placement ?? 'top',
+            maxWidth: options.maxWidth ?? 280,
+            onShow: options.onShow ?? (() => true),
+            onHide: options.onHide ??
+                (() => {
+                    /* noop */
+                }),
+            content: options.content ?? defaultContent,
+        };
+    }
+    onInit(engine) {
+        this._engine = engine;
+    }
+    onDestroy() {
+        this.hide();
+        this._clearTimeout();
+        for (const unlisten of this._listeners)
+            unlisten();
+        this._listeners = [];
+    }
+    show(event, targetEl) {
+        this._clearTimeout();
+        this._timeout = setTimeout(() => {
+            if (this._options.onShow(event) === false)
+                return;
+            const rect = targetEl.getBoundingClientRect();
+            const pos = this._computePosition(rect);
+            this._state = {
+                visible: true,
+                event,
+                x: pos.x,
+                y: pos.y,
+                placement: pos.placement,
+                content: this._options.content(event),
+            };
+        }, this._options.delay);
+    }
+    hide() {
+        this._clearTimeout();
+        if (this._state.event) {
+            this._options.onHide(this._state.event);
+        }
+        this._state = createDefaultTooltipState();
+    }
+    updatePosition(targetEl) {
+        if (!this._state.visible || !this._state.event)
+            return;
+        const rect = targetEl.getBoundingClientRect();
+        const pos = this._computePosition(rect);
+        this._state = { ...this._state, x: pos.x, y: pos.y, placement: pos.placement };
+    }
+    get state() {
+        return this._state;
+    }
+    get isVisible() {
+        return this._state.visible;
+    }
+    _computePosition(rect) {
+        const placement = this._options.placement;
+        const offset = 8;
+        switch (placement) {
+            case 'top':
+                return { x: rect.left + rect.width / 2, y: rect.top - offset, placement };
+            case 'bottom':
+                return { x: rect.left + rect.width / 2, y: rect.bottom + offset, placement };
+            case 'left':
+                return { x: rect.left - offset, y: rect.top + rect.height / 2, placement };
+            case 'right':
+                return { x: rect.right + offset, y: rect.top + rect.height / 2, placement };
+        }
+    }
+    _clearTimeout() {
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+            this._timeout = null;
+        }
+    }
+}
+function defaultContent(event) {
+    const time = `${event.start.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })} – ${event.end.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}`;
+    return `${event.title}\n${time}`;
+}
+
+class KeyboardPlugin {
+    constructor(options = {}) {
+        this.name = 'keyboard';
+        this.priority = 20;
+        this._handler = null;
+        this._options = options;
+    }
+    onInit(engine) {
+        this._engine = engine;
+        if (typeof document !== 'undefined') {
+            this._handler = (e) => this._onKeyDown(e);
+            document.addEventListener('keydown', this._handler);
+        }
+    }
+    onDestroy() {
+        if (this._handler) {
+            document.removeEventListener('keydown', this._handler);
+            this._handler = null;
+        }
+    }
+    _onKeyDown(e) {
+        const target = e.target;
+        if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)
+            return;
+        switch (e.key) {
+            case 'ArrowRight':
+                e.preventDefault();
+                this._moveFocus(1);
+                break;
+            case 'ArrowLeft':
+                e.preventDefault();
+                this._moveFocus(-1);
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                this._moveFocusTime(-30);
+                break;
+            case 'ArrowDown':
+                e.preventDefault();
+                this._moveFocusTime(30);
+                break;
+            case 'Enter':
+            case ' ':
+                e.preventDefault();
+                this._activateFocused();
+                break;
+            case 'Delete':
+            case 'Backspace':
+                e.preventDefault();
+                this._deleteSelected();
+                break;
+            case 'Escape':
+                e.preventDefault();
+                this._deselect();
+                this._options.onKeyAction?.('escape');
+                break;
+            case 'a':
+                if (e.ctrlKey || e.metaKey) {
+                    e.preventDefault();
+                    this._selectAll();
+                }
+                break;
+            case 't':
+                if (!e.ctrlKey && !e.metaKey && !e.altKey) {
+                    e.preventDefault();
+                    this._goToday();
+                }
+                break;
+        }
+    }
+    _moveFocus(deltaDays) {
+        const sel = this._engine.selection();
+        const focused = sel.focusedCell;
+        if (focused) {
+            const newDate = addDays(focused.date, deltaDays);
+            this._engine.selection.update((s) => ({
+                ...s,
+                focusedCell: { date: newDate, resourceId: focused.resourceId },
+            }));
+        }
+        else {
+            const vs = this._engine.viewState();
+            this._engine.selection.update((s) => ({
+                ...s,
+                focusedCell: { date: vs.date },
+            }));
+        }
+        this._options.onKeyAction?.('moveFocus');
+    }
+    _moveFocusTime(deltaMinutes) {
+        const sel = this._engine.selection();
+        const focused = sel.focusedCell;
+        if (focused) {
+            const newDate = addMinutes(focused.date, deltaMinutes);
+            this._engine.selection.update((s) => ({
+                ...s,
+                focusedCell: { date: newDate, resourceId: focused.resourceId },
+            }));
+        }
+        else {
+            this._moveFocus(0);
+        }
+        this._options.onKeyAction?.('moveFocusTime');
+    }
+    _activateFocused() {
+        const sel = this._engine.selection();
+        const ids = sel.selectedEventIds;
+        if (ids.size === 1) {
+            const eventId = Array.from(ids)[0];
+            const event = this._engine.events().find((e) => e.id === eventId);
+            if (event)
+                this._options.onKeyAction?.('activate');
+        }
+        else {
+            const focused = sel.focusedCell;
+            if (focused) {
+                const dayEvents = this._engine.eventsForDay(focused.date);
+                if (dayEvents.length > 0) {
+                    this._engine.selectEvent(dayEvents[0].id);
+                }
+            }
+        }
+    }
+    _deleteSelected() {
+        if (this._options.onKeyAction?.('delete') === false)
+            return;
+        const ids = this._engine.selection().selectedEventIds;
+        for (const id of ids) {
+            this._engine.removeEvent(id);
+        }
+        this._engine.clearSelection();
+    }
+    _deselect() {
+        this._engine.clearSelection();
+    }
+    _selectAll() {
+        const events = this._engine.events();
+        this._engine.selection.update((s) => ({
+            ...s,
+            selectedEventIds: new Set(events.map((e) => e.id)),
+        }));
+        this._options.onKeyAction?.('selectAll');
+    }
+    _goToday() {
+        this._engine.today();
+        this._options.onKeyAction?.('today');
+    }
+}
+
+function snapToSlot(value, snapDuration) {
+    return Math.round(value / snapDuration) * snapDuration;
+}
+function snapDateToSlot(date, snapDuration) {
+    const ms = date.getTime();
+    const snapMs = snapDuration * 60_000;
+    return new Date(Math.round(ms / snapMs) * snapMs);
+}
+function minutesToPixels(minutes, hourHeight) {
+    return (minutes / 60) * hourHeight;
+}
+function pixelsToMinutes(pixels, hourHeight) {
+    return (pixels / hourHeight) * 60;
+}
+function timeToMinutes(date) {
+    return date.getHours() * 60 + date.getMinutes();
+}
+function minutesToTime(baseDate, minutes) {
+    const d = new Date(baseDate);
+    d.setHours(0, 0, 0, 0);
+    d.setMinutes(minutes);
+    return d;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_SELECTION, DEFAULT_WORKING_HOURS, DragPlugin, KeyboardPlugin, PluginHost, ResizePlugin, SchedulerEngine, SelectionPlugin, TooltipPlugin, addDays, addMinutes, addWeeks, clampDate, createDefaultTooltipState, dateRangeOverlaps, diffDays, diffMinutes, endOfMonth, endOfWeek, formatDateRange, formatHour, getDayNames, getHoursInRange, getMonthGrid, getMonthNames, getWeekDates, getWorkWeekDates, isDayGridView, isPast, isSameDay, isSameWeek, isTimeGridView, isToday, isWeekend, minutesToPixels, minutesToTime, pixelsToMinutes, snapDateToSlot, snapToSlot, startOfDay, startOfMonth, startOfWeek, timeToMinutes };
+//# sourceMappingURL=ngxsmk-cdk-scheduler.mjs.map