@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.1

package/scheduler/behaviour.js

@@ -0,0 +1,243 @@
+// Ported from @malva-ui/scheduler (src/lib/layout/scheduler-focus.ts `findEventElement` / `findCellElement`), MIT,
+// © 2026 Malva UI.
+// Rivet: the DOM lookups of the delegated keyboard / focus handlers (`keys*.ts`). Attribute names carry the
+// `data-rv-` prefix (`data-rv-event-id`, `data-rv-day-index`, `data-rv-minutes`). No JSX, no import-time DOM work.
+// Month `+N more` toggle / close / focus: port of src/lib/month/scheduler-month.ts `_openMore` / `onClose` (T3).
+// `schedulerPress` (T6): the delegated press of the views (no malva counterpart: malva binds SortableJS per list and
+// `attachPointerDrag` per handle at render); loads the drag chunk (`drag.ts`) on the first press of a chip / handle.
+import { untrack } from "@rivetjs/reactivity";
+import { DEV } from "#dev";
+import { schedulerSelectable } from "./selection.js";
+/** Chip attribute holding the event id. */
+export const EVENT_ID_ATTR = "data-rv-event-id";
+/** Cell / column attribute holding the visible-day index. */
+export const DAY_INDEX_ATTR = "data-rv-day-index";
+/** Cell attribute: `"all-day"` (month cell, all-day cell) or the slot's minutes of day. */
+export const MINUTES_ATTR = "data-rv-minutes";
+/**
+ * The chip element rendering `id`, or `null`. Attribute comparison, so ids need no escaping.
+ *
+ * A multi-day event renders one chip per day and every one of them carries the same event id, so `dayIndex` picks the
+ * segment: the chip whose owning cell or column declares that day index. It is a preference, not a filter — an index
+ * no chip claims any more (the segment was resized away, or the change scrolled the range) falls back to the first
+ * chip of `id`.
+ */
+export function findEventElement(root, id, dayIndex) {
+    let first = null;
+    for (const element of Array.from(root.querySelectorAll("[" + EVENT_ID_ATTR + "]"))) {
+        if (element.getAttribute(EVENT_ID_ATTR) !== id)
+            continue;
+        if (dayIndex === undefined)
+            return element;
+        first ??= element;
+        const owner = element.closest("[" + DAY_INDEX_ATTR + "]");
+        if (owner && Number(owner.getAttribute(DAY_INDEX_ATTR)) === dayIndex)
+            return element;
+    }
+    return first;
+}
+/**
+ * The focusable cell for a day (`minutes === null`: a month cell or all-day cell, `data-rv-minutes="all-day"`) or a
+ * time slot (`data-rv-minutes="<n>"`).
+ */
+export function findCellElement(root, dayIndex, minutes) {
+    const minutesAttr = minutes === null ? "all-day" : String(minutes);
+    return root.querySelector("[" + DAY_INDEX_ATTR + '="' + dayIndex + '"][' + MINUTES_ATTR + '="' + minutesAttr + '"]');
+}
+/** The scheduler root owning `element` (a chip in the `+N more` panel lives in a portal: found through its trigger). */
+export function schedulerRootOf(element) {
+    const root = element.closest("[data-rv-scheduler]");
+    if (root)
+        return root;
+    const panel = element.closest("[role=group][id]");
+    return panel ? (panel.ownerDocument.querySelector(`[aria-controls="${panel.id}"]`)?.closest("[data-rv-scheduler]") ?? null) : null;
+}
+/** The `+N more` button of a day, or `null` when the day does not overflow. */
+export function moreButtonOf(root, dayIndex) {
+    return root.querySelector("[" + DAY_INDEX_ATTR + '="' + dayIndex + '"] [data-rv-more]');
+}
+function dayIndexOfElement(element) {
+    const owner = element?.closest("[" + DAY_INDEX_ATTR + "]");
+    return owner ? Number(owner.getAttribute(DAY_INDEX_ATTR)) : null;
+}
+/** Focuses the first chip of the open panel once it rendered (the overlay mounts on the next flush). */
+function focusPanel(popoverId, attempts = 4) {
+    const panel = typeof document === "undefined" ? null : document.getElementById(popoverId);
+    const chip = panel?.querySelector("[" + EVENT_ID_ATTR + "]:not([data-ghost])") ?? panel;
+    if (chip)
+        chip.focus({ preventScroll: true });
+    else if (attempts > 0)
+        requestAnimationFrame(() => focusPanel(popoverId, attempts - 1));
+}
+/**
+ * `+N more` press (malva `_openMore`): toggles its own panel (a second press closes it, focus back on the button, no
+ * `onMoreAction`), else opens the panel for its day, emits `onMoreAction({ date, events: hidden })` and moves focus to
+ * the panel's first chip.
+ */
+export function monthMoreClick(event, ctx) {
+    const trigger = event.target?.closest("[data-rv-more]");
+    if (!trigger)
+        return;
+    event.stopPropagation();
+    const dayIndex = dayIndexOfElement(trigger);
+    if (dayIndex === null)
+        return;
+    const state = ctx.state;
+    if (untrack(state.popoverDay) === dayIndex) {
+        state.popoverDay.set(null);
+        trigger.focus();
+        return;
+    }
+    const cell = ctx.cell(dayIndex);
+    if (!cell)
+        return;
+    ctx.onMoreAction({ date: ctx.moreDate(cell.day), events: cell.hidden });
+    state.popoverDay.set(dayIndex);
+    requestAnimationFrame(() => focusPanel(ctx.popoverId));
+}
+/**
+ * Panel dismissed (Escape, outside press): closes it; focus that fell to `<body>` with the panel (or sat inside it)
+ * returns to the button — a close while focus sits elsewhere (the user pressed another cell) leaves it there.
+ */
+export function closeMorePanel(ctx, root) {
+    const state = ctx.state;
+    const dayIndex = untrack(state.popoverDay);
+    if (dayIndex === null)
+        return;
+    const panel = typeof document === "undefined" ? null : document.getElementById(ctx.popoverId);
+    const doc = root?.ownerDocument;
+    const active = doc?.activeElement ?? null;
+    const held = !active || active === doc?.body || (!!panel && panel.contains(active));
+    const trigger = root ? moreButtonOf(root, dayIndex) : null;
+    state.popoverDay.set(null);
+    if (!held || !trigger)
+        return;
+    requestAnimationFrame(() => {
+        const now = trigger.ownerDocument.activeElement;
+        if (!now || now === trigger.ownerDocument.body || (panel && panel.contains(now)))
+            trigger.focus();
+    });
+}
+/** Roving tab stop follows focus onto a cell. */
+export function monthFocusIn(event, ctx) {
+    const target = event.target;
+    if (!target || target.getAttribute("role") !== "gridcell")
+        return;
+    const dayIndex = dayIndexOfElement(target);
+    const cell = dayIndex === null ? null : ctx.cell(dayIndex);
+    if (cell)
+        ctx.focusDay.set(cell.day);
+}
+/** Roving tab stop follows focus onto a slot or an all-day cell (malva `_onCellFocus`). */
+export function timeGridFocusIn(event, days, focus) {
+    const target = event.target;
+    const role = target?.getAttribute("role");
+    if (!target || (role !== "option" && role !== "gridcell"))
+        return;
+    const dayIndex = Number(target.getAttribute(DAY_INDEX_ATTR));
+    const raw = target.getAttribute(MINUTES_ATTR);
+    const day = days[dayIndex];
+    if (day === undefined || raw === null)
+        return;
+    focus.set({ day, minutes: raw === "all-day" ? null : Number(raw) });
+}
+// ─── Chip drag / resize (delegated on the month grid, the `+N more` panel and the time-grid sheet) ──
+/** Resize handle of a chip (`data-edge="start" | "end"`). */
+const HANDLE = ".rv-SchedulerEvent-resize-handle";
+const MOUSE_AFTER_TOUCH = 800;
+let lastTouch = -Infinity;
+/**
+ * Press on a view (`mousedown` / `touchstart` move a chip, `pointerdown` on a resize handle resizes it): finds the
+ * draggable chip (never a ghost, never `data-draggable="false"`), records whether the press ends before the lazily
+ * imported drag chunk (`drag.ts`) arrives, then hands the press over. Emulated mouse events after a touch are ignored
+ * (cdk drag-drop rule). Nothing is loaded for presses on cells, handles of read-only chips or secondary buttons.
+ */
+export function schedulerPress(event, state) {
+    const target = event.target;
+    if (!target || event.button > 0)
+        return;
+    const type = event.type;
+    const handle = target.closest(HANDLE);
+    if (type === "touchstart")
+        lastTouch = Date.now();
+    if (type === "pointerdown") {
+        if (!handle)
+            return pressCell(event, state, target);
+    }
+    else if (handle || (type === "mousedown" && Date.now() - lastTouch < MOUSE_AFTER_TOUCH))
+        return;
+    const chip = target.closest("[" + EVENT_ID_ATTR + "]");
+    if (!chip || chip.hasAttribute("data-ghost") || (!handle && chip.getAttribute("data-draggable") === "false"))
+        return;
+    if (handle)
+        event.stopPropagation();
+    const doc = chip.ownerDocument;
+    const at = Date.now();
+    let released = false;
+    const ends = handle ? ["pointerup", "pointercancel"] : ["mouseup", "touchend", "touchcancel"];
+    const onEnd = () => (released = true);
+    for (const name of ends)
+        doc.addEventListener(name, onEnd, true);
+    const release = () => {
+        for (const name of ends)
+            doc.removeEventListener(name, onEnd, true);
+    };
+    import("./drag.js")
+        .then((drag) => {
+        release();
+        if (handle)
+            drag.startChipResize(state, event, handle, released);
+        else
+            drag.startChipMove(state, event, chip, released, Date.now() - at);
+    })
+        .catch(chunkFailed(release));
+}
+/**
+ * Press on a cell (malva `_onGridPointerDown` / `_onSheetPointerDown`): a press outside a pending selection abandons
+ * it (a later `Enter` must act on what was pressed), then — when range selection is on — the range-select chunk
+ * (`select.ts`) takes the press. Presses on chips, buttons (`+N more`) or outside a cell start nothing.
+ */
+function pressCell(event, state, target) {
+    const cell = target.closest("[" + DAY_INDEX_ATTR + "][" + MINUTES_ATTR + "]");
+    const raw = cell?.getAttribute(MINUTES_ATTR);
+    const pos = cell ? { dayIndex: Number(cell.getAttribute(DAY_INDEX_ATTR)), minutes: raw === "all-day" ? null : Number(raw) } : null;
+    // The views paint selected cells `data-selected` (`selection.ts` `isCellSelected`): no state / layout code here.
+    if (untrack(state.selection) && !cell?.hasAttribute("data-selected"))
+        state.selection.set(null);
+    if (!pos || target.closest("[" + EVENT_ID_ATTR + "], button") || !untrack(() => schedulerSelectable(state)))
+        return;
+    const surface = event.currentTarget;
+    if (!surface)
+        return;
+    const doc = surface.ownerDocument;
+    let released = false;
+    const onEnd = () => (released = true);
+    for (const name of ["pointerup", "pointercancel"])
+        doc.addEventListener(name, onEnd, true);
+    const release = () => {
+        for (const name of ["pointerup", "pointercancel"])
+            doc.removeEventListener(name, onEnd, true);
+    };
+    import("./select.js")
+        .then((select) => {
+        release();
+        select.startRangeSelect(state, event, surface, pos, released);
+    })
+        .catch(chunkFailed(release));
+}
+/** Hit-area `DropList` `onDropped` (external drop, T7): hands the drop to the drag chunk. */
+export function schedulerExternalDrop(drop, state) {
+    import("./drag.js").then((drag) => drag.externalDrop(state, drop)).catch(chunkFailed());
+}
+/**
+ * Rejection path of a lazy gesture chunk (network error, stale deploy) or of the gesture start it runs: drops the
+ * press listeners added for it (idempotent) and reports the failure in development (no unhandled rejection; the press
+ * simply starts nothing).
+ */
+function chunkFailed(release) {
+    return (error) => {
+        release?.();
+        if (DEV)
+            console.error("[rivet:cdk] scheduler: a gesture chunk failed to load or start; the press starts nothing.", error);
+    };
+}

package/scheduler/context.d.ts

@@ -0,0 +1,100 @@
+import type { Content } from "@rivetjs/runtime/jsx-runtime";
+import type { SchedulerEvent, SchedulerEventInteraction, SchedulerLayoutRange, SchedulerMoreEvent, SchedulerNormalizedEvent, SchedulerSlotEvent, SchedulerView } from "./layout.js";
+import type { SchedulerMessageKey } from "./intl.js";
+import type { SchedulerDate } from "./dates.js";
+import type { SchedulerState } from "./state.js";
+/** State handed to `renderEvent` (accessor-free snapshot of the chip; the render function re-runs on change). */
+export interface SchedulerEventRenderState {
+    /** The view the chip renders in. */
+    readonly view: SchedulerView;
+    /** Rendered in a lane (month grid, all-day band, `+N more` panel) instead of on the time axis. */
+    readonly allDay: boolean;
+    /** The event started before this segment. */
+    readonly continuesBefore: boolean;
+    /** The event ends after this segment. */
+    readonly continuesAfter: boolean;
+    /** The drag-preview copy of an event being dragged. */
+    readonly isGhost: boolean;
+    /** Formatted time of the chip (`"9:00 AM"` in a lane, `"9:00 AM – 9:30 AM"` on the time axis; empty all-day). */
+    readonly time: string;
+}
+/** `renderEvent` (read once at mount): chip content. */
+export type SchedulerRenderEvent<T = unknown> = (event: SchedulerEvent<T>, state: SchedulerEventRenderState) => Content;
+/** The time axis of the time grid in minutes of day (`last` = start of the last RENDERED slot row). */
+export interface SchedulerAxis {
+    readonly min: number;
+    readonly max: number;
+    readonly slot: number;
+    readonly snap: number;
+    readonly last: number;
+}
+/** Interaction kinds shared by chips and cells (malva `MlvSchedulerInteractionKind`). */
+export type SchedulerInteractionKind = "click" | "dblclick" | "contextmenu";
+/** Where a slot interaction happened: day number, slot minutes (`null` = the day), painted by a pending selection. */
+export interface SchedulerSlotPosition {
+    readonly day: number;
+    readonly minutes: number | null;
+    readonly inSelection: boolean;
+}
+/** Root → views contract. */
+export interface SchedulerContextValue<T = unknown> {
+    readonly state: SchedulerState<T>;
+    readonly view: () => SchedulerView;
+    readonly locale: () => string;
+    readonly timeZone: () => string;
+    /** Rendered day numbers (after `hiddenDays`). */
+    readonly days: () => readonly number[];
+    /** Visible days per month week row. */
+    readonly rowLength: () => number;
+    /** Day number of the anchor date. */
+    readonly anchorDay: () => number;
+    /** Today's day number, `null` while `showCurrentTime` is off (no today highlight). */
+    readonly today: () => number | null;
+    /** Weekend weekdays (0 = Sunday). */
+    readonly weekend: () => readonly number[];
+    /** Normalized events plus the drag ghost. */
+    readonly events: () => readonly SchedulerNormalizedEvent<T>[];
+    readonly visibleLanes: () => number;
+    readonly editable: () => boolean;
+    readonly selectable: () => boolean;
+    readonly showWeekNumbers: () => boolean;
+    /** A day as a date in the anchor's form (all-day: date-only for strings / `CalendarDate`). */
+    readonly dateOf: (day: number) => SchedulerDate;
+    /** Translated message (resolved table, plural selection). */
+    readonly t: (key: SchedulerMessageKey | "moreEvents" | "moreEventsLabel", vars?: Record<string, string | number | boolean>) => string;
+    /** Id of the visually hidden drag hint (chips' `aria-describedby`). */
+    readonly dragHintId: string;
+    /** Id of the `+N more` panel. */
+    readonly popoverId: string;
+    readonly renderEvent: SchedulerRenderEvent<T> | undefined;
+    /** The normalized (non-ghost) event of `id`, `null` once it left the model. */
+    readonly normalized: (id: string) => SchedulerNormalizedEvent<T> | null;
+    /** `commitChange` from the keyboard; returns whether it was applied. */
+    readonly commit: (kind: "move" | "resize", normalized: SchedulerNormalizedEvent<T>, next: SchedulerLayoutRange) => boolean;
+    /** Navigates to the period containing `day` (`schedulerGoTo`, the anchor's form). */
+    readonly goTo: (day: number) => void;
+    /** The nearest rendered weekday from `day` in `direction` (malva `nextVisibleDate`). */
+    readonly stepDay: (day: number, direction: -1 | 1) => number;
+    /** One month from `day` (same day of month, clamped), skipped on to a rendered weekday (malva `_page`). */
+    readonly pageMonth: (day: number, direction: -1 | 1) => number;
+    /** A slot's date (`minutes` `null` = the day, all-day) in the anchor's form; 24:00 rolls over to the next day. */
+    readonly slotDate: (day: number, minutes: number | null) => SchedulerDate;
+    readonly axis: () => SchedulerAxis;
+    /** Reads the pending selection back as a `selectionHint` announcement. */
+    readonly announceSelection: () => void;
+    /** Commits the pending selection (`onRangeSelect`, source keyboard). */
+    readonly commitSelection: () => void;
+    /** Chip interaction → `onEventAction` / `onEventDoubleClick` / `onEventContextMenu`; a context menu opens `renderEventMenu` first. */
+    readonly eventInteraction: (kind: SchedulerInteractionKind, interaction: SchedulerEventInteraction<T>) => void;
+    /** `Delete` / `Backspace` on a chip → `onEventDelete`. */
+    readonly eventDelete: (interaction: SchedulerEventInteraction<T>) => void;
+    /** Cell interaction → `onSlotAction` / `onSlotDoubleClick` / `onSlotContextMenu`; a context menu opens `renderSlotMenu` first. */
+    readonly slotInteraction: (kind: SchedulerInteractionKind, slot: SchedulerSlotEvent, at: SchedulerSlotPosition) => void;
+    /** `renderEventMenu` is given (a chip right-click / ContextMenu key opens the built-in menu). */
+    readonly hasEventMenu: boolean;
+    /** `renderSlotMenu` is given. */
+    readonly hasSlotMenu: boolean;
+    readonly onMoreAction: ((event: SchedulerMoreEvent<T>) => void) | undefined;
+}
+/** The scheduler's root context (resume id `rv-scheduler`). */
+export declare const SchedulerContext: import("@rivetjs/reactivity").Context<SchedulerContextValue<any> | null>;

package/scheduler/context.jsx

@@ -0,0 +1,7 @@
+// Ported from @malva-ui/scheduler (src/lib/scheduler/scheduler-context.ts `MLV_SCHEDULER_CONTEXT`), MIT, © 2026 Malva UI.
+// Rivet: the root → views contract as one resumable context (`rv-scheduler`). The root builds every accessor as an
+// inline arrow / `computed` in its own `.tsx` render (resumable); views read them, never the root's props.
+import { createContext } from "@rivetjs/reactivity";
+import { resumableContext } from "@rivetjs/runtime/resume-format";
+/** The scheduler's root context (resume id `rv-scheduler`). */
+export const SchedulerContext = resumableContext(createContext(null, { id: "rv-scheduler" }));

package/scheduler/dates.d.ts

@@ -0,0 +1,53 @@
+import { type DateValue } from "../date/CalendarDate.js";
+import type { DateValueString } from "../date/serialize.js";
+/** A scheduler date input: a `@rivetjs/cdk/date` value or its `DateValueString`. */
+export type SchedulerDate = DateValue | DateValueString;
+/** A point on the layout axis. */
+export interface LayoutTime {
+    /** Days since 1970-01-01 (proleptic Gregorian). */
+    readonly day: number;
+    /** Minutes of day, `0`–`1439`. */
+    readonly minute: number;
+}
+/** Day number of a proleptic Gregorian date (`month` 1–12). */
+export declare function dayFromCivil(year: number, month: number, day: number): number;
+/** `[year, month (1–12), day]` of a day number. */
+export declare function civilFromDay(dayNumber: number): [number, number, number];
+/** `day` plus `months` calendar months: same day of month, clamped to the target month's length (malva `addCalendarMonths`). */
+export declare function addCalendarMonths(day: number, months: number): number;
+/** Weekday of a day number, 0 = Sunday … 6 = Saturday. */
+export declare function dayOfWeek(day: number): number;
+/** The day number a wall-minute value falls on. */
+export declare function dayOf(wall: number): number;
+/** Minutes of day of a wall-minute value (`0`–`1439`). */
+export declare function minuteOf(wall: number): number;
+/**
+ * Wall minutes (`day * 1440 + minute`) of a date input on the wall clock of `timeZone`, or `null` when the input
+ * does not parse. Dates read as midnight; `ZonedDateTime` (instance or string) converts from its own zone into
+ * `timeZone`; `CalendarDateTime` is a wall-clock value already (no zone).
+ */
+export declare function toWallMinutes(value: SchedulerDate | null | undefined, timeZone?: string): number | null;
+/** `toWallMinutes` split into `{ day, minute }`. */
+export declare function toLayoutTime(value: SchedulerDate | null | undefined, timeZone?: string): LayoutTime | null;
+/**
+ * The layout point `day` + `minute` (minutes past 1440 roll into the next days) written back in the form of
+ * `like`: a string in → a string out (same shape and `[u-ca=…]` annotation); an instance in → the same class,
+ * calendar and zone out. `allDay` (default: `like` is a plain date) picks a date-only result for a date `like`
+ * and a timed one otherwise (`CalendarDate` → `CalendarDateTime`); date-time / zoned `like`s keep their class
+ * (all-day = midnight). A wall time in a DST gap resolves `"compatible"` (later).
+ */
+export declare function fromLayout<V extends SchedulerDate>(day: number, minute: number, like: V, timeZone?: string, allDay?: boolean): V;
+/** Today's day number on the wall clock of `timeZone`. */
+export declare function todayDay(timeZone: string): number;
+/** The current wall minutes in `timeZone`. */
+export declare function nowWall(timeZone: string): number;
+/**
+ * Formats a day number (labels: weekday names, day of month, titles). `options` are `Intl.DateTimeFormat` options;
+ * the zone is fixed to UTC (day numbers are wall-clock days), the calendar follows the locale (`-u-ca-…`).
+ * Formatters are cached per locale + options (`i18n/intl-cache`).
+ */
+export declare function formatDay(day: number, locale: string, options: Intl.DateTimeFormatOptions): string;
+/** Formats wall minutes (time labels) like `formatDay`. */
+export declare function formatWall(wall: number, locale: string, options: Intl.DateTimeFormatOptions): string;
+/** Formats a range of day numbers / wall minutes (`formatRange`, e.g. a week title). */
+export declare function formatDayRange(start: number, end: number, locale: string, options: Intl.DateTimeFormatOptions): string;

package/scheduler/dates.js

@@ -0,0 +1,183 @@
+// Rivet-authored date bridge of `@rivetjs/cdk/scheduler` (replaces malva's `MlvDateAdapter<D>` calls in
+// @malva-ui/scheduler `layout/*.ts`, MIT, © 2026 Malva UI — mapping table in `scheduler/CLAUDE.md`).
+// Layout runs on integers only:
+// - `day`  = days since 1970-01-01, proleptic Gregorian (`dayFromCivil`), weekday `(day + 4) % 7` (0 = Sunday);
+// - `minute` = minutes of day 0…1440; "wall minutes" = `day * 1440 + minute` (one integer per instant on the
+//   wall clock of the scheduler `timeZone`; arithmetic = wall-clock arithmetic, so a 00:00 → 24:00 event covers
+//   the whole day on a DST day too).
+// Inputs: `CalendarDate` / `CalendarDateTime` / `ZonedDateTime` (any calendar) or their `DateValueString` form
+// (`@rivetjs/cdk/date` `stringifyDateValue`). A string's ISO body is always proleptic Gregorian (the `[u-ca=…]`
+// annotation only names the calendar it parses back into), so strings are read with one regex and no calendar
+// code. Results are written back by `fromLayout` in the form of a `like` value: string in → string out (same
+// annotation), instance in → same class, calendar and zone out.
+// Deviation: malva's "Invalid Date propagates" → an unparsable value reads as `null` (the event is not placed).
+import { CalendarDate, CalendarDateTime, ZonedDateTime } from "../date/CalendarDate.js";
+import { GregorianCalendar } from "../date/calendars/GregorianCalendar.js";
+import { fromAbsolute, getTimeZoneOffset, toAbsolute, toCalendar } from "../date/conversion.js";
+import { now, today } from "../date/queries.js";
+import { DateFormatter } from "../date/DateFormatter.js";
+import { cachedIntl } from "../i18n/intl-cache.js";
+import { MINUTES_PER_DAY } from "./time.js";
+const DAY_MS = 86_400_000;
+const MINUTE_MS = 60_000;
+let gregorian;
+/** Day number of a proleptic Gregorian date (`month` 1–12). */
+export function dayFromCivil(year, month, day) {
+    const y = month <= 2 ? year - 1 : year;
+    const era = Math.floor(y / 400);
+    const yoe = y - era * 400;
+    const doy = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
+    const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+    return era * 146097 + doe - 719468;
+}
+/** `[year, month (1–12), day]` of a day number. */
+export function civilFromDay(dayNumber) {
+    const z = dayNumber + 719468;
+    const era = Math.floor(z / 146097);
+    const doe = z - era * 146097;
+    const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
+    const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+    const mp = Math.floor((5 * doy + 2) / 153);
+    const day = doy - Math.floor((153 * mp + 2) / 5) + 1;
+    const month = mp < 10 ? mp + 3 : mp - 9;
+    return [yoe + era * 400 + (month <= 2 ? 1 : 0), month, day];
+}
+/** `day` plus `months` calendar months: same day of month, clamped to the target month's length (malva `addCalendarMonths`). */
+export function addCalendarMonths(day, months) {
+    const [y, m, d] = civilFromDay(day);
+    const month0 = m - 1 + months;
+    const year = y + Math.floor(month0 / 12);
+    const month = ((month0 % 12) + 12) % 12;
+    const length = dayFromCivil(month === 11 ? year + 1 : year, month === 11 ? 1 : month + 2, 1) - dayFromCivil(year, month + 1, 1);
+    return dayFromCivil(year, month + 1, Math.min(d, length));
+}
+/** Weekday of a day number, 0 = Sunday … 6 = Saturday. */
+export function dayOfWeek(day) {
+    return (((day + 4) % 7) + 7) % 7;
+}
+/** The day number a wall-minute value falls on. */
+export function dayOf(wall) {
+    return Math.floor(wall / MINUTES_PER_DAY);
+}
+/** Minutes of day of a wall-minute value (`0`–`1439`). */
+export function minuteOf(wall) {
+    return wall - dayOf(wall) * MINUTES_PER_DAY;
+}
+const ISO = /^([+-]?\d{4,6})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:([+-])(\d{2}):(\d{2})(?::\d{2})?)?(?:\[([^\]=]+)\])?)?/;
+/** Wall minutes of `ms` (epoch) on the wall clock of `timeZone`. */
+function wallOfAbsolute(ms, timeZone) {
+    return Math.floor((ms + getTimeZoneOffset(ms, timeZone)) / MINUTE_MS);
+}
+/**
+ * Wall minutes (`day * 1440 + minute`) of a date input on the wall clock of `timeZone`, or `null` when the input
+ * does not parse. Dates read as midnight; `ZonedDateTime` (instance or string) converts from its own zone into
+ * `timeZone`; `CalendarDateTime` is a wall-clock value already (no zone).
+ */
+export function toWallMinutes(value, timeZone = "UTC") {
+    if (value == null)
+        return null;
+    if (typeof value === "string") {
+        const m = ISO.exec(value);
+        if (!m)
+            return null;
+        const day = dayFromCivil(Number(m[1]), Number(m[2]), Number(m[3]));
+        const local = day * MINUTES_PER_DAY + (m[4] ? Number(m[4]) * 60 + Number(m[5]) : 0);
+        if (!m[7] || !m[10] || m[10] === timeZone)
+            return Number.isFinite(local) ? local : null;
+        const offset = (m[7] === "-" ? -1 : 1) * (Number(m[8]) * 60 + Number(m[9]));
+        const seconds = m[6] ? Number(m[6]) : 0;
+        return wallOfAbsolute((local - offset) * MINUTE_MS + seconds * 1000, timeZone);
+    }
+    let v = value;
+    if (v.calendar.identifier !== "gregory")
+        v = toCalendar(v, (gregorian ??= new GregorianCalendar()));
+    const year = v.era === "BC" ? 1 - v.year : v.year;
+    const local = dayFromCivil(year, v.month, v.day) * MINUTES_PER_DAY + ("hour" in v ? v.hour * 60 + v.minute : 0);
+    if (!(v instanceof ZonedDateTime) || v.timeZone === timeZone)
+        return local;
+    return wallOfAbsolute(local * MINUTE_MS + v.second * 1000 + v.millisecond - v.offset, timeZone);
+}
+/** `toWallMinutes` split into `{ day, minute }`. */
+export function toLayoutTime(value, timeZone = "UTC") {
+    const wall = toWallMinutes(value, timeZone);
+    return wall === null ? null : { day: dayOf(wall), minute: minuteOf(wall) };
+}
+const pad = (n, width = 2) => String(n).padStart(width, "0");
+function isoYear(year) {
+    return year < 0 ? "-" + pad(-year, 6) : year > 9999 ? "+" + pad(year, 6) : pad(year, 4);
+}
+/**
+ * The layout point `day` + `minute` (minutes past 1440 roll into the next days) written back in the form of
+ * `like`: a string in → a string out (same shape and `[u-ca=…]` annotation); an instance in → the same class,
+ * calendar and zone out. `allDay` (default: `like` is a plain date) picks a date-only result for a date `like`
+ * and a timed one otherwise (`CalendarDate` → `CalendarDateTime`); date-time / zoned `like`s keep their class
+ * (all-day = midnight). A wall time in a DST gap resolves `"compatible"` (later).
+ */
+export function fromLayout(day, minute, like, timeZone = "UTC", allDay) {
+    const wall = day * MINUTES_PER_DAY + minute;
+    const d = dayOf(wall);
+    const mins = wall - d * MINUTES_PER_DAY;
+    const [year, month, date] = civilFromDay(d);
+    const hour = Math.floor(mins / 60);
+    const min = mins % 60;
+    if (typeof like === "string") {
+        const m = ISO.exec(like);
+        const annotation = /\[u-ca=[a-z0-9-]+\]$/.exec(like)?.[0] ?? "";
+        const isDate = !m?.[4];
+        const zone = m?.[10];
+        const dateOnly = allDay ?? isDate;
+        const body = isoYear(year) + "-" + pad(month) + "-" + pad(date);
+        if (zone) {
+            const ms = toAbsolute(new CalendarDateTime(year, month, date, hour, min), timeZone);
+            const zoned = fromAbsolute(ms, zone);
+            return (zoned.toString() + annotation);
+        }
+        if (isDate && dateOnly)
+            return (body + annotation);
+        return (body + "T" + pad(hour) + ":" + pad(min) + ":00" + annotation);
+    }
+    const value = like;
+    const isDate = !("hour" in value);
+    let out;
+    if (value instanceof ZonedDateTime) {
+        const ms = toAbsolute(new CalendarDateTime(year, month, date, hour, min), timeZone);
+        out = fromAbsolute(ms, value.timeZone);
+    }
+    else if (isDate && (allDay ?? true)) {
+        out = new CalendarDate(year, month, date);
+    }
+    else {
+        out = new CalendarDateTime(year, month, date, hour, min);
+    }
+    if (value.calendar.identifier !== "gregory")
+        out = toCalendar(out, value.calendar);
+    return out;
+}
+/** Today's day number on the wall clock of `timeZone`. */
+export function todayDay(timeZone) {
+    const t = today(timeZone);
+    return dayFromCivil(t.year, t.month, t.day);
+}
+/** The current wall minutes in `timeZone`. */
+export function nowWall(timeZone) {
+    const n = now(timeZone);
+    return dayFromCivil(n.year, n.month, n.day) * MINUTES_PER_DAY + n.hour * 60 + n.minute;
+}
+const Formatter = DateFormatter;
+const formatter = (locale, options) => cachedIntl(Formatter, locale, { ...options, timeZone: "UTC" });
+/**
+ * Formats a day number (labels: weekday names, day of month, titles). `options` are `Intl.DateTimeFormat` options;
+ * the zone is fixed to UTC (day numbers are wall-clock days), the calendar follows the locale (`-u-ca-…`).
+ * Formatters are cached per locale + options (`i18n/intl-cache`).
+ */
+export function formatDay(day, locale, options) {
+    return formatter(locale, options).format(new Date(day * DAY_MS));
+}
+/** Formats wall minutes (time labels) like `formatDay`. */
+export function formatWall(wall, locale, options) {
+    return formatter(locale, options).format(new Date(wall * MINUTE_MS));
+}
+/** Formats a range of day numbers / wall minutes (`formatRange`, e.g. a week title). */
+export function formatDayRange(start, end, locale, options) {
+    return formatter(locale, options).formatRange(new Date(start * DAY_MS), new Date(end * DAY_MS));
+}

package/scheduler/drag.d.ts

@@ -0,0 +1,20 @@
+import { type SchedulerDropTarget } from "./layout.js";
+import type { DragDrop } from "../drag-drop/drag-events.js";
+import { type SchedulerPointerPosition } from "./pointer.js";
+import { type SchedulerState } from "./state.js";
+/** malva `resolveTarget`: the drop target under `pointer` inside `root`, `null` outside every list. */
+export declare function resolveDropTarget(state: SchedulerState<any>, root: HTMLElement, pointer: SchedulerPointerPosition, top: number | null, grabDayOffset: number): SchedulerDropTarget | null;
+/**
+ * Drag-moves `chip` from the press that loaded this chunk (`age` = ms since the press: the touch delay keeps its
+ * original timing). `released` = the press ended while the chunk loaded (a click: nothing starts).
+ */
+export declare function startChipMove<T>(state: SchedulerState<T>, press: MouseEvent | TouchEvent, chip: HTMLElement, released: boolean, age: number): void;
+/** Resizes the chip of `handle` from the press that loaded this chunk (malva `_attachResize`). */
+export declare function startChipResize<T>(state: SchedulerState<T>, press: PointerEvent, handle: HTMLElement, released: boolean): void;
+/**
+ * A cdk drag-drop item from a connected list landed on the scheduler's hit-area `DropList` (malva `externalDrop`):
+ * the cell under the drop point (time column: the pointer's slot) → `onExternalDrop({ item, start, end, allDay })`
+ * with `end = start + defaultEventDuration` (timed) or the next midnight (month cell / all-day row). Nothing is
+ * written; the item returns to its own list (the scheduler list never sorts).
+ */
+export declare function externalDrop<T>(state: SchedulerState<T>, drop: DragDrop<any, any, any>): void;