@joewinke/jatui 0.41.1 → 0.43.0

package/dist/components/calendar/dayOverlap.js

@@ -0,0 +1,147 @@
+/**
+ * Week/day-view overlap packing.
+ *
+ * Upstreamed from MOS `lib/components/calendar/shared/dayOverlap.ts`
+ * (jatui-lfxyy) with its tests; generic over any `PackableEvent`.
+ *
+ * Month view stacks intervals across seven discrete day columns into vertical
+ * lanes (`monthPacking.ts`). Week and day view have the same interval-graph
+ * problem on the other axis: events run over continuous time inside ONE day
+ * column, so concurrent events have to be sliced into side-by-side
+ * sub-columns. Same shape, different axis — which is why this is a sibling
+ * module rather than a mode flag on `packWeek`.
+ *
+ * The allocator hands out a horizontal slot for every timed event and the grid
+ * renders it as a percentage `left`/`width`, so two meetings at 2pm sit beside
+ * each other instead of one hiding the other.
+ *
+ * The intervals compared here are RENDERED extents, not literal ones. The grid
+ * gives an event with no end a one-hour block and never draws anything shorter
+ * than half an hour, so two five-minute events ten minutes apart really do
+ * collide on screen even though their times do not. Packing the literal times
+ * would call that pair disjoint and stack them back on top of each other.
+ */
+import { parseLocalDate } from "./monthPacking";
+const MS_PER_MIN = 60_000;
+/** Grid block for an event with no end — matches `eventHeightPx`'s 48px. */
+export const DEFAULT_DURATION_MIN = 60;
+/** Shortest block the grid will draw — matches `eventHeightPx`'s 24px floor. */
+export const MIN_DURATION_MIN = 30;
+/**
+ * The vertical extent the grid will actually draw for `ev`, in minutes.
+ *
+ * `start` is read in local time and measured from its own midnight, so an
+ * event running past midnight simply reports an `endMin` above 1440 rather
+ * than wrapping — the comparisons below only ever need it to be monotonic.
+ */
+export function eventInterval(ev, opts = {}) {
+    const defaultDuration = opts.defaultDurationMin ?? DEFAULT_DURATION_MIN;
+    const minDuration = opts.minDurationMin ?? MIN_DURATION_MIN;
+    const start = parseLocalDate(ev.start);
+    const startMin = start.getHours() * 60 + start.getMinutes();
+    let duration = defaultDuration;
+    if (ev.end) {
+        const end = parseLocalDate(ev.end);
+        const ms = end.getTime() - start.getTime();
+        // A missing, unparseable or backwards end is no information at all, so
+        // fall back to the same default block a null end gets.
+        if (Number.isFinite(ms) && ms > 0)
+            duration = ms / MS_PER_MIN;
+    }
+    return { startMin, endMin: startMin + Math.max(duration, minDuration) };
+}
+/** Half-open overlap: two blocks that merely touch do NOT overlap. */
+export function intervalsOverlap(a, b) {
+    return a.startMin < b.endMin && b.startMin < a.endMin;
+}
+/**
+ * Split one day's timed events into side-by-side sub-columns.
+ *
+ * Three passes over the events sorted by start time:
+ *
+ * 1. **Cluster.** Walk in start order carrying the furthest end seen; an event
+ *    starting at or after that end can share no space with anything before it,
+ *    so it opens a new cluster. This is exactly the transitive closure of
+ *    "overlaps" — A and C never touching still share a cluster if B bridges
+ *    them, and they must, or the two halves would be scaled differently and
+ *    B would collide with one of them.
+ * 2. **Assign columns.** Greedily take the first sub-column whose last event
+ *    has already ended. On an interval graph this uses exactly as many columns
+ *    as the busiest instant needs — no cluster is ever sliced thinner than the
+ *    real peak concurrency.
+ * 3. **Widen.** Let each event grow rightward while no event in the next
+ *    sub-column overlaps it, so a lone 4pm event beside a busy 2pm stack still
+ *    reads full width. This cannot reintroduce a collision: for A to widen
+ *    past column c it must be disjoint from everything in column c, and any B
+ *    widening out of column c is in column c.
+ */
+export function layoutDay(events, opts = {}) {
+    const expand = opts.expand ?? true;
+    const items = events.map((ev) => ({
+        ev,
+        ...eventInterval(ev, opts),
+        cluster: 0,
+        column: 0,
+        span: 1,
+    }));
+    // Earliest first, then longest, then title/id — so the same day always packs
+    // the same way regardless of the order the events arrived in.
+    items.sort((a, b) => a.startMin - b.startMin ||
+        b.endMin - a.endMin ||
+        a.ev.title.localeCompare(b.ev.title) ||
+        a.ev.id.localeCompare(b.ev.id));
+    const clusters = [];
+    let current = [];
+    let clusterEnd = -Infinity;
+    for (const it of items) {
+        if (current.length > 0 && it.startMin >= clusterEnd) {
+            clusters.push(current);
+            current = [];
+            clusterEnd = -Infinity;
+        }
+        it.cluster = clusters.length;
+        current.push(it);
+        clusterEnd = Math.max(clusterEnd, it.endMin);
+    }
+    if (current.length > 0)
+        clusters.push(current);
+    const placements = [];
+    for (const cluster of clusters) {
+        // Last end time per sub-column. Within a column every event starts at or
+        // after the previous one ended, so this is that column's max end.
+        const columnEnds = [];
+        for (const it of cluster) {
+            let c = 0;
+            while (c < columnEnds.length && columnEnds[c] > it.startMin)
+                c++;
+            it.column = c;
+            columnEnds[c] = it.endMin;
+        }
+        const columns = columnEnds.length;
+        const unit = 100 / columns;
+        for (const it of cluster) {
+            let span = 1;
+            if (expand) {
+                for (let c = it.column + 1; c < columns; c++) {
+                    const blocked = cluster.some((other) => other.column === c && intervalsOverlap(other, it));
+                    if (blocked)
+                        break;
+                    span++;
+                }
+            }
+            it.span = span;
+            placements.push({
+                ev: it.ev,
+                startMin: it.startMin,
+                endMin: it.endMin,
+                cluster: it.cluster,
+                column: it.column,
+                columns,
+                span,
+                leftPct: it.column * unit,
+                widthPct: span * unit,
+            });
+        }
+    }
+    return placements;
+}

package/dist/components/calendar/eventCalendar.d.ts

@@ -0,0 +1,75 @@
+/**
+ * EventCalendar — the pure layer.
+ *
+ * Everything the month / week / day / agenda views compute that is not
+ * markup: event colour tokens, view titles and stepping, the visible range a
+ * host should load, the month and week matrices with events placed on them
+ * (lane packing is `monthPacking.ts`, timed overlap is `dayOverlap.ts`, both
+ * upstreamed from MOS), and the agenda grouping.
+ */
+import { type Weekday } from './calendarGrid';
+import { type MonthDay, type PackableEvent } from './monthPacking';
+import type { HourCycle } from './timeSlots';
+/** A jatui event hue (1–6 → `--jatui-event-N`) or a DaisyUI semantic name. */
+export type EventColor = 1 | 2 | 3 | 4 | 5 | 6 | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
+export interface CalendarEventItem extends PackableEvent {
+    id: string;
+    title: string;
+    /** ISO datetime, `YYYY-MM-DD` for an all-day day, or a Date. */
+    start: string | Date;
+    /** Inclusive last day for all-day events; the end instant for timed ones. */
+    end?: string | Date | null;
+    allDay?: boolean;
+    color?: EventColor;
+    description?: string;
+    location?: string;
+    /** Set false to pin this event when drag-to-move is on. */
+    draggable?: boolean;
+    /** Anything the host wants back in callbacks. */
+    meta?: Record<string, unknown>;
+}
+export type EventCalendarView = 'month' | 'week' | 'day' | 'agenda';
+/**
+ * Inline custom properties for one event: `--ev` (the hue: dots, stripes),
+ * `--ev-bg` (chip fill) and `--ev-fg` (time / secondary text). All from the
+ * `--jatui-event-*` triplets in tokens.css, so they flip with the theme.
+ * Titles stay `base-content` on the tinted fill, which keeps contrast in
+ * every theme (a saturated fill with `-content` text does not).
+ */
+export declare function eventColorStyle(color: EventColor | undefined): string;
+/** Move the focus date one view-step (month, week, day; agenda pages by month). */
+export declare function stepDate(view: EventCalendarView, date: Date, dir: -1 | 1): Date;
+/** The first and last day a view shows — what a host should load events for. */
+export declare function visibleRange(view: EventCalendarView, date: Date, weekStart?: Weekday): {
+    start: Date;
+    end: Date;
+};
+/** "March 2026", "Mar 1 – 7, 2026", "Wednesday, March 4, 2026". */
+export declare function viewTitle(view: EventCalendarView, date: Date, weekStart?: Weekday, locale?: string): string;
+/** True when an event belongs on the all-day row / a filled bar (all-day or crossing midnight). */
+export declare function isAllDayLike(ev: PackableEvent): boolean;
+/**
+ * Month weeks with every event recorded on each day it touches (the week
+ * packer collapses the repeats into one spanning segment).
+ */
+export declare function buildMonthWeeks<E extends PackableEvent>(date: Date, weekStart: Weekday, events: E[]): MonthDay<E>[][];
+/** Seven days from the week start, each with its all-day-like and timed events. */
+export interface TimeGridDay<E extends PackableEvent> extends MonthDay<E> {
+    timed: E[];
+}
+export declare function buildTimeGridDays<E extends PackableEvent>(days: Date[], events: E[]): TimeGridDay<E>[];
+export declare function weekDates(date: Date, weekStart: Weekday): Date[];
+/** Agenda: the days in [start, end] that have events, each sorted all-day first then by time. */
+export declare function agendaDays<E extends PackableEvent>(events: E[], start: Date, end: Date): {
+    date: Date;
+    events: E[];
+}[];
+/** Compact chip time: "9a" / "9:30a" (h12) or "09:30" (h23). Empty for all-day. */
+export declare function chipTime(ev: PackableEvent, hourCycle?: HourCycle): string;
+/** "Mon, Aug 10 · 9:00 AM – 10:30 AM", "Aug 10 – Aug 16", "Mon, Aug 10 · All day". */
+export declare function eventWhen(ev: PackableEvent, opts?: {
+    hourCycle?: HourCycle;
+    locale?: string;
+}): string;
+/** Hour-row label: "6 AM" (h12) / "06:00" (h23). */
+export declare function hourLabel(h: number, hourCycle?: HourCycle): string;

package/dist/components/calendar/eventCalendar.js

@@ -0,0 +1,187 @@
+/**
+ * EventCalendar — the pure layer.
+ *
+ * Everything the month / week / day / agenda views compute that is not
+ * markup: event colour tokens, view titles and stepping, the visible range a
+ * host should load, the month and week matrices with events placed on them
+ * (lane packing is `monthPacking.ts`, timed overlap is `dayOverlap.ts`, both
+ * upstreamed from MOS), and the agenda grouping.
+ */
+import { addDays, addMonths, buildMonthMatrix, endOfMonth, formatMonthYear, isSameDay, startOfDay, startOfMonth, startOfWeek } from './calendarGrid';
+import { eventDayRange, parseLocalDate } from './monthPacking';
+// ── Colour ─────────────────────────────────────────────────────────────────
+const SEMANTIC_HUE = { primary: 1, secondary: 2, accent: 3, info: 4, success: 5, warning: 6 };
+/**
+ * Inline custom properties for one event: `--ev` (the hue: dots, stripes),
+ * `--ev-bg` (chip fill) and `--ev-fg` (time / secondary text). All from the
+ * `--jatui-event-*` triplets in tokens.css, so they flip with the theme.
+ * Titles stay `base-content` on the tinted fill, which keeps contrast in
+ * every theme (a saturated fill with `-content` text does not).
+ */
+export function eventColorStyle(color) {
+    if (color === 'error') {
+        return [
+            '--ev: var(--jatui-status-negative, var(--color-error))',
+            '--ev-bg: color-mix(in oklab, var(--color-error) 16%, var(--color-base-100))',
+            '--ev-fg: color-mix(in oklab, var(--color-error) 55%, var(--color-base-content))'
+        ].join('; ');
+    }
+    if (color === 'neutral') {
+        return [
+            '--ev: color-mix(in oklab, var(--color-base-content) 45%, transparent)',
+            '--ev-bg: color-mix(in oklab, var(--color-base-content) 9%, var(--color-base-100))',
+            '--ev-fg: color-mix(in oklab, var(--color-base-content) 65%, transparent)'
+        ].join('; ');
+    }
+    const n = typeof color === 'number' ? Math.min(6, Math.max(1, Math.round(color))) : (SEMANTIC_HUE[color ?? 'primary'] ?? 1);
+    return `--ev: var(--jatui-event-${n}); --ev-bg: var(--jatui-event-${n}-bg); --ev-fg: var(--jatui-event-${n}-fg)`;
+}
+// ── Views ──────────────────────────────────────────────────────────────────
+/** Move the focus date one view-step (month, week, day; agenda pages by month). */
+export function stepDate(view, date, dir) {
+    switch (view) {
+        case 'week':
+            return addDays(date, 7 * dir);
+        case 'day':
+            return addDays(date, dir);
+        default:
+            return addMonths(date, dir);
+    }
+}
+/** The first and last day a view shows — what a host should load events for. */
+export function visibleRange(view, date, weekStart = 0) {
+    switch (view) {
+        case 'week': {
+            const start = startOfWeek(date, weekStart);
+            return { start, end: addDays(start, 6) };
+        }
+        case 'day':
+            return { start: startOfDay(date), end: startOfDay(date) };
+        case 'agenda':
+            return { start: startOfMonth(date), end: endOfMonth(date) };
+        default: {
+            const weeks = buildMonthMatrix(date, weekStart);
+            return { start: weeks[0][0].date, end: weeks[weeks.length - 1][6].date };
+        }
+    }
+}
+/** "March 2026", "Mar 1 – 7, 2026", "Wednesday, March 4, 2026". */
+export function viewTitle(view, date, weekStart = 0, locale) {
+    if (view === 'day') {
+        return new Intl.DateTimeFormat(locale, { weekday: 'long', month: 'long', day: 'numeric', year: 'numeric' }).format(date);
+    }
+    if (view === 'week') {
+        const { start, end } = visibleRange('week', date, weekStart);
+        const fmt = new Intl.DateTimeFormat(locale, { month: 'short', day: 'numeric', year: 'numeric' });
+        return typeof fmt.formatRange === 'function' ? fmt.formatRange(start, end) : `${fmt.format(start)} – ${fmt.format(end)}`;
+    }
+    return formatMonthYear(date, locale);
+}
+// ── Placement ──────────────────────────────────────────────────────────────
+/** True when an event belongs on the all-day row / a filled bar (all-day or crossing midnight). */
+export function isAllDayLike(ev) {
+    if (ev.allDay)
+        return true;
+    const [s, e] = eventDayRange(ev);
+    return !isSameDay(s, e);
+}
+/**
+ * Month weeks with every event recorded on each day it touches (the week
+ * packer collapses the repeats into one spanning segment).
+ */
+export function buildMonthWeeks(date, weekStart, events) {
+    const matrix = buildMonthMatrix(date, weekStart);
+    const weeks = matrix.map((w) => w.map((c) => ({ date: c.date, inMonth: c.inMonth, events: [] })));
+    const first = weeks[0][0].date;
+    const last = weeks[weeks.length - 1][6].date;
+    for (const ev of events) {
+        const [s, e] = eventDayRange(ev);
+        if (e < first || s > last)
+            continue;
+        for (const week of weeks) {
+            for (const day of week) {
+                if (day.date >= s && day.date <= e)
+                    day.events.push(ev);
+            }
+        }
+    }
+    return weeks;
+}
+export function buildTimeGridDays(days, events) {
+    const out = days.map((date) => ({ date, inMonth: true, events: [], timed: [] }));
+    for (const ev of events) {
+        if (isAllDayLike(ev)) {
+            const [s, e] = eventDayRange(ev);
+            for (const d of out)
+                if (d.date >= s && d.date <= e)
+                    d.events.push(ev);
+        }
+        else {
+            const start = parseLocalDate(ev.start);
+            const d = out.find((x) => isSameDay(x.date, start));
+            d?.timed.push(ev);
+        }
+    }
+    return out;
+}
+export function weekDates(date, weekStart) {
+    const start = startOfWeek(date, weekStart);
+    return Array.from({ length: 7 }, (_, i) => addDays(start, i));
+}
+/** Agenda: the days in [start, end] that have events, each sorted all-day first then by time. */
+export function agendaDays(events, start, end) {
+    const out = [];
+    for (let d = startOfDay(start); d <= end; d = addDays(d, 1)) {
+        const onDay = events.filter((ev) => {
+            const [s, e] = eventDayRange(ev);
+            return d >= s && d <= e;
+        });
+        if (onDay.length === 0)
+            continue;
+        onDay.sort((a, b) => {
+            if (!!a.allDay !== !!b.allDay)
+                return a.allDay ? -1 : 1;
+            return parseLocalDate(a.start).getTime() - parseLocalDate(b.start).getTime() || a.title.localeCompare(b.title);
+        });
+        out.push({ date: d, events: onDay });
+    }
+    return out;
+}
+// ── Labels ─────────────────────────────────────────────────────────────────
+/** Compact chip time: "9a" / "9:30a" (h12) or "09:30" (h23). Empty for all-day. */
+export function chipTime(ev, hourCycle = 'h12') {
+    if (ev.allDay)
+        return '';
+    const d = parseLocalDate(ev.start);
+    const h = d.getHours();
+    const m = d.getMinutes();
+    if (hourCycle === 'h23')
+        return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
+    const h12 = h % 12 === 0 ? 12 : h % 12;
+    const suffix = h < 12 ? 'a' : 'p';
+    return m === 0 ? `${h12}${suffix}` : `${h12}:${String(m).padStart(2, '0')}${suffix}`;
+}
+/** "Mon, Aug 10 · 9:00 AM – 10:30 AM", "Aug 10 – Aug 16", "Mon, Aug 10 · All day". */
+export function eventWhen(ev, opts = {}) {
+    const { hourCycle = 'h12', locale } = opts;
+    const [s, e] = eventDayRange(ev);
+    const day = (d) => new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric' }).format(d);
+    if (!isSameDay(s, e))
+        return `${day(s)} – ${day(e)}`;
+    if (ev.allDay)
+        return `${day(s)} · All day`;
+    const t = (v) => new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', hourCycle }).format(parseLocalDate(v));
+    return ev.end ? `${day(s)} · ${t(ev.start)} – ${t(ev.end)}` : `${day(s)} · ${t(ev.start)}`;
+}
+/** Hour-row label: "6 AM" (h12) / "06:00" (h23). */
+export function hourLabel(h, hourCycle = 'h12') {
+    if (hourCycle === 'h23')
+        return `${String(h).padStart(2, '0')}:00`;
+    if (h === 0)
+        return '12 AM';
+    if (h < 12)
+        return `${h} AM`;
+    if (h === 12)
+        return '12 PM';
+    return `${h - 12} PM`;
+}

package/dist/components/calendar/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * jatui/calendar — the dates + calendar surface (BoardUI wave 4, jatui-lfxyy).
+ *
+ * Components (also exported from the `jatui` root): DatePicker, the
+ * calendar-mode DateRangePicker, CalendarPicker, TimeSlotPicker,
+ * BookingScheduler, EventCalendar and the shared CalendarMonthGrid panel.
+ * This subpath adds every pure helper behind them: date math, the APG grid
+ * keyboard model, range/preset logic, typed-entry parsing, time-slot zone
+ * handling, and the event engine upstreamed from MOS (month lane packing,
+ * day overlap layout).
+ */
+export { default as CalendarMonthGrid } from './MonthGrid.svelte';
+export type { MonthGridDay, MonthGridProps } from './MonthGrid.svelte';
+export { default as CalendarHeader } from './CalendarHeader.svelte';
+export { default as CalendarPicker } from '../CalendarPicker.svelte';
+export { default as DatePicker } from '../DatePicker.svelte';
+export { default as DateRangePicker } from '../DateRangePicker.svelte';
+export { default as TimeSlotPicker } from '../TimeSlotPicker.svelte';
+export { default as BookingScheduler } from '../BookingScheduler.svelte';
+export { default as EventCalendar } from '../EventCalendar.svelte';
+export { createCalendarGrid } from './createCalendarGrid';
+export type { CalendarGrid, CalendarGridOptions } from './createCalendarGrid';
+export { startOfDay, isSameDay, isSameMonth, addDays, addMonths, startOfMonth, endOfMonth, daysInMonth, dayDiff, startOfWeek, endOfWeek, compareDays, clampDay, toIsoDate, parseIsoDate, toDay, weekStartForLocale, resolveWeekStart, weekdayLabels, formatMonthYear, formatLongDate, formatMediumDate, buildMonthMatrix, nextFocusDate, makeIsDisabled, normalizeRange, isInRange, rangeDayCount, rangeCellState, pickRangeDate, toIsoRange, fromIsoRange, resolvePreset, defaultRangePresets, defaultRangePresetsWithAll, matchPreset, formatRangeLabel, dateFieldOrder, dateSeparator, datePlaceholder, formatTypedDate, parseTypedDate, calendarAccentStyle, followFocus, canStepMonth } from './calendarGrid';
+export type { Weekday, DateRange, IsoDateRange, MonthCell, GridKeyOptions, DateRules, RangeCellState, RangePreset, CalendarAccent } from './calendarGrid';
+export { hourInZone, dayPart, groupSlotsByDayPart, formatSlotTime, formatSlotLabel, localeHourCycle, localTimeZone, timeZoneOffsetLabel, timeZoneCity, commonTimeZones, nextSlotIndex } from './timeSlots';
+export type { HourCycle, DayPart, SlotGroup } from './timeSlots';
+export { parseLocalDate, eventDayRange, packWeek, computeVisibility } from './monthPacking';
+export type { PackableEvent, MonthDay, WeekSegment, PackedWeek, WeekVisibility } from './monthPacking';
+export { eventInterval, intervalsOverlap, layoutDay, DEFAULT_DURATION_MIN, MIN_DURATION_MIN } from './dayOverlap';
+export type { DayOverlapOptions, DayInterval, DayPlacement } from './dayOverlap';
+export { eventColorStyle, stepDate, visibleRange, viewTitle, isAllDayLike, buildMonthWeeks, buildTimeGridDays, weekDates, agendaDays, chipTime, eventWhen, hourLabel } from './eventCalendar';
+export type { CalendarEventItem, EventColor, EventCalendarView, TimeGridDay } from './eventCalendar';

package/dist/components/calendar/index.js

@@ -0,0 +1,25 @@
+/**
+ * jatui/calendar — the dates + calendar surface (BoardUI wave 4, jatui-lfxyy).
+ *
+ * Components (also exported from the `jatui` root): DatePicker, the
+ * calendar-mode DateRangePicker, CalendarPicker, TimeSlotPicker,
+ * BookingScheduler, EventCalendar and the shared CalendarMonthGrid panel.
+ * This subpath adds every pure helper behind them: date math, the APG grid
+ * keyboard model, range/preset logic, typed-entry parsing, time-slot zone
+ * handling, and the event engine upstreamed from MOS (month lane packing,
+ * day overlap layout).
+ */
+export { default as CalendarMonthGrid } from './MonthGrid.svelte';
+export { default as CalendarHeader } from './CalendarHeader.svelte';
+export { default as CalendarPicker } from '../CalendarPicker.svelte';
+export { default as DatePicker } from '../DatePicker.svelte';
+export { default as DateRangePicker } from '../DateRangePicker.svelte';
+export { default as TimeSlotPicker } from '../TimeSlotPicker.svelte';
+export { default as BookingScheduler } from '../BookingScheduler.svelte';
+export { default as EventCalendar } from '../EventCalendar.svelte';
+export { createCalendarGrid } from './createCalendarGrid';
+export { startOfDay, isSameDay, isSameMonth, addDays, addMonths, startOfMonth, endOfMonth, daysInMonth, dayDiff, startOfWeek, endOfWeek, compareDays, clampDay, toIsoDate, parseIsoDate, toDay, weekStartForLocale, resolveWeekStart, weekdayLabels, formatMonthYear, formatLongDate, formatMediumDate, buildMonthMatrix, nextFocusDate, makeIsDisabled, normalizeRange, isInRange, rangeDayCount, rangeCellState, pickRangeDate, toIsoRange, fromIsoRange, resolvePreset, defaultRangePresets, defaultRangePresetsWithAll, matchPreset, formatRangeLabel, dateFieldOrder, dateSeparator, datePlaceholder, formatTypedDate, parseTypedDate, calendarAccentStyle, followFocus, canStepMonth } from './calendarGrid';
+export { hourInZone, dayPart, groupSlotsByDayPart, formatSlotTime, formatSlotLabel, localeHourCycle, localTimeZone, timeZoneOffsetLabel, timeZoneCity, commonTimeZones, nextSlotIndex } from './timeSlots';
+export { parseLocalDate, eventDayRange, packWeek, computeVisibility } from './monthPacking';
+export { eventInterval, intervalsOverlap, layoutDay, DEFAULT_DURATION_MIN, MIN_DURATION_MIN } from './dayOverlap';
+export { eventColorStyle, stepDate, visibleRange, viewTitle, isAllDayLike, buildMonthWeeks, buildTimeGridDays, weekDates, agendaDays, chipTime, eventWhen, hourLabel } from './eventCalendar';

package/dist/components/calendar/monthPacking.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Month-view lane packing.
+ *
+ * Upstreamed from MOS `lib/components/calendar/shared/monthPacking.ts`
+ * (jatui-lfxyy) with its tests. The only change is the event type: any
+ * `PackableEvent` (id, title, start, end?, allDay?) works, and start/end may
+ * be ISO strings or `Date`s. The MOS event type satisfies it as-is.
+ *
+ * A month row has to place two kinds of thing — bars that span several days and
+ * chips that sit on one — and the only way to guarantee they never collide is to
+ * let a single allocator hand out every slot. This module is that allocator. The
+ * grid then renders each segment as a CSS grid item at (column span, lane), so
+ * overlap becomes structurally impossible instead of a matter of keeping two
+ * pixel offsets in agreement.
+ */
+/** The fields packing reads. Extra fields ride along untouched. */
+export interface PackableEvent {
+    id: string;
+    title: string;
+    /** ISO datetime, `YYYY-MM-DD` (local day) or a Date. */
+    start: string | Date;
+    end?: string | Date | null;
+    allDay?: boolean;
+}
+/** Parse "YYYY-MM-DD" as local midnight, not the UTC midnight `new Date` gives. */
+export declare function parseLocalDate(str: string | Date): Date;
+export declare function isSameDay(d1: Date, d2: Date): boolean;
+/** Whole days between two dates, ignoring time of day. */
+export declare function dayDiff(from: Date, to: Date): number;
+export declare function startOfDay(d: Date): Date;
+/**
+ * Inclusive first and last day an event occupies, both at local midnight.
+ *
+ * Flooring is load-bearing: month cells are midnight dates, so a 9am event
+ * whose range kept its time would fail `cell >= start` and disappear from the
+ * grid rather than render an hour late.
+ */
+export declare function eventDayRange(ev: PackableEvent): [Date, Date];
+export interface MonthDay<E extends PackableEvent = PackableEvent> {
+    date: Date;
+    inMonth: boolean;
+    events: E[];
+}
+export interface WeekSegment<E extends PackableEvent = PackableEvent> {
+    ev: E;
+    /** 0-6, clamped into this week */
+    startCol: number;
+    /** 0-6, clamped into this week */
+    endCol: number;
+    /** 0-based vertical slot */
+    lane: number;
+    /** Began before this week's first day */
+    continuesLeft: boolean;
+    /** Ends after this week's last day */
+    continuesRight: boolean;
+    /** Solid bar (all-day or spanning) rather than a dot-and-label chip */
+    filled: boolean;
+    /** Finished before today */
+    past: boolean;
+}
+export interface PackedWeek<E extends PackableEvent = PackableEvent> {
+    segments: WeekSegment<E>[];
+    laneCount: number;
+}
+/**
+ * Assign every event touching `week` a lane, greedily, widest span first.
+ *
+ * `week` must be exactly seven consecutive days, each carrying the events that
+ * touch it (an event covering three days appears on all three). Duplicates are
+ * collapsed into one segment spanning the columns it covers.
+ */
+export declare function packWeek<E extends PackableEvent>(week: MonthDay<E>[], now?: Date): PackedWeek<E>;
+export interface WeekVisibility {
+    /** Lanes actually rendered. */
+    visibleLanes: number;
+    /** Event ids folded into a "+N more" marker. */
+    hiddenIds: Set<string>;
+    /** Per-column hidden count; 0 means no marker for that day. */
+    moreCounts: number[];
+    /** Lane to render a segment in, when recovery moved it off its packed lane. */
+    laneOverrides: Map<string, number>;
+}
+/**
+ * Decide what a row shows given how many lanes fit.
+ *
+ * The "+N more" marker lives in the LAST VISIBLE lane rather than in a lane of
+ * its own. A dedicated marker row costs every column a slot because one busy
+ * day overflowed, which on a short window collapsed whole rows to a single
+ * event. Here only the columns that actually overflow give up their last lane,
+ * so a quiet day beside a busy one keeps showing its events.
+ *
+ * A segment spanning several columns is one grid item, so it cannot be shown
+ * for some of its days and hidden for others: if any column it covers needs the
+ * marker, the whole segment folds in. That can push a further column over, so
+ * this iterates to a fixed point.
+ */
+export declare function computeVisibility<E extends PackableEvent>(segments: WeekSegment<E>[], capacity: number): WeekVisibility;