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

package/scheduler/menus.d.ts

@@ -0,0 +1,66 @@
+import { type Signal } from "@rivetjs/reactivity";
+import type { Content } from "@rivetjs/runtime/jsx-runtime";
+import type { SchedulerEvent, SchedulerRange, SchedulerView } from "./layout.js";
+import type { SchedulerAxis } from "./context.jsx";
+import type { SchedulerLayoutRange } from "./layout.js";
+/** Second argument of `renderSlotMenu` (malva `MlvSchedulerSlotMenuContext` minus `$implicit`). */
+export interface SchedulerSlotMenuContext {
+    /** The range is the pending keyboard selection the cell lies in (not the cell's own day / slot). */
+    readonly selection: boolean;
+    /** The view the menu opened in. */
+    readonly view: SchedulerView;
+    /** Closes the menu. */
+    readonly close: () => void;
+}
+/** Second argument of `renderEventMenu` (malva `MlvSchedulerEventMenuContext` minus `$implicit`). */
+export interface SchedulerEventMenuContext {
+    readonly view: SchedulerView;
+    readonly close: () => void;
+}
+/** `renderSlotMenu` (read once at mount): items of the menu over an empty month cell, all-day cell or time slot. */
+export type SchedulerRenderSlotMenu = (range: SchedulerRange, context: SchedulerSlotMenuContext) => Content;
+/** `renderEventMenu` (read once at mount): items of the menu over an event chip. */
+export type SchedulerRenderEventMenu<T = unknown> = (event: SchedulerEvent<T>, context: SchedulerEventMenuContext) => Content;
+/** The open context menu (browser only). */
+export interface SchedulerMenuOpen<T = unknown> {
+    readonly kind: "slot" | "event";
+    readonly event: SchedulerEvent<T> | null;
+    readonly range: SchedulerRange | null;
+    readonly selection: boolean;
+    /** Sticky across re-targets: some open of this panel took the pending selection (released on close). */
+    readonly holds: boolean;
+    /** Panel `aria-label` (`eventMenu` / `slotMenu`). */
+    readonly label: string;
+    readonly view: SchedulerView;
+    /** The cell / chip: keyboard anchor, direction scope. */
+    readonly anchor: HTMLElement;
+    /** Client point of a pointer open, `null` for a keyboard one. */
+    readonly point: {
+        readonly x: number;
+        readonly y: number;
+    } | null;
+    /** Bumped per open (a re-target re-renders the items and re-positions). */
+    readonly sequence: number;
+}
+/** What the root passes when an interaction opens a menu. */
+export type SchedulerMenuRequest<T> = Omit<SchedulerMenuOpen<T>, "holds" | "point" | "sequence">;
+/**
+ * Opens (or re-targets) the menu from `native` (malva `openFromEvent`): a `contextmenu` mouse event is prevented (the
+ * consumer's `onEventContextMenu` / `onSlotContextMenu` then sees `defaultPrevented`), the key was claimed already.
+ */
+export declare function openSchedulerMenu<T>(menu: Signal<SchedulerMenuOpen<T> | null>, request: SchedulerMenuRequest<T>, native: MouseEvent | KeyboardEvent): void;
+/**
+ * The range a slot menu is about without a selection (malva `_slotRange`): a month / all-day cell = its day; a slot =
+ * its own duration, clamped to `maxTime` (24:00 = the next midnight: wall minutes roll over by themselves).
+ */
+export declare function slotMenuRange(day: number, minutes: number | null, axis: SchedulerAxis): SchedulerLayoutRange;
+/**
+ * The scheduler's one context-menu panel (rendered only when `renderSlotMenu` or `renderEventMenu` is given):
+ * `Popover.rv-SchedulerMenu-popover` (standalone, non-modal) > `Menu.rv-SchedulerMenu[aria-label]` > the items.
+ */
+export declare function SchedulerMenu<T>(props: {
+    menu: Signal<SchedulerMenuOpen<T> | null>;
+    close: () => void;
+    renderSlotMenu: SchedulerRenderSlotMenu | undefined;
+    renderEventMenu: SchedulerRenderEventMenu<T> | undefined;
+}): import("@rivetjs/runtime/jsx-runtime").CompiledElement;

package/scheduler/menus.jsx

@@ -0,0 +1,88 @@
+// Ported from @malva-ui/scheduler (src/lib/scheduler/scheduler.ts `_hasContextMenu` / `_contextMenu` /
+// `_menuHoldsSelection` / `_openContextMenu` / `_onContextMenuClosed` / `_slotRange`, scheduler.html context menu,
+// scheduler-defs.ts `MlvSchedulerSlotMenuDef` / `MlvSchedulerEventMenuDef`) and @malva-ui/core/menu
+// (context-menu-trigger.ts `openFromEvent` / `_isKeyboardInitiated`), MIT, © 2026 Malva UI.
+// Rivet:
+// - the two menu defs → `renderSlotMenu(range, { selection, view, close })` / `renderEventMenu(event, { view, close })`
+//   (read once at mount; their output is reactive): the items are cdk `MenuItem`s (and sections / separators) inside
+//   one cdk `Menu` in one standalone, non-modal cdk `Popover` per scheduler (R4: cdk has no context-menu trigger).
+// - the open menu is one root signal (`SchedulerMenuOpen`, written only in the browser: element + event values):
+//   a pointer open positions at the pointer (`getTargetRect`), a keyboard one (ContextMenu key / `Shift+F10`, or a
+//   `contextmenu` an assistive technology synthesised) against the cell / chip and focuses the first item; a second
+//   right-click re-targets the open panel (the content re-renders, the position follows the anchor); the overlay's
+//   focus scope returns focus to the element focused before the open.
+// - the pending keyboard selection a slot menu took is cleared when the menu closes (malva bumps `selectionRelease`
+//   for the views to clear their own selection; here the selection is the one root signal).
+// - non-modal: no underlay, nothing outside goes inert, so a right-click elsewhere reaches the scheduler and re-targets
+//   (malva: overlay without a backdrop); Escape, an item action and focus leaving the panel close it.
+import { untrack } from "@rivetjs/reactivity";
+import { Menu } from "../menu/index.jsx";
+import { Popover } from "../popover/index.jsx";
+/**
+ * A keyboard-initiated `contextmenu` (malva `_isKeyboardInitiated`): Firefox names its source, other browsers send a
+ * synthesised event with `detail` 0 at the client origin.
+ */
+function keyboardInitiated(event) {
+    const source = event.mozInputSource;
+    if (source !== undefined)
+        return source === 6;
+    return event.detail === 0 && event.clientX === 0 && event.clientY === 0;
+}
+/**
+ * Opens (or re-targets) the menu from `native` (malva `openFromEvent`): a `contextmenu` mouse event is prevented (the
+ * consumer's `onEventContextMenu` / `onSlotContextMenu` then sees `defaultPrevented`), the key was claimed already.
+ */
+export function openSchedulerMenu(menu, request, native) {
+    const pointer = native instanceof MouseEvent && native.type === "contextmenu" && !keyboardInitiated(native);
+    if (native instanceof MouseEvent)
+        native.preventDefault();
+    const previous = untrack(menu);
+    menu.set({
+        ...request,
+        point: pointer ? { x: native.clientX, y: native.clientY } : null,
+        holds: !!previous?.holds || request.selection,
+        sequence: (previous?.sequence ?? 0) + 1,
+    });
+}
+/**
+ * The range a slot menu is about without a selection (malva `_slotRange`): a month / all-day cell = its day; a slot =
+ * its own duration, clamped to `maxTime` (24:00 = the next midnight: wall minutes roll over by themselves).
+ */
+export function slotMenuRange(day, minutes, axis) {
+    if (minutes === null)
+        return { start: day * 1440, end: (day + 1) * 1440, allDay: true };
+    return { start: day * 1440 + minutes, end: day * 1440 + Math.min(minutes + axis.slot, axis.max), allDay: false };
+}
+/**
+ * The scheduler's one context-menu panel (rendered only when `renderSlotMenu` or `renderEventMenu` is given):
+ * `Popover.rv-SchedulerMenu-popover` (standalone, non-modal) > `Menu.rv-SchedulerMenu[aria-label]` > the items.
+ */
+export function SchedulerMenu(props) {
+    const menu = props.menu;
+    const close = props.close;
+    const renderSlotMenu = props.renderSlotMenu;
+    const renderEventMenu = props.renderEventMenu;
+    return (<Popover triggerRef={() => {
+            // Tracks the open: a re-target re-positions against the new anchor / point.
+            const open = menu();
+            return open ? open.anchor : null;
+        }} getTargetRect={() => {
+            const point = untrack(menu)?.point;
+            return point ? new DOMRect(point.x, point.y, 0, 0) : null;
+        }} isOpen={() => menu() !== null} onOpenChange={(open) => {
+            if (!open)
+                close();
+        }} isNonModal placement="bottom start" offset={4} class="rv-SchedulerMenu-popover">
+      {() => {
+            const open = menu();
+            // Re-rendered per open: a re-target renders the new items and focuses again.
+            if (!open)
+                return null;
+            return (<Menu class="rv-SchedulerMenu" aria-label={open.label} autoFocus={open.point ? true : "first"} onClose={() => close()}>
+            {open.kind === "event"
+                    ? renderEventMenu(open.event, { view: open.view, close: () => close() })
+                    : renderSlotMenu(open.range, { selection: open.selection, view: open.view, close: () => close() })}
+          </Menu>);
+        }}
+    </Popover>);
+}

package/scheduler/month.d.ts

@@ -0,0 +1,26 @@
+import { type DOMValue } from "@rivetjs/runtime/dom";
+import type { SchedulerEvent, SchedulerLaneSegment } from "./layout.js";
+/** One rendered day cell (malva `MlvSchedulerMonthCell`, day numbers instead of dates). */
+export interface SchedulerMonthCell<T = unknown> {
+    readonly dayIndex: number;
+    readonly day: number;
+    /** Localized day of month (decorative: the cell carries the name). */
+    readonly dayNumber: string;
+    /** Accessible name: the full date, `", today"` suffixed when it is. */
+    readonly label: string;
+    /** The full date without the today suffix (`+N more` names, panel title). */
+    readonly dateLabel: string;
+    readonly outside: boolean;
+    readonly today: boolean;
+    readonly weekend: boolean;
+    /** Visible segments starting in this cell (spanning bars live in their start cell). */
+    readonly segments: readonly SchedulerLaneSegment<T>[];
+    /** Hidden events of this day. */
+    readonly hidden: readonly SchedulerEvent<T>[];
+    /** `"+3 more"`, empty when nothing overflows. */
+    readonly moreText: string;
+    /** Accessible name of the `+N more` button; starts with `moreText` (WCAG 2.5.3). */
+    readonly moreLabel: string;
+}
+/** Month view (internal part of `Scheduler`). */
+export declare function SchedulerMonth<T>(): DOMValue;

package/scheduler/month.jsx

@@ -0,0 +1,215 @@
+// Ported from @malva-ui/scheduler (src/lib/month/scheduler-month.ts + .html: rows / cells model, labels, `+N more`
+// overflow + toggling popover, roving tab stop default), MIT, © 2026 Malva UI.
+// Rivet:
+// - lanes per row = `visibleLanes` (live prop, server-exact) instead of malva's row-height measurement (no layout read,
+//   spec F4 / R3): the server HTML is final (chips, `+N more` counts, geometry custom properties).
+// - roving tab stop: the focused DAY (region signal, a day number) instead of a `linkedSignal` index — it falls back
+//   to the default (today, else the 1st of the anchor month, else the first cell) whenever the range moves.
+// - popover = cdk `Popover` (standalone, `triggerRef` = the open day's `+N more` button, non-modal, no underlay: drag
+//   hit-testing reaches the grid); the panel is derived from the day index, never a snapshot (malva rule).
+// - Rivet additions: `showWeekNumbers` (row headers, ISO weeks), `data-weekend` (Pro Weekend Highlighting).
+// - Chip drag / resize: delegated `schedulerPress` on the grid + the panel (T6); the panel stays mounted but hidden
+//   (`visibility: hidden`) while a gesture runs, so the grid under it is the drop target (malva rule).
+// - Range selection (T7): the pointerdown of `schedulerPress` hands empty-cell presses to the lazy `select.ts`; cells
+//   paint `state.selection` (`aria-selected` / `data-selected`).
+// - Keyboard, clicks, focus hand-off (T8): delegated on the grid + the panel (`keys-month.ts` / `keys.ts`, leaf
+//   chunks); `data-rk` holds the navigation keys while a cold handler chunk loads.
+import { _regionState, computed, signal, useContext } from "@rivetjs/reactivity";
+import { For, ref as elementRef } from "@rivetjs/runtime/dom";
+import { Popover } from "../popover/index.jsx";
+import { SchedulerContext } from "./context.jsx";
+import { SchedulerEventChip } from "./event.jsx";
+import { closeMorePanel, moreButtonOf, monthFocusIn, monthMoreClick, schedulerPress } from "./behaviour.js";
+import { SCHEDULER_KEYS, chipFocusIn, chipFocusOut, schedulerInteraction } from "./keys.js";
+import { monthKeyDown } from "./keys-month.js";
+import { civilFromDay, dayFromCivil, formatDay } from "./dates.js";
+import { dateLabel, isCellSelected, isoWeekNumber, schedulerMonthLayout, schedulerSelectionBounds } from "./state.js";
+const keep = (previous, next) => previous === next || next == null;
+const NO_SEGMENTS = Object.freeze([]);
+const sameNumbers = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+/** Month view (internal part of `Scheduler`). */
+export function SchedulerMonth() {
+    const ctx = useContext(SchedulerContext);
+    const state = ctx.state;
+    const popoverId = ctx.popoverId;
+    const onMoreAction = ctx.onMoreAction;
+    const grid = elementRef();
+    const focusDay = _regionState(() => signal(null));
+    const rows = computed(() => schedulerMonthLayout(ctx.events(), ctx.days(), ctx.rowLength(), ctx.visibleLanes()));
+    const selection = computed(() => schedulerSelectionBounds(state.selection(), ctx.days()));
+    const rowKeys = computed(() => rows().map((row) => row.index), { equals: sameNumbers });
+    const cells = computed(() => {
+        const days = ctx.days();
+        const locale = ctx.locale();
+        const today = ctx.today();
+        const weekend = ctx.weekend();
+        const anchorMonth = civilFromDay(ctx.anchorDay())[1];
+        const out = [];
+        for (const row of rows()) {
+            for (let dayIndex = row.startIndex; dayIndex <= row.endIndex; dayIndex++) {
+                const day = days[dayIndex];
+                const plain = dateLabel(day, locale);
+                const isToday = today === day;
+                const hidden = (row.layout.hiddenByDay.get(dayIndex) ?? []).map((segment) => segment.normalized.event);
+                const moreText = hidden.length ? ctx.t("moreEvents", { count: hidden.length }) : "";
+                const segments = row.layout.visible.filter((segment) => segment.startIndex === dayIndex);
+                out.push({
+                    dayIndex,
+                    day,
+                    dayNumber: formatDay(day, locale, { day: "numeric" }),
+                    label: isToday ? ctx.t("dayLabelToday", { date: plain }) : plain,
+                    dateLabel: plain,
+                    outside: civilFromDay(day)[1] !== anchorMonth,
+                    today: isToday,
+                    weekend: weekend.includes((day + 4) % 7),
+                    segments: segments.length ? segments : NO_SEGMENTS,
+                    hidden,
+                    moreText,
+                    moreLabel: hidden.length ? moreText + ", " + ctx.t("moreEventsLabel", { count: hidden.length, date: plain }) : "",
+                });
+            }
+        }
+        return out;
+    });
+    // Today when visible, else the first day of the anchor month, else the first cell (malva `_defaultFocus`).
+    const tabStop = computed(() => {
+        const days = ctx.days();
+        const focused = focusDay();
+        if (focused !== null) {
+            const index = days.indexOf(focused);
+            if (index >= 0)
+                return index;
+        }
+        const today = ctx.today();
+        const todayIndex = today === null ? -1 : days.indexOf(today);
+        if (todayIndex >= 0)
+            return todayIndex;
+        const [year, month] = civilFromDay(ctx.anchorDay());
+        const first = dayFromCivil(year, month, 1);
+        return Math.max(0, days.findIndex((day) => day >= first));
+    });
+    const weekdays = computed(() => {
+        const locale = ctx.locale();
+        const weekend = ctx.weekend();
+        return ctx
+            .days()
+            .slice(0, ctx.rowLength())
+            .map((day) => ({ name: formatDay(day, locale, { weekday: "short" }), weekend: weekend.includes((day + 4) % 7) }));
+    });
+    const gridLabel = () => ctx.t("gridLabel.month", { period: formatDay(ctx.anchorDay(), ctx.locale(), { month: "long", year: "numeric" }) });
+    const openDay = () => state.popoverDay();
+    // Every segment touching the open day, visible or not (the panel list), re-derived from the live layout.
+    const panel = computed(() => {
+        const dayIndex = openDay();
+        if (dayIndex === null)
+            return null;
+        const cell = cells()[dayIndex];
+        const row = rows()[Math.floor(dayIndex / ctx.rowLength())];
+        if (!cell || !row || cell.hidden.length === 0)
+            return null;
+        const all = row.segments.filter((segment) => segment.startIndex <= dayIndex && segment.endIndex >= dayIndex && !segment.normalized.ghost);
+        return { dayIndex, label: cell.dateLabel, all };
+    });
+    const panelKeys = computed(() => panel()?.all.map((segment) => segment.key) ?? [], {
+        equals: (a, b) => a.length === b.length && a.every((k, i) => k === b[i]),
+    });
+    const mctx = {
+        state,
+        popoverId,
+        cell: (dayIndex) => cells()[dayIndex] ?? null,
+        moreDate: (day) => ctx.dateOf(day),
+        onMoreAction: (event) => onMoreAction?.(event),
+        focusDay,
+    };
+    return (<div class="rv-SchedulerMonth" style={{
+            "--rv-scheduler-row-length": String(ctx.rowLength()),
+            "--rv-scheduler-rows": String(rowKeys().length),
+            "--rv-scheduler-visible-lanes": String(ctx.visibleLanes()),
+        }} data-week-numbers={ctx.showWeekNumbers() ? "true" : undefined}>
+      <div ref={grid} class="rv-SchedulerMonth-grid" role="grid" aria-label={gridLabel()} aria-multiselectable={ctx.selectable() ? "true" : undefined} style={{ "user-select": "none", "-webkit-user-select": "none" }} data-rk={SCHEDULER_KEYS} onKeyDown={(e) => monthKeyDown(e, ctx)} onClick={(e) => {
+            monthMoreClick(e, mctx);
+            schedulerInteraction("click", e, ctx);
+        }} onDblClick={(e) => schedulerInteraction("dblclick", e, ctx)} onContextMenu={(e) => schedulerInteraction("contextmenu", e, ctx)} onFocusIn={(e) => {
+            monthFocusIn(e, mctx);
+            chipFocusIn(e, ctx);
+        }} onFocusOut={(e) => chipFocusOut(e, ctx)} onMouseDown={(e) => schedulerPress(e, state)} onTouchStart={(e) => schedulerPress(e, state)} onPointerDown={(e) => schedulerPress(e, state)}>
+        <div class="rv-SchedulerMonth-weekdays" role="row">
+          {ctx.showWeekNumbers() ? (<div class="rv-SchedulerMonth-weekday rv-SchedulerMonth-week-header" role="columnheader">
+              {ctx.t("weekNumber", { week: "" }).trim()}
+            </div>) : null}
+          <For each={weekdays} by={(_w, i) => i}>
+            {(weekday) => (<div class="rv-SchedulerMonth-weekday" role="columnheader" data-weekend={weekday().weekend ? "true" : undefined}>
+                {weekday().name}
+              </div>)}
+          </For>
+        </div>
+        <div class="rv-SchedulerMonth-rows" role="rowgroup">
+          <For each={rowKeys} by={(k) => k}>
+            {(rowKey) => {
+            const rowIndex = rowKey();
+            const dayIndices = computed(() => {
+                const row = rows()[rowIndex];
+                const out = [];
+                if (row)
+                    for (let i = row.startIndex; i <= row.endIndex; i++)
+                        out.push(i);
+                return out;
+            }, { equals: sameNumbers });
+            const weekNumber = () => {
+                const row = rows()[rowIndex];
+                return row ? isoWeekNumber(ctx.days()[row.startIndex]) : 0;
+            };
+            return (<div class="rv-SchedulerMonth-row" role="row">
+                  {ctx.showWeekNumbers() ? (<div class="rv-SchedulerMonth-week-number" role="rowheader" aria-label={ctx.t("weekNumber", { week: weekNumber() })}>
+                      {String(weekNumber())}
+                    </div>) : null}
+                  <For each={dayIndices} by={(i) => i}>
+                    {(indexOf) => {
+                    const dayIndex = indexOf();
+                    const cell = computed(() => cells()[dayIndex], { equals: keep });
+                    const segments = () => cell().segments;
+                    return (<div class="rv-SchedulerMonth-cell" role="gridcell" aria-label={cell().label} tabIndex={tabStop() === dayIndex ? 0 : -1} data-rv-day-index={String(dayIndex)} data-rv-minutes="all-day" data-outside={cell().outside ? "true" : undefined} data-today={cell().today ? "true" : undefined} data-weekend={cell().weekend ? "true" : undefined} aria-selected={isCellSelected(selection(), dayIndex, null) ? "true" : undefined} data-selected={isCellSelected(selection(), dayIndex, null) ? "true" : undefined}>
+                          <span class="rv-SchedulerMonth-day-number" aria-hidden="true">
+                            {cell().dayNumber}
+                          </span>
+                          <div class="rv-SchedulerMonth-lanes">
+                            <For each={segments} by={(segment) => segment.key}>
+                              {(segment) => (<SchedulerEventChip segment={() => segment()} lane={true} spanning={() => segment().endIndex > segment().startIndex} geometry={() => ({
+                                "--rv-scheduler-lane": String(segment().lane + 1),
+                                "--rv-scheduler-span": String(segment().endIndex - segment().startIndex + 1),
+                            })}/>)}
+                            </For>
+                            {cell().hidden.length ? (<button type="button" class="rv-SchedulerMonth-more" data-rv-more="" tabIndex={-1} aria-haspopup="dialog" aria-label={cell().moreLabel} aria-expanded={openDay() === dayIndex ? "true" : "false"} aria-controls={openDay() === dayIndex && panel() ? popoverId : undefined} style={{ "--rv-scheduler-lane": String(ctx.visibleLanes()) }}>
+                                {cell().moreText}
+                              </button>) : null}
+                          </div>
+                        </div>);
+                }}
+                  </For>
+                </div>);
+        }}
+          </For>
+        </div>
+      </div>
+      <Popover triggerRef={() => {
+            const dayIndex = openDay();
+            const element = grid();
+            return dayIndex === null || !element ? null : moreButtonOf(element, dayIndex);
+        }} isOpen={() => panel() !== null} onOpenChange={(open) => {
+            if (!open)
+                closeMorePanel(mctx, grid());
+        }} isNonModal placement="bottom start" shouldCloseOnInteractOutside={(element) => !element.closest("[data-rv-more]")} aria-label={panel()?.label} class="rv-SchedulerMonth-popover-overlay">
+        {() => (<div class="rv-SchedulerMonth-popover" role="group" id={popoverId} aria-label={panel()?.label} tabIndex={-1} data-dragging={state.dragging() ? "true" : undefined} style={{ visibility: state.dragging() ? "hidden" : undefined }} data-rk={SCHEDULER_KEYS} onKeyDown={(e) => monthKeyDown(e, ctx)} onClick={(e) => schedulerInteraction("click", e, ctx)} onDblClick={(e) => schedulerInteraction("dblclick", e, ctx)} onContextMenu={(e) => schedulerInteraction("contextmenu", e, ctx)} onFocusIn={(e) => chipFocusIn(e, ctx)} onFocusOut={(e) => chipFocusOut(e, ctx)} onMouseDown={(e) => schedulerPress(e, state)} onTouchStart={(e) => schedulerPress(e, state)}>
+            <div class="rv-SchedulerMonth-popover-title">{panel()?.label}</div>
+            <For each={panelKeys} by={(k) => k}>
+              {(keyOf) => {
+                const key = keyOf();
+                // Keeps the last segment while the list drops this key (the row is removed in the same flush).
+                const segment = computed(() => (panel()?.all.find((candidate) => candidate.key === key) ?? null), { equals: keep });
+                return <SchedulerEventChip segment={() => segment()} lane={true} tabIndex={0} handles={false}/>;
+            }}
+            </For>
+          </div>)}
+      </Popover>
+    </div>);
+}

package/scheduler/pointer.d.ts

@@ -0,0 +1,64 @@
+/** Screen position of a pointer. */
+export interface SchedulerPointerPosition {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * 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 declare 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 declare function elementAt(doc: Document, at: SchedulerPointerPosition, fallback: EventTarget | null): EventTarget | null;
+/** Milliseconds a gesture's trailing click is swallowed for (malva `suppressNextClick` window). */
+export declare 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 declare function swallowNextClick(doc: Document, press: Event, scope: readonly (Element | null | undefined)[]): void;
+/** Callbacks of `attachPointerDrag` / `startPointerDrag`. */
+export interface SchedulerPointerDragHandlers {
+    /** Fires once, when the pointer first crosses the threshold. `point` is where the pointer went down. */
+    onStart?(point: SchedulerPointerPosition, event: Event): void;
+    /** Fires on every pointermove after the threshold. */
+    onMove(point: SchedulerPointerPosition, event: Event): void;
+    /** Fires on pointerup. `moved` is `false` for a plain click that never crossed the threshold. */
+    onEnd(point: SchedulerPointerPosition, moved: boolean, event: Event | null): void;
+    /** Fires on Escape or pointercancel; `onEnd` is not called afterwards. */
+    onCancel?(): void;
+}
+/** Options of `attachPointerDrag` / `startPointerDrag`. */
+export interface SchedulerPointerDragOptions {
+    /** Distance in px before a press becomes a drag. Default `5`. */
+    readonly threshold?: number;
+    /**
+     * Capture the pointer on the element so the compatibility mouse events and the trailing `click` retarget to it.
+     * Default `true`; range selections pass `false` (their cells own the click handlers a press still has to reach).
+     */
+    readonly capture?: boolean;
+    /** Return `true` for targets that must not start a drag (chips, buttons). */
+    ignore?(target: Element): boolean;
+    /**
+     * Milliseconds a TOUCH pointer must stay still before the gesture arms. Default `0`. A touch that moves before
+     * the timer fires abandons the gesture silently (the browser pans); once armed, the pointer is captured and
+     * `touchmove` is prevented. Mouse and pen keep the movement threshold.
+     */
+    readonly touchDelay?: number;
+    /** The press was released before the gesture started (lazy chunk): ends at once as a click. */
+    readonly released?: () => boolean;
+}
+/**
+ * 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 declare function startPointerDrag(down: Event, element: HTMLElement, handlers: SchedulerPointerDragHandlers, options?: SchedulerPointerDragOptions): () => void;
+/** malva `attachPointerDrag`: tracks every press on `element` (one gesture at a time). Returns the detach. */
+export declare function attachPointerDrag(element: HTMLElement, handlers: SchedulerPointerDragHandlers, options?: SchedulerPointerDragOptions): () => void;