vectis-ui 0.1.0

package/dist/components/VCalendar/keyboard.js

@@ -0,0 +1,86 @@
+function e(e, t, n, r, i) {
+	let a = r > 0 ? r : 1, o = i ? -1 : 1;
+	if (n === "grabbed") switch (e) {
+		case "ArrowLeft": return {
+			kind: "grabMove",
+			days: -o,
+			minutes: 0
+		};
+		case "ArrowRight": return {
+			kind: "grabMove",
+			days: o,
+			minutes: 0
+		};
+		case "ArrowUp": return t ? {
+			kind: "grabResize",
+			minutes: -a
+		} : {
+			kind: "grabMove",
+			days: 0,
+			minutes: -a
+		};
+		case "ArrowDown": return t ? {
+			kind: "grabResize",
+			minutes: a
+		} : {
+			kind: "grabMove",
+			days: 0,
+			minutes: a
+		};
+		case "Enter":
+		case " ": return { kind: "activate" };
+		case "Escape": return { kind: "cancel" };
+		default: return;
+	}
+	if (n === "event") switch (e) {
+		case "Enter":
+		case " ": return { kind: "activate" };
+		case "Escape": return { kind: "cancel" };
+		default: return;
+	}
+	switch (e) {
+		case "ArrowLeft": return {
+			kind: "moveFocus",
+			days: -o,
+			minutes: 0
+		};
+		case "ArrowRight": return {
+			kind: "moveFocus",
+			days: o,
+			minutes: 0
+		};
+		case "ArrowUp": return {
+			kind: "moveFocus",
+			days: 0,
+			minutes: -60
+		};
+		case "ArrowDown": return {
+			kind: "moveFocus",
+			days: 0,
+			minutes: 60
+		};
+		case "Home": return {
+			kind: "rowEdge",
+			edge: "start"
+		};
+		case "End": return {
+			kind: "rowEdge",
+			edge: "end"
+		};
+		case "PageUp": return {
+			kind: "period",
+			delta: -1
+		};
+		case "PageDown": return {
+			kind: "period",
+			delta: 1
+		};
+		case "Enter":
+		case " ": return { kind: "activate" };
+		default: return;
+	}
+}
+//#endregion
+export { e as calendarIntent };
+
+//# sourceMappingURL=keyboard.js.map

package/dist/components/VCalendar/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","names":[],"sources":["../../../src/components/VCalendar/keyboard.ts"],"sourcesContent":["// @keyboard @a11y\n/**\n * The pure half of VCalendar's keyboard: it answers the single question \"what does this\n * key mean here?\", and does nothing else. Moving the focus, writing to the model, calling\n * `preventDefault` and announcing the result all stay in the component, where the reactive\n * state lives.\n *\n * It sits in VCalendar's own folder rather than in `utils/` because it has exactly one\n * consumer, which fails the admission rule for shared code (the same reasoning as\n * `VDatePicker/keyboard.ts` and `VHotkeys/platform.ts`). Being pure is also what makes the\n * whole keyboard testable without mounting anything, since the environment the tests run\n * in lays nothing out and the handlers in the component only ever move DOM focus.\n *\n * `utils/arrowNav` is deliberately not used. It navigates a flat DOM list of controls; this\n * navigates a two-dimensional space of DATES AND TIMES whose edges are a domain clamp, not\n * a list end — the same reason VDatePicker, VCombobox and VTimePicker stay out of it.\n *\n * WHY A GRAB MODE, and not arrows that move an event outright. Every gesture the pointer\n * offers has to have a keyboard equivalent (WCAG 2.1.1), and a card is reached by the\n * arrows in the first place — so if the arrows also moved it, arriving at an event and\n * nudging it would be the same keystroke, and there would be no way to pass over one\n * without dragging it. Entering a mode separates the two, and Escape gives back the one\n * thing a pointer drag has that a keypress does not: the chance to change your mind.\n */\n\n/** What one key means, given where the focus is. */\nexport type CalendarIntent =\n  /** Move the focused cell by whole days and whole hours. */\n  | { kind: 'moveFocus'; days: number; minutes: number }\n  /** Jump to the first or last day of the row. */\n  | { kind: 'rowEdge'; edge: 'start' | 'end' }\n  /** Show the previous or next period, as the toolbar's buttons do. */\n  | { kind: 'period'; delta: -1 | 1 }\n  /** Take up what is focused: create here, open a card, or commit a move under way. */\n  | { kind: 'activate' }\n  /** Back out: leave a card for its cell, or abandon a move and put the event back. */\n  | { kind: 'cancel' }\n  /** Move the grabbed event. */\n  | { kind: 'grabMove'; days: number; minutes: number }\n  /** Change how long the grabbed event lasts. */\n  | { kind: 'grabResize'; minutes: number }\n\n/**\n * Where the focus is when the key arrives, which is what decides the answer:\n *\n * - `cell` — an empty part of the grid. The arrows travel, Enter creates.\n * - `event` — a card, at rest. Enter takes hold of it, Escape goes back to the grid.\n * - `grabbed` — a card being moved. The arrows now move the EVENT, Enter commits, Escape\n *   puts it back where it was.\n */\nexport type CalendarFocus = 'cell' | 'event' | 'grabbed'\n\n/** How far one press of an arrow travels vertically in the grid: one hour. */\nconst MINUTES_PER_ROW = 60\n\n/**\n * What a key means. Returning nothing says the key is none of this table's business and\n * the event must be left entirely alone — which is what keeps Tab, the browser's own\n * shortcuts and anything a consumer has bound working.\n *\n * `rtl` is passed in rather than read here: which way is \"forward\" is a property of the\n * document, and a pure table has no business consulting one.\n */\nexport function calendarIntent(\n  key: string,\n  shiftKey: boolean,\n  focus: CalendarFocus,\n  slotMinutes: number,\n  rtl: boolean,\n): CalendarIntent | undefined {\n  const step = slotMinutes > 0 ? slotMinutes : 1\n  // The inline arrows follow the reading direction; the block ones never do, because down\n  // is later in the day in every script.\n  const inline = rtl ? -1 : 1\n\n  if (focus === 'grabbed') {\n    switch (key) {\n      case 'ArrowLeft':\n        return { kind: 'grabMove', days: -inline, minutes: 0 }\n      case 'ArrowRight':\n        return { kind: 'grabMove', days: inline, minutes: 0 }\n      case 'ArrowUp':\n        return shiftKey\n          ? { kind: 'grabResize', minutes: -step }\n          : { kind: 'grabMove', days: 0, minutes: -step }\n      case 'ArrowDown':\n        return shiftKey\n          ? { kind: 'grabResize', minutes: step }\n          : { kind: 'grabMove', days: 0, minutes: step }\n      case 'Enter':\n      case ' ':\n        return { kind: 'activate' }\n      case 'Escape':\n        return { kind: 'cancel' }\n      default:\n        return undefined\n    }\n  }\n\n  if (focus === 'event') {\n    switch (key) {\n      case 'Enter':\n      case ' ':\n        return { kind: 'activate' }\n      case 'Escape':\n        return { kind: 'cancel' }\n      default:\n        return undefined\n    }\n  }\n\n  switch (key) {\n    case 'ArrowLeft':\n      return { kind: 'moveFocus', days: -inline, minutes: 0 }\n    case 'ArrowRight':\n      return { kind: 'moveFocus', days: inline, minutes: 0 }\n    case 'ArrowUp':\n      return { kind: 'moveFocus', days: 0, minutes: -MINUTES_PER_ROW }\n    case 'ArrowDown':\n      return { kind: 'moveFocus', days: 0, minutes: MINUTES_PER_ROW }\n    case 'Home':\n      return { kind: 'rowEdge', edge: 'start' }\n    case 'End':\n      return { kind: 'rowEdge', edge: 'end' }\n    case 'PageUp':\n      return { kind: 'period', delta: -1 }\n    case 'PageDown':\n      return { kind: 'period', delta: 1 }\n    case 'Enter':\n    case ' ':\n      return { kind: 'activate' }\n    default:\n      return undefined\n  }\n}\n"],"mappings":"AA+DA,SAAgB,EACd,GACA,GACA,GACA,GACA,GAC4B;CAC5B,IAAM,IAAO,IAAc,IAAI,IAAc,GAGvC,IAAS,IAAM,KAAK;CAE1B,IAAI,MAAU,WACZ,QAAQ,GAAR;EACE,KAAK,aACH,OAAO;GAAE,MAAM;GAAY,MAAM,CAAC;GAAQ,SAAS;EAAE;EACvD,KAAK,cACH,OAAO;GAAE,MAAM;GAAY,MAAM;GAAQ,SAAS;EAAE;EACtD,KAAK,WACH,OAAO,IACH;GAAE,MAAM;GAAc,SAAS,CAAC;EAAK,IACrC;GAAE,MAAM;GAAY,MAAM;GAAG,SAAS,CAAC;EAAK;EAClD,KAAK,aACH,OAAO,IACH;GAAE,MAAM;GAAc,SAAS;EAAK,IACpC;GAAE,MAAM;GAAY,MAAM;GAAG,SAAS;EAAK;EACjD,KAAK;EACL,KAAK,KACH,OAAO,EAAE,MAAM,WAAW;EAC5B,KAAK,UACH,OAAO,EAAE,MAAM,SAAS;EAC1B,SACE;CACJ;CAGF,IAAI,MAAU,SACZ,QAAQ,GAAR;EACE,KAAK;EACL,KAAK,KACH,OAAO,EAAE,MAAM,WAAW;EAC5B,KAAK,UACH,OAAO,EAAE,MAAM,SAAS;EAC1B,SACE;CACJ;CAGF,QAAQ,GAAR;EACE,KAAK,aACH,OAAO;GAAE,MAAM;GAAa,MAAM,CAAC;GAAQ,SAAS;EAAE;EACxD,KAAK,cACH,OAAO;GAAE,MAAM;GAAa,MAAM;GAAQ,SAAS;EAAE;EACvD,KAAK,WACH,OAAO;GAAE,MAAM;GAAa,MAAM;GAAG,SAAS;EAAiB;EACjE,KAAK,aACH,OAAO;GAAE,MAAM;GAAa,MAAM;GAAG,SAAS;EAAgB;EAChE,KAAK,QACH,OAAO;GAAE,MAAM;GAAW,MAAM;EAAQ;EAC1C,KAAK,OACH,OAAO;GAAE,MAAM;GAAW,MAAM;EAAM;EACxC,KAAK,UACH,OAAO;GAAE,MAAM;GAAU,OAAO;EAAG;EACrC,KAAK,YACH,OAAO;GAAE,MAAM;GAAU,OAAO;EAAE;EACpC,KAAK;EACL,KAAK,KACH,OAAO,EAAE,MAAM,WAAW;EAC5B,SACE;CACJ;AACF"}

package/dist/components/VCalendar/layout.d.ts

@@ -0,0 +1,355 @@
+import { MonthCell } from '../../utils/date.js';
+import { CalendarEvent, CalendarEventId, CalendarEventTimes, CalendarView } from './types.js';
+/**
+ * How far the pointer must travel before a press becomes a drag rather than a click.
+ *
+ * It is what keeps click-to-create and click-to-open alive: a press that never moves this
+ * far writes nothing on release and is handled as a plain activation. Without it, the
+ * hand's natural tremor during a click would register as a one-pixel drag and every click
+ * would silently move its event.
+ */
+export declare const DRAG_THRESHOLD = 3;
+/** The slice of the day a calendar is showing, as minutes since midnight. */
+export interface TimeWindow {
+    start: number;
+    end: number;
+}
+/** Turns the `dayStart`/`dayEnd` props, given in hours, into the window the rest works in. */
+export declare function windowOf(startHour: number, endHour: number): TimeWindow;
+/**
+ * Minutes since midnight back into an `HH:mm` string.
+ *
+ * TRAP — the value is held one minute short of midnight rather than allowed to reach it.
+ * A day's last moment is 1440 in this arithmetic, but `24:00` is not a time any of the
+ * design system's helpers accept (`isValidTime` rejects it), and the alternative — writing
+ * `00:00` on the following day — would turn an ordinary evening appointment into a
+ * two-day event and send it to the all-day band. One minute is invisible at every zoom
+ * this component offers; a card in the wrong place is not.
+ */
+export declare function timeOf(minutes: number): string;
+/** An `HH:mm` string into minutes since midnight; `fallback` when it is not one. */
+export declare function minutesAt(time: string | undefined, fallback: number): number;
+/**
+ * The weekdays a calendar shows, in reading order.
+ *
+ * The array does double duty, which is why there is no separate "first day of week" prop:
+ * it says which days are VISIBLE — `[1,2,3,4,5]` hides the weekend everywhere — and its
+ * first entry is the day a week starts on. Given nothing, the seven days rotated to the
+ * locale's own first day.
+ */
+export declare function normalizeWeekdays(weekdays: readonly number[] | undefined, firstDayOfWeek: number): number[];
+/** Whether a date falls on one of the visible weekdays. */
+export declare function isVisibleDay(iso: string, weekdays: readonly number[]): boolean;
+/**
+ * The first visible day at or after `iso` (or at or before it, going backwards).
+ *
+ * The loop is bounded at seven because a non-empty weekday list always contains one of any
+ * seven consecutive days — the bound is a guard against an empty list, never a real limit.
+ */
+export declare function snapToVisibleDay(iso: string, weekdays: readonly number[], direction?: -1 | 1): string;
+/** Moves `count` VISIBLE days from `iso`, skipping over the hidden ones. */
+export declare function advanceVisibleDays(iso: string, count: number, weekdays: readonly number[]): string;
+/** How many day columns a view shows, before the visible-weekday filter applies. */
+export declare function columnCount(view: CalendarView, customDays: number): number;
+/**
+ * The days a view shows, in reading order.
+ *
+ * `day`, `4days` and `custom` run forward from the anchor over the visible days alone, so
+ * a four-day view of a Monday-to-Friday calendar shows four WORKING days rather than four
+ * calendar ones. `week` shows the week the anchor falls in, starting on `weekdays[0]`.
+ * `month` returns every day of the anchor's month that is visible — the grid that renders
+ * them cuts them back into weeks itself.
+ *
+ * `year` returns an empty list on purpose: that view is twelve month names, not a row of
+ * days, and giving it a 365-entry list nothing reads would be an invitation to read it.
+ */
+export declare function visibleDays(anchor: string, view: CalendarView, weekdays: readonly number[], customDays: number): string[];
+/**
+ * Where Previous and Next land.
+ *
+ * TRAP — the day-shaped views step over VISIBLE days, not calendar ones. Stepping by one
+ * calendar day from a Friday in a Monday-to-Friday calendar would land on a Saturday the
+ * grid does not draw; the view would then show the same week it already showed, and the
+ * button would look broken with nothing in the console to say why.
+ */
+export declare function stepAnchor(anchor: string, view: CalendarView, direction: -1 | 1, weekdays: readonly number[], customDays: number): string;
+/** The first and last day a view covers, which is what names it in the toolbar. */
+export declare function visibleRange(anchor: string, view: CalendarView, weekdays: readonly number[], customDays: number): {
+    start: string;
+    end: string;
+};
+/**
+ * Whether an event belongs in the band above the grid rather than in a day's column.
+ *
+ * The second clause is not a convenience: an event running from one day to the next cannot
+ * be drawn inside a single column, so the band — where it becomes a bar with its times in
+ * its label — is the only place it can honestly go.
+ */
+export declare function isAllDayEvent(event: CalendarEvent): boolean;
+/** One event's box in one day column, in minutes since midnight. */
+export interface EventSegment {
+    id: CalendarEventId;
+    /** Which of the visible columns it belongs to. */
+    dayIndex: number;
+    start: number;
+    end: number;
+    /** Whether the window cut it off, so the card can show that it carries on past the edge. */
+    clippedStart: boolean;
+    clippedEnd: boolean;
+}
+/**
+ * Cuts the timed events into the boxes the day columns draw. All-day events produce none —
+ * they are the band's business — and so does an event whose day is not on show or whose
+ * hours fall entirely outside the window.
+ *
+ * `minDuration` is applied HERE, by stretching the end, so that `packDayColumn` below sees
+ * ordinary intervals and can stay a plain interval algorithm. Were the minimum applied
+ * during packing instead, two events fifteen minutes apart would be laid out as though
+ * they did not overlap and then drawn as though they did.
+ */
+export declare function timedSegments(events: readonly CalendarEvent[], days: readonly string[], window: TimeWindow, minDuration: number): EventSegment[];
+/** A segment once it knows how much of its column's width it gets. */
+export interface PlacedSegment extends EventSegment {
+    /** Which column of its cluster it sits in, counted from zero. */
+    column: number;
+    /** How many columns it takes up — more than one when the room beside it is free. */
+    span: number;
+    /** How many columns its cluster has. It is what both of the above are read against. */
+    columns: number;
+}
+/**
+ * Shares one day's width out between the events happening at the same time.
+ *
+ * Three passes. First the segments are cut into CLUSTERS — runs joined by overlap, where an
+ * event starting after everything before it has finished begins a new one. That is what
+ * stops a crowded morning from squeezing a lone afternoon meeting into a sliver. Then,
+ * inside a cluster, each event takes the first column whose last occupant has already
+ * ended, which is the ordinary greedy colouring of an interval graph and uses as few
+ * columns as the cluster can be drawn in. Finally each event grows sideways for as long as
+ * nothing in the next column overlaps it, so a single event never leaves a gap it could
+ * have filled.
+ *
+ * The order is fixed — by start, then longest first, then by id — so the same list always
+ * produces the same picture. Without the id to break the last tie, two events at the same
+ * time for the same length would swap places whenever the array was re-sorted, and the
+ * whole day would appear to shuffle for no reason.
+ *
+ * Overlap is strictly `a.start < b.end && b.start < a.end`, so events that merely touch —
+ * one ending exactly as the next begins — share a column instead of splitting the width.
+ */
+export declare function packDayColumn(segments: readonly EventSegment[]): PlacedSegment[];
+/**
+ * One square of the month view: a day, and whether it belongs to the month on show.
+ *
+ * It is `utils/date`'s own type, re-exported rather than restated: `monthWeeks` below builds
+ * its cells by calling `buildMonthGrid` from that module, so a second declaration here could
+ * only ever drift away from the shape it is actually handed. The re-export keeps
+ * `import { type MonthCell } from './layout.js'` working for the two views that read it.
+ */
+export type { MonthCell };
+/**
+ * The month view, cut into weeks.
+ *
+ * It keeps the fixed six rows `buildMonthGrid` produces — padded with the neighbouring
+ * months — so the grid is the same height whichever month is on show and the page does not
+ * jump as one steps through the year. Each row is then filtered down to the visible
+ * weekdays, which is what makes a Monday-to-Friday month five columns wide rather than
+ * seven with two blanks.
+ */
+export declare function monthWeeks(anchor: string, weekdays: readonly number[]): MonthCell[][];
+/** The first day of each month of the anchor's year, which is what the year view lays out. */
+export declare function monthsOfYear(anchor: string): string[];
+/** Whether an event covers a given day at all, all-day or timed. */
+export declare function coversDay(event: CalendarEvent, iso: string): boolean;
+/**
+ * The events falling on one day, in the order a summary should list them: the all-day ones
+ * first, since they frame the day rather than sit inside it, then the rest by when they
+ * start. The last tie is broken by id so the list cannot reshuffle for no reason.
+ */
+export declare function eventsOnDay<T extends CalendarEvent>(events: readonly T[], iso: string): T[];
+/**
+ * Every visible day's events at once, in one pass over the list.
+ *
+ * WHY THIS EXISTS RATHER THAN A LOOP OVER `eventsOnDay`. The month view needs all 42 squares
+ * filled, and asking `eventsOnDay` once per square walks the whole event list 42 times and
+ * sorts it 42 times — `cells × events`, with a sort each. Measured on the bench: 7.8 ms per
+ * render at 2000 events, and the month view re-renders on every `pointermove` of a drag, so
+ * that is roughly half a frame spent rebuilding lists no gesture changed.
+ *
+ * Here each event is placed once, into the days it actually covers, and each day is sorted
+ * once — `events × span + cells × k log k`. The walk is bounded to the grid on both ends, so
+ * an event running from last year costs its visible part and nothing more.
+ *
+ * The ORDER is identical to `eventsOnDay`'s, because both sort with `compareForDay`. That
+ * matters: it is the order chips are listed in, so a difference would be visible.
+ */
+export declare function eventsByDay<T extends CalendarEvent>(events: readonly T[], days: readonly string[]): Map<string, T[]>;
+/** One bar in the all-day band: the columns it covers, and the row it sits on. */
+export interface AllDaySpan {
+    id: CalendarEventId;
+    /** The first visible column it covers. */
+    startIndex: number;
+    /** How many visible columns it covers, at least one. */
+    span: number;
+    /** Whether it reaches beyond the days on show, on either side. */
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+    /** Which row of the band it sits on. */
+    lane: number;
+}
+/**
+ * Stacks the all-day bars into as few rows as they fit in.
+ *
+ * A bar covers the run from the FIRST to the LAST visible day it touches, which is what
+ * makes a hidden weekday in the middle of a range simply not there rather than a gap to
+ * account for: an event running Friday to Monday in a Monday-to-Friday calendar shows as
+ * one day on the Friday and one on the following Monday, because those are the two days it
+ * actually covers on screen.
+ *
+ * The rows are the same greedy pass the day columns use — each bar takes the first row
+ * whose last bar has already ended — and the ordering is fixed, longest first at equal
+ * starts, so the band cannot reshuffle when the array is re-sorted.
+ */
+export declare function packAllDay(events: readonly CalendarEvent[], days: readonly string[]): AllDaySpan[];
+/** Where a moment sits in the visible window, as a unitless fraction the stylesheet scales. */
+export declare function fractionOf(minutes: number, window: TimeWindow): number;
+/** The measurements of the grid a pointer is being read against, in viewport coordinates. */
+export interface GridGeometry {
+    top: number;
+    height: number;
+    /** The edge the first column starts at: the left one normally, the right one in RTL. */
+    inlineStart: number;
+    inlineSize: number;
+    columns: number;
+}
+/**
+ * Turns a point on the screen into a point on the calendar: which day column it fell in,
+ * and what moment that height stands for.
+ *
+ * Both answers are brought back inside the grid, so a pointer dragged past an edge keeps
+ * producing the nearest sensible value rather than none — which is what makes a drag that
+ * wanders off the component behave as the user expects instead of stopping dead.
+ */
+export declare function pointToCell(point: {
+    x: number;
+    y: number;
+}, geometry: GridGeometry, window: TimeWindow, rtl: boolean): {
+    columnIndex: number;
+    minutes: number;
+};
+/** Rounds a moment to the nearest step the calendar allows. */
+export declare function snapToSlot(minutes: number, step: number): number;
+/** Rounds a moment DOWN to the step containing it — where a new event begins. */
+export declare function floorToSlot(minutes: number, step: number): number;
+/**
+ * Where an event lands when it is dragged or nudged: it keeps its length and moves by whole
+ * days and whole steps.
+ *
+ * An event pushed past the end of the window is held against it rather than having its tail
+ * cut off — moving something must never change how long it is, which is the other gesture's
+ * job.
+ */
+export declare function moveEvent(origin: CalendarEventTimes, dayDelta: number, minuteDelta: number, window: TimeWindow, weekdays?: readonly number[]): CalendarEventTimes;
+/**
+ * Where the end of an event lands when its bottom edge is dragged. It can never cross the
+ * start: the shortest an event may become is one step, which is also the length a new one
+ * is created at.
+ */
+export declare function resizeEvent(origin: CalendarEventTimes, endMinutes: number, minDuration: number, window: TimeWindow): CalendarEventTimes;
+/**
+ * How many whole days an event covers beyond its first — zero for one that starts and ends
+ * on the same day, two for a trip from Monday to Wednesday.
+ */
+export declare function daySpan(times: CalendarEventTimes): number;
+/**
+ * Moves an event to another day, KEEPING its length in days as well as its times.
+ *
+ * This is the counterpart of `moveEvent`, and the two must not be confused: that one is for
+ * a timed move INSIDE a single day and deliberately collapses `end` onto `start`, so putting
+ * a three-day trip through it would silently squash it into one Tuesday. This one is for the
+ * whole-day gestures — an all-day bar dragged along the band, a chip dragged across a month —
+ * where the times are carried along untouched and only the dates move.
+ */
+export declare function moveEventToDay(origin: CalendarEventTimes, target: string): CalendarEventTimes;
+/** The measurements of a month grid — the same struct, with rows where a time window was. */
+export interface MonthGeometry {
+    top: number;
+    height: number;
+    inlineStart: number;
+    inlineSize: number;
+    columns: number;
+    rows: number;
+}
+/**
+ * Turns a point on the screen into a square of the month.
+ *
+ * The block axis is a ROW here rather than a moment, which is the whole difference from
+ * `pointToCell` — the inline half is the same arithmetic, RTL flip included. It is sound
+ * because every week of a month is drawn the same height: the rows share what space there is
+ * and a day too full for its box clips rather than growing.
+ */
+export declare function pointToMonthCell(point: {
+    x: number;
+    y: number;
+}, geometry: MonthGeometry, rtl: boolean): {
+    columnIndex: number;
+    rowIndex: number;
+};
+/**
+ * Which inline edge a point is resting against, as a direction to page in: -1 for the start
+ * edge, 1 for the end one, nothing in between.
+ *
+ * It answers in READING order, so the start edge is the left one normally and the right one
+ * in a right-to-left page — which is what makes "hold at the edge to go back" mean the same
+ * thing in both.
+ */
+export declare function inlineEdgeAt(x: number, geometry: {
+    inlineStart: number;
+    inlineSize: number;
+}, band: number, rtl: boolean): -1 | 1 | null;
+/**
+ * How hard a point near the top or bottom of a box is asking it to scroll: -1 at the very
+ * top, 1 at the very bottom, 0 anywhere in the middle.
+ *
+ * A FRACTION and not a direction, so the speed can rise as the pointer nears the edge. At a
+ * constant speed there is no setting that works: fast enough to be useful at the boundary is
+ * uncontrollable a few pixels in, and gentle enough to be controllable never gets anywhere.
+ */
+export declare function blockEdgeAt(y: number, geometry: {
+    top: number;
+    height: number;
+}, band: number): number;
+/**
+ * Whether a point falls inside a box — how a drag decides, on release, whether it is over the
+ * calendar at all or over the toolbar, or over the page beside it.
+ *
+ * It takes the box as the browser MEASURED it, and never the `GridGeometry` the rest of this file
+ * works in. Containment is a physical question with no reading direction, where `inlineStart` is
+ * the box's RIGHT edge in a right-to-left page: bracketing with it would walk off the far side of
+ * the screen and make every right-to-left drop read as outside. `columns` says nothing about
+ * whether a point is in a box either, so asking for a `GridGeometry` would ask every caller to
+ * build a thing this needs no part of.
+ *
+ * The edges COUNT as inside: a rect is a pair of floats on a screen that may be scaled by a
+ * fraction, and an exclusive boundary would refuse a drop that looked, and was, on target.
+ *
+ * TRAP — a box that measures nothing contains EVERYTHING. That is the same answer `inlineEdgeAt`
+ * and `blockEdgeAt` give a box of no size, and for the same reason: with no measurement there is
+ * no outside to be on. Take a zero-size box literally instead and the calendar refuses every drop
+ * wherever nothing has been laid out — in a hidden tab, before the first frame, and in jsdom,
+ * which measures nothing at all and where all but a handful of the drag tests would go red at
+ * once.
+ */
+export declare function pointWithin(point: {
+    x: number;
+    y: number;
+}, box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}): boolean;
+/** The times of an event, as the shape the move and resize events carry. */
+export declare function timesOf(event: CalendarEvent): CalendarEventTimes;
+/** Today, as the calendar reads it. Kept here so the component has one place to call. */
+export declare function todayISO(): string;