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

package/scheduler/pointer.js

@@ -0,0 +1,203 @@
+/**
+ * Milliseconds a touch must rest before a scheduler pointer gesture arms (range selection, chip resize and the chip
+ * drag-move's `dragStartDelay`): every touch gesture has the same "press, then drag" feel and a swipe scrolls.
+ */
+export const TOUCH_GESTURE_DELAY = 200;
+/**
+ * The element under a pointer position, falling back to `fallback`. A touch pointer is implicitly captured by the
+ * element its `pointerdown` landed on, so a gesture that hit-tests cells must not read `event.target` on moves;
+ * `elementFromPoint` returns `null` outside the viewport, so the caller's own target is the fallback.
+ */
+export function elementAt(doc, at, fallback) {
+    if (typeof doc.elementFromPoint !== "function")
+        return fallback;
+    return doc.elementFromPoint(at.x, at.y) ?? fallback;
+}
+/** Milliseconds a gesture's trailing click is swallowed for (malva `suppressNextClick` window). */
+export const CLICK_SWALLOW_WINDOW = 300;
+/**
+ * Swallows the click the release of a gesture produces (malva `suppressNextClick`): once, within
+ * `CLICK_SWALLOW_WINDOW` ms, only when the click lands inside one of `scope` (the scheduler root, the dragged chip),
+ * and never after a touch gesture (a prevented `touchmove` leaves no trailing click, so the user's next tap would be
+ * eaten). The next `pointerdown` drops it: a click after a new press belongs to that press.
+ */
+export function swallowNextClick(doc, press, scope) {
+    if (press.type.startsWith("touch") || press.pointerType === "touch")
+        return;
+    const swallow = (event) => {
+        const target = event.target;
+        if (!target || !scope.some((element) => element?.contains(target)))
+            return;
+        event.stopPropagation();
+        event.preventDefault();
+        done();
+    };
+    const done = () => {
+        clearTimeout(timer);
+        doc.removeEventListener("click", swallow, true);
+        doc.removeEventListener("pointerdown", done, true);
+    };
+    doc.addEventListener("click", swallow, true);
+    doc.addEventListener("pointerdown", done, true);
+    const timer = setTimeout(done, CLICK_SWALLOW_WINDOW);
+}
+/**
+ * Press-drag-release tracker on Pointer Events, started from an already dispatched `pointerdown`. Handles button
+ * filtering, threshold, capture, touch delay, foreign pointers, Escape / pointercancel and cleanup. Returns the
+ * teardown (also run when the gesture ends).
+ */
+export function startPointerDrag(down, element, handlers, options = {}) {
+    const threshold = options.threshold ?? 5;
+    const capture = options.capture ?? true;
+    const touchDelay = options.touchDelay ?? 0;
+    const doc = element.ownerDocument;
+    let origin = null;
+    let pointerId = null;
+    let started = false;
+    let pending = false;
+    let delayedTouch = false;
+    let delayTimer = null;
+    const onTouchMove = (event) => {
+        if (event.cancelable)
+            event.preventDefault();
+    };
+    const point = (event) => {
+        const { clientX, clientY } = event;
+        return { x: clientX, y: clientY };
+    };
+    const stop = () => {
+        if (delayTimer !== null) {
+            clearTimeout(delayTimer);
+            delayTimer = null;
+        }
+        pending = false;
+        delayedTouch = false;
+        element.removeEventListener("touchmove", onTouchMove);
+        if (pointerId !== null && capture && typeof element.releasePointerCapture === "function" && element.hasPointerCapture?.(pointerId))
+            element.releasePointerCapture(pointerId);
+        origin = null;
+        pointerId = null;
+        started = false;
+        doc.removeEventListener("pointermove", onMove);
+        doc.removeEventListener("pointerup", onUp);
+        doc.removeEventListener("pointercancel", onCancel);
+        doc.removeEventListener("keydown", onKeydown);
+    };
+    // A second pointer must not steer a gesture it did not start (events without a pointerId are never filtered).
+    const foreign = (event) => {
+        const id = event.pointerId;
+        return pointerId !== null && typeof id === "number" && id !== pointerId;
+    };
+    const onMove = (event) => {
+        if (!origin || foreign(event))
+            return;
+        const at = point(event);
+        const travelled = Math.hypot(at.x - origin.x, at.y - origin.y);
+        if (pending) {
+            if (travelled >= threshold)
+                onCancel();
+            return;
+        }
+        if (!started) {
+            if (travelled < threshold)
+                return;
+            started = true;
+            handlers.onStart?.(origin, event);
+        }
+        handlers.onMove(at, event);
+    };
+    const onUp = (event) => {
+        if (!origin || foreign(event))
+            return;
+        const moved = started;
+        const at = point(event);
+        stop();
+        handlers.onEnd(at, moved, event);
+    };
+    const onCancel = (event) => {
+        if (!origin || (event && foreign(event)))
+            return;
+        stop();
+        handlers.onCancel?.();
+    };
+    const onKeydown = (event) => {
+        if (event.key === "Escape")
+            onCancel();
+    };
+    const arm = () => {
+        pending = false;
+        delayTimer = null;
+        if (capture && pointerId !== null && typeof element.setPointerCapture === "function") {
+            try {
+                element.setPointerCapture(pointerId);
+            }
+            catch {
+                // A pointer already released / an element detached meanwhile: the document listeners still see the events.
+            }
+        }
+        if (delayedTouch)
+            element.addEventListener("touchmove", onTouchMove, { passive: false });
+    };
+    const pe = down;
+    if (pe.button !== undefined && pe.button !== 0)
+        return stop;
+    const target = down.target;
+    if (target && options.ignore?.(target))
+        return stop;
+    origin = point(down);
+    if (options.released?.()) {
+        const at = origin;
+        stop();
+        handlers.onEnd(at, false, null);
+        return stop;
+    }
+    pointerId = typeof pe.pointerId === "number" ? pe.pointerId : null;
+    if (touchDelay > 0 && pe.pointerType === "touch") {
+        pending = true;
+        delayedTouch = true;
+        delayTimer = setTimeout(arm, touchDelay);
+    }
+    else
+        arm();
+    doc.addEventListener("pointermove", onMove);
+    doc.addEventListener("pointerup", onUp);
+    doc.addEventListener("pointercancel", onCancel);
+    doc.addEventListener("keydown", onKeydown);
+    return stop;
+}
+/** malva `attachPointerDrag`: tracks every press on `element` (one gesture at a time). Returns the detach. */
+export function attachPointerDrag(element, handlers, options = {}) {
+    let running = null;
+    let active = false;
+    const wrapped = {
+        onStart: handlers.onStart && ((p, e) => handlers.onStart(p, e)),
+        onMove: (p, e) => handlers.onMove(p, e),
+        onEnd: (p, moved, e) => {
+            active = false;
+            handlers.onEnd(p, moved, e);
+        },
+        onCancel: () => {
+            active = false;
+            handlers.onCancel?.();
+        },
+    };
+    const onDown = (event) => {
+        // A press while a gesture runs belongs to another pointer: never re-anchor the running one.
+        if (active)
+            return;
+        const pe = event;
+        if (pe.button !== undefined && pe.button !== 0)
+            return;
+        const target = event.target;
+        if (target && options.ignore?.(target))
+            return;
+        active = true;
+        running = startPointerDrag(event, element, wrapped, options);
+    };
+    element.addEventListener("pointerdown", onDown);
+    return () => {
+        running?.();
+        active = false;
+        element.removeEventListener("pointerdown", onDown);
+    };
+}

package/scheduler/select.d.ts

@@ -0,0 +1,11 @@
+import { type SchedulerCell, type SchedulerState } from "./state.js";
+/** Grid position of the cell `element` sits in, `null` outside every cell (malva `_positionAt`). */
+export declare function cellPositionOf(element: Element | null): SchedulerCell | null;
+/**
+ * Range selection from the press on `surface` (month grid / time-grid sheet): the anchor is the pressed cell, the
+ * gesture arms after 5 px (touch: after a 200 ms rest, so a swipe pans), the head follows the cell under the POINTER
+ * (`elementAt`: a touch pointer stays captured by the pressed cell) and never crosses between the all-day row and the
+ * time slots; release commits `onRangeSelect` and swallows its click; Escape / pointercancel clear (and swallow the
+ * click the release still fires when something was painted).
+ */
+export declare function startRangeSelect(state: SchedulerState<any>, press: PointerEvent, surface: HTMLElement, anchor: SchedulerCell, released: boolean): void;

package/scheduler/select.js

@@ -0,0 +1,64 @@
+// Ported from @malva-ui/scheduler (src/lib/month/scheduler-month.ts + src/lib/time-grid/scheduler-time-grid.ts: the
+// range-select `attachPointerDrag` trackers, `_positionAt`, pending anchor), MIT, © 2026 Malva UI.
+// Rivet: one tracker for both views, started by `behaviour.ts` `schedulerPress` from the pointerdown that loaded this
+// chunk (`startPointerDrag`); the selection is `state.selection` (keyed by the rendered days, the views paint it);
+// the trailing click is swallowed once (`swallowNextClick`, 300 ms, inside the surface, not after touch) instead of
+// malva's `_ignoreClicksUntil`.
+import { untrack } from "@rivetjs/reactivity";
+import { TOUCH_GESTURE_DELAY, elementAt, startPointerDrag, swallowNextClick } from "./pointer.js";
+import { commitSelection, schedulerDays, schedulerDaysKey } from "./state.js";
+const CELL = "[data-rv-day-index][data-rv-minutes]";
+/** Grid position of the cell `element` sits in, `null` outside every cell (malva `_positionAt`). */
+export function cellPositionOf(element) {
+    const cell = element?.closest(CELL);
+    if (!cell)
+        return null;
+    const raw = cell.getAttribute("data-rv-minutes");
+    return { dayIndex: Number(cell.getAttribute("data-rv-day-index")), minutes: raw === "all-day" ? null : Number(raw) };
+}
+/**
+ * Range selection from the press on `surface` (month grid / time-grid sheet): the anchor is the pressed cell, the
+ * gesture arms after 5 px (touch: after a 200 ms rest, so a swipe pans), the head follows the cell under the POINTER
+ * (`elementAt`: a touch pointer stays captured by the pressed cell) and never crosses between the all-day row and the
+ * time slots; release commits `onRangeSelect` and swallows its click; Escape / pointercancel clear (and swallow the
+ * click the release still fires when something was painted).
+ */
+export function startRangeSelect(state, press, surface, anchor, released) {
+    const doc = surface.ownerDocument;
+    let started = false;
+    startPointerDrag(press, surface, {
+        onStart: () => {
+            started = true;
+            const key = untrack(() => schedulerDaysKey(schedulerDays(state)));
+            state.selection.set({ anchor, head: anchor, key });
+        },
+        onMove: (at, event) => {
+            const current = untrack(state.selection);
+            const hit = elementAt(doc, at, event.target);
+            const pos = hit && surface.contains(hit) ? cellPositionOf(hit) : null;
+            if (!current || !pos || (pos.minutes === null) !== (current.anchor.minutes === null))
+                return;
+            if (pos.dayIndex === current.head.dayIndex && pos.minutes === current.head.minutes)
+                return;
+            state.selection.set({ ...current, head: pos });
+        },
+        onEnd: (_at, moved) => {
+            // Only a drag that painted a selection commits one and swallows the click that trails it.
+            if (!moved || !untrack(state.selection))
+                return;
+            swallowNextClick(doc, press, [surface]);
+            commitSelection(state, "pointer");
+        },
+        onCancel: () => {
+            // A cancel before the threshold (touch swipe in the arm delay, Escape on a still press) leaves a pending
+            // keyboard selection alone.
+            if (!started)
+                return;
+            // Swallow from the tracker's own state: an Escape on the focused pressed cell reaches the view's key handler
+            // first, which clears the selection before this document listener runs (review T7+T8 #2; malva's reason for
+            // the swallow). `onStart` painted the anchor, so a started gesture always painted something.
+            swallowNextClick(doc, press, [surface]);
+            state.selection.set(null);
+        },
+    }, { capture: false, threshold: 5, touchDelay: TOUCH_GESTURE_DELAY, released: () => released });
+}

package/scheduler/selection.d.ts

@@ -0,0 +1,34 @@
+import type { SchedulerState } from "./state.js";
+/** A grid position: a day (month cell / all-day cell: `minutes` `null`) or a time slot. */
+export interface SchedulerCell {
+    readonly dayIndex: number;
+    readonly minutes: number | null;
+}
+/** A pending range selection (pointer drag or `Shift+Arrow`). */
+export interface SchedulerSelection {
+    readonly anchor: SchedulerCell;
+    readonly head: SchedulerCell;
+    /** The rendered days it was made on (`schedulerDaysKey`): a selection of another range is stale (malva `linkedSignal`). */
+    readonly key: string;
+}
+/** Ordered selection span (malva `_selectedBounds`): days by index, minutes on the first / last day. */
+export interface SchedulerSelectionBounds {
+    readonly allDay: boolean;
+    readonly dayFrom: number;
+    readonly dayTo: number;
+    /** Start minute on `dayFrom` (0 when all-day). */
+    readonly from: number;
+    /** Start minute of the last selected slot on `dayTo` (0 when all-day). */
+    readonly to: number;
+}
+/** Identity of the rendered days (selection staleness). */
+export declare function schedulerDaysKey(days: readonly number[]): string;
+/**
+ * The selection ordered as `(dayIndex, minutes)` tuples (malva `_selectedBounds`: a backwards multi-day drag Tue 14:00
+ * → Wed 09:00 is Tue 14:00 → Wed 09:00, never per component), `null` without one or when it belongs to other days.
+ */
+export declare function schedulerSelectionBounds(selection: SchedulerSelection | null, days: readonly number[]): SchedulerSelectionBounds | null;
+/** Whether a cell is painted (malva `_isSelected`: CONTINUOUS — first day from its minute, middle days full, last day up to its minute). */
+export declare function isCellSelected(bounds: SchedulerSelectionBounds | null, dayIndex: number, minutes: number | null): boolean;
+/** Whether range selection is allowed. */
+export declare function schedulerSelectable(state: SchedulerState<any>): boolean;

package/scheduler/selection.js

@@ -0,0 +1,39 @@
+const read = (value) => (typeof value === "function" ? value() : value);
+/** Identity of the rendered days (selection staleness). */
+export function schedulerDaysKey(days) {
+    return days.length ? days.length + ":" + days[0] : "";
+}
+/**
+ * The selection ordered as `(dayIndex, minutes)` tuples (malva `_selectedBounds`: a backwards multi-day drag Tue 14:00
+ * → Wed 09:00 is Tue 14:00 → Wed 09:00, never per component), `null` without one or when it belongs to other days.
+ */
+export function schedulerSelectionBounds(selection, days) {
+    if (!selection || selection.key !== schedulerDaysKey(days))
+        return null;
+    const { anchor, head } = selection;
+    const allDay = anchor.minutes === null;
+    const a = anchor.minutes ?? 0;
+    const h = head.minutes ?? a;
+    const anchorFirst = anchor.dayIndex === head.dayIndex ? a <= h : anchor.dayIndex < head.dayIndex;
+    return {
+        allDay,
+        dayFrom: Math.min(anchor.dayIndex, head.dayIndex),
+        dayTo: Math.max(anchor.dayIndex, head.dayIndex),
+        from: allDay ? 0 : anchorFirst ? a : h,
+        to: allDay ? 0 : anchorFirst ? h : a,
+    };
+}
+/** Whether a cell is painted (malva `_isSelected`: CONTINUOUS — first day from its minute, middle days full, last day up to its minute). */
+export function isCellSelected(bounds, dayIndex, minutes) {
+    if (!bounds || dayIndex < bounds.dayFrom || dayIndex > bounds.dayTo)
+        return false;
+    if (bounds.allDay)
+        return minutes === null;
+    if (minutes === null)
+        return false;
+    return (dayIndex > bounds.dayFrom || minutes >= bounds.from) && (dayIndex < bounds.dayTo || minutes <= bounds.to);
+}
+/** Whether range selection is allowed. */
+export function schedulerSelectable(state) {
+    return read(state.options.allowsRangeSelection) ?? true;
+}

package/scheduler/state.d.ts

@@ -0,0 +1,296 @@
+import { type Signal } from "@rivetjs/reactivity";
+import { type ControlledState } from "../interactions/controllable.js";
+import { type DayOfWeek } from "../date/queries.js";
+import { type SchedulerDate } from "./dates.js";
+import { type SchedulerBusinessHours, type SchedulerCanChange, type SchedulerChangeSource, type SchedulerClusteredSegment, type SchedulerDayRange, type SchedulerEvent, type SchedulerEventChange, type SchedulerEventInteraction, type SchedulerSlotEvent, type SchedulerExternalDropEvent, type SchedulerRangeSelectEvent, type SchedulerLaneSegment, type SchedulerLayoutRange, type SchedulerNormalizedEvent, type SchedulerRowLayout, type SchedulerRowSegment, type SchedulerView, type SchedulerVisibleRange } from "./layout.js";
+import { type SchedulerMessageKey, type SchedulerStrings } from "./intl.js";
+import { type SchedulerSelection, type SchedulerSelectionBounds } from "./selection.js";
+export * from "./selection.js";
+/** A value, or an accessor read where it is used (live prop). */
+export type MaybeAccessor<T> = T | (() => T);
+/** Lanes per month row / all-day band when `visibleLanes` is `"auto"` (malva's fallback before measuring). */
+export declare const DEFAULT_VISIBLE_LANES = 3;
+/** Options read live (each a value or an accessor). */
+export interface SchedulerOptions {
+    /**
+     * Wall clock of the layout. Default: the zone resolved when the state is created — `"UTC"` on the server (kept by
+     * the resumed page, dev warning), the local zone for a client-only render. Pass it for local time on SSR pages.
+     */
+    timeZone?: MaybeAccessor<string | undefined>;
+    /** Locale of labels, strings, first day of week and weekend. Default `"en-US"` (components pass `useLocale()`). */
+    locale?: MaybeAccessor<string | undefined>;
+    /** First day of the week. Default: locale. */
+    firstDayOfWeek?: MaybeAccessor<DayOfWeek | undefined>;
+    /** Weekdays (0 = Sunday) removed from every view. */
+    hiddenDays?: MaybeAccessor<readonly number[] | undefined>;
+    /** Weekdays (0 = Sunday) marked `data-weekend`. Default: locale weekend. */
+    weekendDays?: MaybeAccessor<readonly number[] | undefined>;
+    /** First visible time of the time grid (`"HH:mm"`). Default `"00:00"`. */
+    minTime?: MaybeAccessor<string | undefined>;
+    /** End of the time grid (`"HH:mm"`, `"24:00"` allowed). Default `"24:00"`. */
+    maxTime?: MaybeAccessor<string | undefined>;
+    /** Slot height unit, positive minutes. Default `30`. */
+    slotDuration?: MaybeAccessor<number | undefined>;
+    /** Drag / resize / selection granularity, positive minutes. Default: `slotDuration`. */
+    snapDuration?: MaybeAccessor<number | undefined>;
+    /** Minutes for all-day → timed drops, external drops and `end <= start` repair. Default `60`. */
+    defaultEventDuration?: MaybeAccessor<number | undefined>;
+    /** Working-hours shading; `null` = none. */
+    businessHours?: MaybeAccessor<SchedulerBusinessHours | null | undefined>;
+    /** Lane cap of month rows (the time grid's all-day band never collapses: it grows). `"auto"` = `DEFAULT_VISIBLE_LANES` (ui: density default). */
+    visibleLanes?: MaybeAccessor<number | "auto" | undefined>;
+    /** Disables move / resize / delete (pointer and keyboard). malva `editable` inverse. */
+    isReadOnly?: MaybeAccessor<boolean | undefined>;
+    /** Pointer + keyboard range selection. malva `selectable`. Default `true`. */
+    allowsRangeSelection?: MaybeAccessor<boolean | undefined>;
+    /** Now-line and today highlight. Default `true`. */
+    showCurrentTime?: MaybeAccessor<boolean | undefined>;
+    /** Centre the current time on the initial time-grid scroll. Default `false`. */
+    scrollToCurrentTime?: MaybeAccessor<boolean | undefined>;
+    /** Week-number column of the month grid. Default `false`. */
+    showWeekNumbers?: MaybeAccessor<boolean | undefined>;
+    /** String overrides on top of the locale table. */
+    strings?: MaybeAccessor<Partial<SchedulerStrings> | undefined>;
+}
+/** `createSchedulerState` input. Handlers and veto hooks are read once. */
+export interface SchedulerStateProps<T = unknown> extends SchedulerOptions {
+    /** Events: a Signal (two-way), a value or an accessor (controlled: use `onEventsChange`). */
+    events?: readonly SchedulerEvent<T>[] | Signal<readonly SchedulerEvent<T>[]> | (() => readonly SchedulerEvent<T>[]);
+    defaultEvents?: readonly SchedulerEvent<T>[];
+    onEventsChange?: (events: readonly SchedulerEvent<T>[]) => void;
+    view?: SchedulerView | Signal<SchedulerView> | (() => SchedulerView);
+    defaultView?: SchedulerView;
+    onViewChange?: (view: SchedulerView) => void;
+    /** Anchor date (any form; written back in the same form). Default: today in `timeZone`. */
+    date?: SchedulerDate | Signal<SchedulerDate> | (() => SchedulerDate);
+    defaultDate?: SchedulerDate;
+    onDateChange?: (date: SchedulerDate) => void;
+    /** Move veto (read once). */
+    canMove?: SchedulerCanChange<T>;
+    /** Resize veto (read once). */
+    canResize?: SchedulerCanChange<T>;
+    onEventMove?: (change: SchedulerEventChange<T>) => void;
+    onEventResize?: (change: SchedulerEventChange<T>) => void;
+    onVisibleRangeChange?: (range: SchedulerVisibleRange) => void;
+    /** A pointer drag (or `Shift+Arrow` + `Enter`) over empty cells committed a range (malva `rangeSelect`). Read once at mount. */
+    onRangeSelect?: (range: SchedulerRangeSelectEvent) => void;
+    /** A cdk drag-drop item from a connected list was dropped on a cell (malva `externalDrop`); nothing is written. Read once at mount. */
+    onExternalDrop?: (drop: SchedulerExternalDropEvent) => void;
+    /** Chip click / `Enter` / `Space` (malva `eventClick`). Read once at mount. */
+    onEventAction?: (interaction: SchedulerEventInteraction<T>) => void;
+    /** Chip double click (malva `eventDoubleClick`). Read once at mount. */
+    onEventDoubleClick?: (interaction: SchedulerEventInteraction<T>) => void;
+    /** Chip right click, ContextMenu key / `Shift+F10` (malva `eventContextMenu`). Read once at mount. */
+    onEventContextMenu?: (interaction: SchedulerEventInteraction<T>) => void;
+    /** `Delete` / `Backspace` on a focused chip while editable (prevented; the caller removes the event). Read once at mount. */
+    onEventDelete?: (interaction: SchedulerEventInteraction<T>) => void;
+    /** Click / `Space` (or `Enter` without a chip) on a cell or slot (malva `slotClick`). Read once at mount. */
+    onSlotAction?: (slot: SchedulerSlotEvent) => void;
+    /** Double click on a cell or slot (malva `slotDoubleClick`). Read once at mount. */
+    onSlotDoubleClick?: (slot: SchedulerSlotEvent) => void;
+    /** Right click, ContextMenu key / `Shift+F10` on a cell or slot (malva `slotContextMenu`). Read once at mount. */
+    onSlotContextMenu?: (slot: SchedulerSlotEvent) => void;
+}
+/** The drag preview (ghost) of a pointer gesture in flight: wall minutes of the event's would-be dates. */
+export interface SchedulerDragPreview extends SchedulerLayoutRange {
+    readonly id: string;
+}
+/** A `schedulerScrollToTime` request waiting for the time grid (`sequence` guards `consumeScrollRequest`). */
+export interface SchedulerScrollRequest {
+    readonly time: string;
+    readonly sequence: number;
+}
+/**
+ * What the active view should focus after its next render (malva `MlvSchedulerFocusRequest`): a chip (`eventId`,
+ * preferring its segment on `day`) or a cell (`eventId` `null`: the cell of `day`, `minutes` `null` = month cell /
+ * all-day cell, else the slot owning that minute). Day numbers, not indexes: a request made before a navigation
+ * names the day of the period that will render.
+ */
+export interface SchedulerFocusRequest {
+    readonly eventId: string | null;
+    readonly day: number | null;
+    readonly minutes: number | null;
+}
+/** Scheduler state (serializable: controllable values, the caller's option values / accessors, plain signals). */
+export interface SchedulerState<T = unknown> {
+    readonly events: ControlledState<readonly SchedulerEvent<T>[]>;
+    readonly view: ControlledState<SchedulerView>;
+    readonly date: ControlledState<SchedulerDate>;
+    readonly options: SchedulerOptions;
+    /**
+     * The zone resolved at creation when no `timeZone` is given (server: `"UTC"`, browser: the local zone). Region
+     * state, so a resumed page keeps laying out in the zone the server rendered with (no chip jump, no `data-today`
+     * move on the first recompute).
+     */
+    readonly zone: string;
+    readonly canMove: SchedulerCanChange<T> | undefined;
+    readonly canResize: SchedulerCanChange<T> | undefined;
+    readonly onEventMove: ((change: SchedulerEventChange<T>) => void) | undefined;
+    readonly onEventResize: ((change: SchedulerEventChange<T>) => void) | undefined;
+    readonly onVisibleRangeChange: ((range: SchedulerVisibleRange) => void) | undefined;
+    readonly onRangeSelect: ((range: SchedulerRangeSelectEvent) => void) | undefined;
+    readonly onExternalDrop: ((drop: SchedulerExternalDropEvent) => void) | undefined;
+    readonly onEventAction: ((interaction: SchedulerEventInteraction<T>) => void) | undefined;
+    readonly onEventDoubleClick: ((interaction: SchedulerEventInteraction<T>) => void) | undefined;
+    readonly onEventContextMenu: ((interaction: SchedulerEventInteraction<T>) => void) | undefined;
+    readonly onEventDelete: ((interaction: SchedulerEventInteraction<T>) => void) | undefined;
+    readonly onSlotAction: ((slot: SchedulerSlotEvent) => void) | undefined;
+    readonly onSlotDoubleClick: ((slot: SchedulerSlotEvent) => void) | undefined;
+    readonly onSlotContextMenu: ((slot: SchedulerSlotEvent) => void) | undefined;
+    /** Pending range selection. */
+    readonly selection: Signal<SchedulerSelection | null>;
+    /** Drag preview of the gesture in flight. */
+    readonly dragPreview: Signal<SchedulerDragPreview | null>;
+    /** `true` while a pointer gesture owns the pointer (root `user-select: none`). */
+    readonly dragging: Signal<boolean>;
+    /** Latest `schedulerScrollToTime` request. */
+    readonly scrollRequest: Signal<SchedulerScrollRequest | null>;
+    /** Focus target after the next render (keyboard moves, removed chips). */
+    readonly pendingFocus: Signal<SchedulerFocusRequest | null>;
+    /** Day index of the open `+N more` popover. */
+    readonly popoverDay: Signal<number | null>;
+    /** The two polite live-region texts (exactly one non-empty after an announcement). */
+    readonly announcement: Signal<readonly [string, string]>;
+}
+/** Creates the scheduler state (region state: a re-created region of a resumed page keeps it). */
+export declare function createSchedulerState<T = unknown>(props?: SchedulerStateProps<T>): SchedulerState<T>;
+/** The layout zone: `timeZone`, else the zone resolved when the state was created (`state.zone`). */
+export declare function schedulerTimeZone(state: SchedulerState<any>): string;
+/** The locale. */
+export declare function schedulerLocale(state: SchedulerState<any>): string;
+/** First day of the week, 0 = Sunday (`firstDayOfWeek` or the locale's). */
+export declare function schedulerFirstDay(state: SchedulerState<any>): number;
+/** Weekend weekdays (`weekendDays` or the locale's). */
+export declare function schedulerWeekendDays(state: SchedulerState<any>): readonly number[];
+/** `hiddenDays` (raw; layout functions repair it). */
+export declare function schedulerHiddenDays(state: SchedulerState<any>): readonly number[];
+/** Slot duration in minutes. */
+export declare function schedulerSlotDuration(state: SchedulerState<any>): number;
+/** Effective snap: `snapDuration` or `slotDuration`. */
+export declare function schedulerSnap(state: SchedulerState<any>): number;
+/** `defaultEventDuration` in minutes. */
+export declare function schedulerDefaultDuration(state: SchedulerState<any>): number;
+/** Lane cap of month rows (the time grid's all-day band never collapses: it passes `Infinity`). */
+export declare function schedulerVisibleLanes(state: SchedulerState<any>): number;
+/** Whether move / resize / delete are allowed (scheduler level). */
+export declare function schedulerEditable(state: SchedulerState<any>): boolean;
+/** Whether the now-line / today highlight shows. */
+export declare function schedulerShowsCurrentTime(state: SchedulerState<any>): boolean;
+/**
+ * `[minTime, maxTime)` as minutes of day, validated as one pair: a window that is not strictly ascending would write
+ * `NaN%` / `Infinity%` geometry, so it fails loudly (malva text).
+ */
+export declare function schedulerTimeWindow(state: SchedulerState<any>): {
+    min: number;
+    max: number;
+};
+/** Resolved strings (locale table + `strings` overrides). */
+export declare function schedulerStringTable(state: SchedulerState<any>): SchedulerStrings;
+/** One translated message (`schedulerString` over the resolved table). */
+export declare function schedulerTranslate(state: SchedulerState<any>, key: SchedulerMessageKey | "moreEvents" | "moreEventsLabel", vars?: Record<string, string | number | boolean>): string;
+/** Day number of the anchor date (today when it does not parse). */
+export declare function schedulerAnchorDay(state: SchedulerState<any>, date?: SchedulerDate): number;
+/** The rendered period in day numbers. */
+export declare function schedulerDayRange(state: SchedulerState<any>, view?: SchedulerView, date?: SchedulerDate): SchedulerDayRange;
+/** The rendered period, dates in the form of the anchor date (malva public `visibleRange`). */
+export declare function schedulerVisibleRange(state: SchedulerState<any>): SchedulerVisibleRange;
+/**
+ * Days rendered by the active view, after `hiddenDays`. In the day view `hiddenDays` steers navigation but never
+ * blanks the grid: an anchor on a hidden weekday renders that day as asked.
+ */
+export declare function schedulerDays(state: SchedulerState<any>, range?: SchedulerDayRange): readonly number[];
+/** Visible days per month week row. */
+export declare function schedulerRowLength(state: SchedulerState<any>): number;
+/** Localized title: month-year, "Aug 31 – Sep 6, 2026", or the full day label. */
+export declare function schedulerTitle(state: SchedulerState<any>): string;
+/** `events` normalized (wall minutes in `timeZone`; unparsable dates dropped, dev warning once per event object). */
+export declare function schedulerNormalizedEvents<T>(state: SchedulerState<T>): SchedulerNormalizedEvent<T>[];
+/** Ghost id suffix of the drag preview copy. */
+export declare const GHOST_SUFFIX = "__rv-ghost";
+/**
+ * `normalized` plus the drag preview ghost (a copy of the dragged event at its would-be dates, `ghost: true`, id
+ * suffixed with `GHOST_SUFFIX`) while a gesture is in flight.
+ */
+export declare function schedulerWithPreview<T>(state: SchedulerState<T>, normalized: readonly SchedulerNormalizedEvent<T>[]): readonly SchedulerNormalizedEvent<T>[];
+/** One month week row. */
+export interface SchedulerMonthRow<T = unknown> {
+    readonly index: number;
+    /** First and last (inclusive) visible-day index of the row. */
+    readonly startIndex: number;
+    readonly endIndex: number;
+    /** Every segment of the row (popover lists). */
+    readonly segments: readonly SchedulerRowSegment<T>[];
+    /** Lanes + `+N more` overflow. */
+    readonly layout: SchedulerRowLayout<T>;
+}
+/** Month rows → lane-packed segments with the lane budget applied (server-exact: no measurement). */
+export declare function schedulerMonthLayout<T>(events: readonly SchedulerNormalizedEvent<T>[], days: readonly number[], rowLength: number, visibleLanes: number): SchedulerMonthRow<T>[];
+/** Week / day time grid: the all-day band (lanes) and per-day clustered timed segments. */
+export interface SchedulerTimeGridLayout<T = unknown> {
+    readonly allDay: SchedulerRowLayout<T>;
+    readonly allDaySegments: readonly SchedulerLaneSegment<T>[];
+    /** `columns[dayIndex]` = clustered segments of that day. */
+    readonly columns: readonly (readonly SchedulerClusteredSegment<T>[])[];
+}
+/** Time-grid layout (lanes for all-day / ≥ 24 h events, clusters for timed ones). */
+export declare function schedulerTimeGridLayout<T>(events: readonly SchedulerNormalizedEvent<T>[], days: readonly number[], window: {
+    min: number;
+    max: number;
+}, visibleLanes: number): SchedulerTimeGridLayout<T>;
+/** ISO week number (Monday-based) of a day number — month grid week-number column. */
+export declare function isoWeekNumber(day: number): number;
+/** Jumps to `date` (the period containing it becomes visible). */
+export declare function schedulerGoTo(state: SchedulerState<any>, date: SchedulerDate): void;
+/** Switches the view. A switch to the month drops a pending `schedulerScrollToTime` request (no grid to apply it). */
+export declare function schedulerSetView(state: SchedulerState<any>, view: SchedulerView): void;
+/** Jumps to today (written in the form of the current anchor). */
+export declare function schedulerToday(state: SchedulerState<any>): void;
+/** Moves one period forward (month / week / day per `view`). */
+export declare function schedulerNext(state: SchedulerState<any>): void;
+/** Moves one period back. */
+export declare function schedulerPrevious(state: SchedulerState<any>): void;
+/**
+ * Scrolls the time grid so `time` (`"HH:mm"`) sits at the top. No-op in the settled month view: a request still
+ * standing at the end of the task while the month shows is dropped (malva rule); a switch to week / day in the same
+ * task still wins.
+ */
+export declare function schedulerScrollToTime(state: SchedulerState<any>, time: string): void;
+/** Time grid → state: clears the request it applied (a newer request survives). */
+export declare function consumeScrollRequest(state: SchedulerState<any>, sequence: number): void;
+/**
+ * The selection as a half-open wall-minute range (malva `_selectionRange`): all-day = midnight of the first day →
+ * midnight after the last; timed = first slot start → end of the last slot, capped at `maxTime` (24:00 = the next
+ * day's midnight).
+ */
+export declare function schedulerSelectionRange(state: SchedulerState<any>, bounds: SchedulerSelectionBounds): SchedulerLayoutRange;
+/** Wall minutes → the caller's date form (the anchor date's: string in → string out). */
+export declare function schedulerDateOf(state: SchedulerState<any>, wall: number, allDay: boolean): SchedulerDate;
+/** Commits the pending selection as `onRangeSelect` and clears it (malva `_commitSelection`). */
+export declare function commitSelection(state: SchedulerState<any>, source: SchedulerChangeSource): void;
+/**
+ * Announces `message` politely (malva `announce`): written into the region the previous message did not use, the
+ * other one emptied, so a repeat of the same text is a change the screen reader speaks (two-slot rule). The second and
+ * further messages of one task keep the other region (they share one render: a keyboard move that also leaves the
+ * period announces the move and the new period, and clearing would drop the move).
+ */
+export declare function schedulerAnnounce(state: SchedulerState<any>, message: string): void;
+/** A move / resize request (`commitChange`). */
+export interface SchedulerCommit<T = unknown> {
+    readonly kind: "move" | "resize";
+    readonly normalized: SchedulerNormalizedEvent<T>;
+    /** Would-be dates (wall minutes). */
+    readonly next: SchedulerLayoutRange;
+    readonly source: SchedulerChangeSource;
+}
+/**
+ * Applies a move / resize: the veto hook decides (`false` → `moveRejected` announced, nothing written), else the
+ * event is replaced in a new array (`onEventsChange` / the Signal), `onEventMove` / `onEventResize` fire and the
+ * change is announced. Dates are written in the form of the values they replace. Returns whether it was applied.
+ */
+export declare function commitChange<T>(state: SchedulerState<T>, change: SchedulerCommit<T>): boolean;
+/** Full date label (malva `getDateLabel`). */
+export declare function dateLabel(day: number, locale: string): string;
+/** Time of day (malva `formatTime`, e.g. "9:30 AM"). */
+export declare function timeLabel(wall: number, locale: string): string;
+/** Date + time (malva `formatDateTime`), used whenever a label crosses a day boundary. */
+export declare function dateTimeLabel(wall: number, locale: string): string;