vectis-ui 0.1.0

package/dist/components/VCalendar/layout.js

@@ -0,0 +1,292 @@
+import { clamp as e } from "../../utils/number.js";
+import { pad2 as t } from "../../utils/text.js";
+import { addDays as n, addMonths as r, buildMonthGrid as i, compareISO as a, daysInMonth as o, formatISO as s, isoOf as c, parseISO as l } from "../../utils/date.js";
+import { minutesOf as u } from "../../utils/time.js";
+//#region src/components/VCalendar/layout.ts
+var d = 1440, f = 7, p = 1440 * 60 * 1e3;
+function m(e, t) {
+	let n = String(e), r = String(t);
+	return n < r ? -1 : +(n > r);
+}
+function h(t, n) {
+	let r = e(Math.round(t * 60), 0, d);
+	return {
+		start: r,
+		end: e(Math.round(n * 60), r + 60, d)
+	};
+}
+function g(n) {
+	let r = e(Math.round(n), 0, d - 1);
+	return `${t(Math.floor(r / 60))}:${t(r % 60)}`;
+}
+function _(e, t) {
+	return u(e) ?? t;
+}
+function v(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = [];
+	for (let t of e ?? []) {
+		let e = Math.trunc(t);
+		e >= 0 && e <= 6 && !n.has(e) && (n.add(e), r.push(e));
+	}
+	if (r.length > 0) return r;
+	let i = (Math.trunc(t) % 7 + 7) % 7;
+	return Array.from({ length: f }, (e, t) => (i + t) % 7);
+}
+function y(e, t) {
+	let n = l(e);
+	return n !== null && t.includes(n.getDay());
+}
+function b(e, t, r = 1) {
+	if (t.length === 0) return e;
+	let i = e;
+	for (let e = 0; e < f; e++) {
+		if (y(i, t)) return i;
+		i = n(i, r);
+	}
+	return e;
+}
+function x(e, t, r) {
+	if (t === 0 || r.length === 0) return e;
+	let i = t > 0 ? 1 : -1, a = e, o = Math.abs(t), s = Math.abs(t) * f + f;
+	for (; o > 0 && s-- > 0;) a = n(a, i), y(a, r) && o--;
+	return a;
+}
+function S(t, n) {
+	return t === "day" ? 1 : t === "4days" ? 4 : t === "custom" ? e(Math.trunc(n), 1, 31) : f;
+}
+function C(e, t, r, i) {
+	if (r.length === 0 || l(e) === null || t === "year") return [];
+	if (t === "month") {
+		let t = l(e), n = t.getFullYear(), i = t.getMonth(), a = [];
+		for (let e = 1; e <= o(n, i); e++) {
+			let t = c(n, i, e);
+			y(t, r) && a.push(t);
+		}
+		return a;
+	}
+	if (t === "week") {
+		let t = n(e, -((l(e).getDay() - r[0] + f) % f)), i = [];
+		for (let e = 0; e < f; e++) {
+			let a = n(t, e);
+			y(a, r) && i.push(a);
+		}
+		return i;
+	}
+	let a = S(t, i), s = [b(e, r)];
+	for (let e = 1; e < a; e++) s.push(x(s[e - 1], 1, r));
+	return s;
+}
+function w(e, t, i, a, o) {
+	return l(e) === null ? e : t === "month" ? r(e, i) : t === "year" ? r(e, i * 12) : t === "week" ? b(n(e, i * f), a) : x(e, i * S(t, o), a);
+}
+function T(e, t, n, r) {
+	if (t === "year") {
+		let t = l(e)?.getFullYear() ?? (/* @__PURE__ */ new Date()).getFullYear();
+		return {
+			start: c(t, 0, 1),
+			end: c(t, 11, 31)
+		};
+	}
+	let i = C(e, t, n, r);
+	return i.length === 0 ? {
+		start: e,
+		end: e
+	} : {
+		start: i[0],
+		end: i[i.length - 1]
+	};
+}
+function E(e) {
+	return e.allDay === !0 || a(e.start, e.end) !== 0;
+}
+function D(t, n, r, i) {
+	let a = new Map(n.map((e, t) => [e, t])), o = [];
+	for (let n of t) {
+		if (E(n)) continue;
+		let t = a.get(n.start);
+		if (t === void 0) continue;
+		let s = _(n.startTime, r.start), c = Math.max(_(n.endTime, s + i), s + 1);
+		if (c <= r.start || s >= r.end) continue;
+		let l = e(s, r.start, r.end - 1), u = e(Math.max(c, l + i), l + 1, r.end);
+		o.push({
+			id: n.id,
+			dayIndex: t,
+			start: l,
+			end: u,
+			clippedStart: s < r.start,
+			clippedEnd: c > r.end
+		});
+	}
+	return o;
+}
+function O(e) {
+	let t = [...e].sort((e, t) => e.start - t.start || t.end - t.start - (e.end - e.start) || m(e.id, t.id)), n = [], r = [], i = [], a = -Infinity, o = () => {
+		let e = i.length;
+		for (let t of r) {
+			let n = 1;
+			for (; t.column + n < e && !r.some((e) => e.column === t.column + n && e.start < t.end && t.start < e.end);) n++;
+			t.span = n, t.columns = e;
+		}
+		n.push(...r), r = [], i = [], a = -Infinity;
+	};
+	for (let e of t) {
+		e.start >= a && r.length > 0 && o();
+		let t = i.findIndex((t) => t <= e.start);
+		t === -1 ? (t = i.length, i.push(e.end)) : i[t] = e.end, r.push({
+			...e,
+			column: t,
+			span: 1,
+			columns: 1
+		}), a = Math.max(a, e.end);
+	}
+	return r.length > 0 && o(), n;
+}
+function k(e, t) {
+	let n = l(e);
+	if (!n || t.length === 0) return [];
+	let r = i(n.getFullYear(), n.getMonth(), t[0]), a = [];
+	for (let e = 0; e < r.length; e += f) {
+		let n = r.slice(e, e + f).filter((e) => y(e.iso, t));
+		n.length > 0 && a.push(n);
+	}
+	return a;
+}
+function A(e) {
+	let t = l(e);
+	if (!t) return [];
+	let n = t.getFullYear();
+	return Array.from({ length: 12 }, (e, t) => c(n, t, 1));
+}
+function j(e, t) {
+	return a(t, e.start) >= 0 && a(t, e.end) <= 0;
+}
+function M(e, t) {
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) r.set(e, []);
+	if (t.length === 0) return /* @__PURE__ */ new Map();
+	let i = t[0], o = t[t.length - 1];
+	for (let t of e) {
+		let e = a(t.start, i) > 0 ? t.start : i, s = a(t.end, o) < 0 ? t.end : o;
+		if (a(e, s) > 0) continue;
+		let c = {
+			event: t,
+			allDay: +!E(t),
+			minutes: _(t.startTime, 0),
+			id: String(t.id)
+		};
+		for (let t = e; a(t, s) <= 0; t = n(t, 1)) r.get(t)?.push(c);
+	}
+	let s = /* @__PURE__ */ new Map();
+	for (let [e, t] of r) t.sort(N), s.set(e, t.map((e) => e.event));
+	return s;
+}
+function N(e, t) {
+	return e.allDay - t.allDay || e.minutes - t.minutes || (e.id < t.id ? -1 : +(e.id > t.id));
+}
+function P(e, t) {
+	let n = [];
+	for (let r of e) {
+		if (!E(r)) continue;
+		let e = -1, i = -1;
+		for (let n = 0; n < t.length; n++) j(r, t[n]) && (e === -1 && (e = n), i = n);
+		e !== -1 && n.push({
+			id: r.id,
+			startIndex: e,
+			span: i - e + 1,
+			continuesBefore: a(r.start, t[e]) < 0,
+			continuesAfter: a(r.end, t[i]) > 0,
+			lane: 0
+		});
+	}
+	n.sort((e, t) => e.startIndex - t.startIndex || t.span - e.span || m(e.id, t.id));
+	let r = [];
+	for (let e of n) {
+		let t = r.findIndex((t) => t < e.startIndex);
+		t === -1 && (t = r.length, r.push(0)), r[t] = e.startIndex + e.span - 1, e.lane = t;
+	}
+	return n;
+}
+function F(t, n) {
+	let r = n.end - n.start;
+	return r > 0 ? e((t - n.start) / r, 0, 1) : 0;
+}
+function I(t, n, r, i) {
+	let a = Math.max(1, n.columns), o = n.inlineSize / a, s = i ? n.inlineStart - t.x : t.x - n.inlineStart, c = e(o > 0 ? Math.floor(s / o) : 0, 0, a - 1), l = n.height > 0 ? (t.y - n.top) / n.height : 0;
+	return {
+		columnIndex: c,
+		minutes: e(r.start + l * (r.end - r.start), r.start, r.end)
+	};
+}
+function L(t, n) {
+	let r = n > 0 ? n : 1;
+	return e(Math.round(t / r) * r, 0, d);
+}
+function R(t, n) {
+	let r = n > 0 ? n : 1;
+	return e(Math.floor(t / r) * r, 0, d);
+}
+function z(t, r, i, a, o) {
+	let s = _(t.startTime, a.start), c = Math.max(_(t.endTime, s), s + 1) - s, l = o && o.length > 0 ? x(t.start, r, o) : n(t.start, r), u = e(s + i, a.start, Math.max(a.start, a.end - c));
+	return {
+		start: l,
+		end: l,
+		startTime: g(u),
+		endTime: g(u + c)
+	};
+}
+function B(t, n, r, i) {
+	let a = _(t.startTime, i.start), o = e(n, a + Math.max(r, 1), i.end);
+	return {
+		start: t.start,
+		end: t.start,
+		startTime: g(a),
+		endTime: g(o)
+	};
+}
+function V(e) {
+	let t = l(e.start), n = l(e.end);
+	return !t || !n ? 0 : Math.max(0, Math.round((n.getTime() - t.getTime()) / p));
+}
+function H(e, t) {
+	return l(t) === null ? e : {
+		start: t,
+		end: n(t, V(e)),
+		startTime: e.startTime,
+		endTime: e.endTime
+	};
+}
+function U(t, n, r) {
+	let i = Math.max(1, n.columns), a = Math.max(1, n.rows), o = n.inlineSize / i, s = r ? n.inlineStart - t.x : t.x - n.inlineStart, c = e(o > 0 ? Math.floor(s / o) : 0, 0, i - 1), l = n.height / a;
+	return {
+		columnIndex: c,
+		rowIndex: e(l > 0 ? Math.floor((t.y - n.top) / l) : 0, 0, a - 1)
+	};
+}
+function W(e, t, n, r) {
+	if (n <= 0 || t.inlineSize <= 0) return null;
+	let i = r ? t.inlineStart - e : e - t.inlineStart;
+	return i < n ? -1 : i > t.inlineSize - n ? 1 : null;
+}
+function G(t, n, r) {
+	if (r <= 0 || n.height <= 0) return 0;
+	let i = t - n.top, a = n.top + n.height - t;
+	return i < r ? -e((r - i) / r, 0, 1) : a < r ? e((r - a) / r, 0, 1) : 0;
+}
+function K(e, t) {
+	return t.width <= 0 || t.height <= 0 || e.x >= t.left && e.x <= t.left + t.width && e.y >= t.top && e.y <= t.top + t.height;
+}
+function q(e) {
+	return {
+		start: e.start,
+		end: e.end,
+		startTime: e.startTime,
+		endTime: e.endTime
+	};
+}
+function J() {
+	return s(/* @__PURE__ */ new Date());
+}
+//#endregion
+export { x as advanceVisibleDays, G as blockEdgeAt, S as columnCount, j as coversDay, V as daySpan, M as eventsByDay, R as floorToSlot, F as fractionOf, W as inlineEdgeAt, E as isAllDayEvent, y as isVisibleDay, _ as minutesAt, k as monthWeeks, A as monthsOfYear, z as moveEvent, H as moveEventToDay, v as normalizeWeekdays, P as packAllDay, O as packDayColumn, I as pointToCell, U as pointToMonthCell, K as pointWithin, B as resizeEvent, L as snapToSlot, b as snapToVisibleDay, w as stepAnchor, g as timeOf, D as timedSegments, q as timesOf, J as todayISO, C as visibleDays, T as visibleRange, h as windowOf };
+
+//# sourceMappingURL=layout.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","names":[],"sources":["../../../src/components/VCalendar/layout.ts"],"sourcesContent":["// @core\n/**\n * Everything VCalendar has to work out rather than render: which days a view shows, where\n * an event's box goes, how a day's width is shared between events happening at once, and\n * what point on the screen corresponds to what moment in the day.\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, and because VCalendar owns\n * the contract (the same reasoning as `VDatePicker/keyboard.ts` and\n * `VHotkeys/platform.ts`).\n *\n * Being pure is not tidiness here, it is the only way any of this is testable. The test\n * environment lays nothing out — every element it renders measures zero — so a function\n * that took an Element could never be checked. NOTHING below receives one: the single\n * `getBoundingClientRect()` in the whole component builds the plain `GridGeometry` struct\n * that `pointToCell` takes, and every consequence of that measurement is an ordinary unit\n * test over numbers.\n *\n * Times are handled throughout as MINUTES SINCE MIDNIGHT, converted at the edges from the\n * `HH:mm` strings the public API speaks. That is what lets the arithmetic be plain\n * addition instead of a string dance at every step.\n */\nimport {\n  addDays,\n  addMonths,\n  buildMonthGrid,\n  compareISO,\n  daysInMonth,\n  formatISO,\n  isoOf,\n  parseISO,\n} from '../../utils/date'\nimport { clamp } from '../../utils/number'\nimport { pad2 } from '../../utils/text'\nimport { minutesOf } from '../../utils/time'\n\nimport type { MonthCell } from '../../utils/date'\nimport type { CalendarEvent, CalendarEventId, CalendarEventTimes, CalendarView } from './types'\n\n/** How many minutes a day holds. The upper bound of every time computed here. */\nconst MINUTES_PER_DAY = 24 * 60\n\nconst DAYS_PER_WEEK = 7\n\n/**\n * A day in milliseconds, for counting the days between two dates.\n *\n * It is safe here because both ends come from `parseISO`, which builds LOCAL midnights: the\n * difference between two of them is a whole number of days everywhere except across a\n * daylight-saving boundary, and `Math.round` absorbs the hour that gains or loses there.\n */\nconst MS_PER_DAY = 24 * 60 * 60 * 1000\n\n/**\n * How far the pointer must travel before a press becomes a drag rather than a click.\n *\n * It is what keeps click-to-create and click-to-open alive: a press that never moves this\n * far writes nothing on release and is handled as a plain activation. Without it, the\n * hand's natural tremor during a click would register as a one-pixel drag and every click\n * would silently move its event.\n */\nexport const DRAG_THRESHOLD = 3\n\n/**\n * The last tie-break of every ordering below: a stable total order over event ids.\n *\n * TRAP — this must NOT be `localeCompare`. An id is an opaque key, never user-facing text,\n * so there is nothing here to collate; and `localeCompare` with no locale resolves against\n * the RUNTIME's default, which differs between Node and the browser. The three orderings it\n * settles all decide rendered markup — `packDayColumn` assigns columns, `packAllDay`\n * assigns lanes, `eventsOnDay` sets the order chips are listed in — so a divergent order is\n * a hydration mismatch, silent in dev and visible only as a card in the wrong place. It is\n * the same hazard `VDataTable` avoids by passing its locale explicitly.\n *\n * Comparing by code point is also allocation-free, which matters because all three run on\n * every frame of a drag.\n */\nfunction compareId(a: CalendarEventId, b: CalendarEventId): number {\n  const left = String(a)\n  const right = String(b)\n  return left < right ? -1 : left > right ? 1 : 0\n}\n\n/** The slice of the day a calendar is showing, as minutes since midnight. */\nexport interface TimeWindow {\n  start: number\n  end: number\n}\n\n/** Turns the `dayStart`/`dayEnd` props, given in hours, into the window the rest works in. */\nexport function windowOf(startHour: number, endHour: number): TimeWindow {\n  const start = clamp(Math.round(startHour * 60), 0, MINUTES_PER_DAY)\n  const end = clamp(Math.round(endHour * 60), start + 60, MINUTES_PER_DAY)\n  return { start, end }\n}\n\n/**\n * Minutes since midnight back into an `HH:mm` string.\n *\n * TRAP — the value is held one minute short of midnight rather than allowed to reach it.\n * A day's last moment is 1440 in this arithmetic, but `24:00` is not a time any of the\n * design system's helpers accept (`isValidTime` rejects it), and the alternative — writing\n * `00:00` on the following day — would turn an ordinary evening appointment into a\n * two-day event and send it to the all-day band. One minute is invisible at every zoom\n * this component offers; a card in the wrong place is not.\n */\nexport function timeOf(minutes: number): string {\n  const held = clamp(Math.round(minutes), 0, MINUTES_PER_DAY - 1)\n  return `${pad2(Math.floor(held / 60))}:${pad2(held % 60)}`\n}\n\n/** An `HH:mm` string into minutes since midnight; `fallback` when it is not one. */\nexport function minutesAt(time: string | undefined, fallback: number): number {\n  return minutesOf(time) ?? fallback\n}\n\n/**\n * The weekdays a calendar shows, in reading order.\n *\n * The array does double duty, which is why there is no separate \"first day of week\" prop:\n * it says which days are VISIBLE — `[1,2,3,4,5]` hides the weekend everywhere — and its\n * first entry is the day a week starts on. Given nothing, the seven days rotated to the\n * locale's own first day.\n */\nexport function normalizeWeekdays(\n  weekdays: readonly number[] | undefined,\n  firstDayOfWeek: number,\n): number[] {\n  const seen = new Set<number>()\n  const kept: number[] = []\n  for (const day of weekdays ?? []) {\n    const value = Math.trunc(day)\n    if (value >= 0 && value <= 6 && !seen.has(value)) {\n      seen.add(value)\n      kept.push(value)\n    }\n  }\n  if (kept.length > 0) return kept\n  const first = ((Math.trunc(firstDayOfWeek) % 7) + 7) % 7\n  return Array.from({ length: DAYS_PER_WEEK }, (_, i) => (first + i) % 7)\n}\n\n/** Whether a date falls on one of the visible weekdays. */\nexport function isVisibleDay(iso: string, weekdays: readonly number[]): boolean {\n  const date = parseISO(iso)\n  return date !== null && weekdays.includes(date.getDay())\n}\n\n/**\n * The first visible day at or after `iso` (or at or before it, going backwards).\n *\n * The loop is bounded at seven because a non-empty weekday list always contains one of any\n * seven consecutive days — the bound is a guard against an empty list, never a real limit.\n */\nexport function snapToVisibleDay(\n  iso: string,\n  weekdays: readonly number[],\n  direction: -1 | 1 = 1,\n): string {\n  if (weekdays.length === 0) return iso\n  let current = iso\n  for (let i = 0; i < DAYS_PER_WEEK; i++) {\n    if (isVisibleDay(current, weekdays)) return current\n    current = addDays(current, direction)\n  }\n  return iso\n}\n\n/** Moves `count` VISIBLE days from `iso`, skipping over the hidden ones. */\nexport function advanceVisibleDays(\n  iso: string,\n  count: number,\n  weekdays: readonly number[],\n): string {\n  if (count === 0 || weekdays.length === 0) return iso\n  const direction = count > 0 ? 1 : -1\n  let current = iso\n  let remaining = Math.abs(count)\n  // Bounded so a malformed weekday list can never spin: at worst one visible day costs\n  // seven calendar days, so this is the same walk with its worst case written down.\n  let guard = Math.abs(count) * DAYS_PER_WEEK + DAYS_PER_WEEK\n  while (remaining > 0 && guard-- > 0) {\n    current = addDays(current, direction)\n    if (isVisibleDay(current, weekdays)) remaining--\n  }\n  return current\n}\n\n/** How many day columns a view shows, before the visible-weekday filter applies. */\nexport function columnCount(view: CalendarView, customDays: number): number {\n  if (view === 'day') return 1\n  if (view === '4days') return 4\n  if (view === 'custom') return clamp(Math.trunc(customDays), 1, 31)\n  return DAYS_PER_WEEK\n}\n\n/**\n * The days a view shows, in reading order.\n *\n * `day`, `4days` and `custom` run forward from the anchor over the visible days alone, so\n * a four-day view of a Monday-to-Friday calendar shows four WORKING days rather than four\n * calendar ones. `week` shows the week the anchor falls in, starting on `weekdays[0]`.\n * `month` returns every day of the anchor's month that is visible — the grid that renders\n * them cuts them back into weeks itself.\n *\n * `year` returns an empty list on purpose: that view is twelve month names, not a row of\n * days, and giving it a 365-entry list nothing reads would be an invitation to read it.\n */\nexport function visibleDays(\n  anchor: string,\n  view: CalendarView,\n  weekdays: readonly number[],\n  customDays: number,\n): string[] {\n  if (weekdays.length === 0 || parseISO(anchor) === null) return []\n  if (view === 'year') return []\n\n  if (view === 'month') {\n    const date = parseISO(anchor)!\n    const year = date.getFullYear()\n    const month0 = date.getMonth()\n    const days: string[] = []\n    for (let day = 1; day <= daysInMonth(year, month0); day++) {\n      const iso = isoOf(year, month0, day)\n      if (isVisibleDay(iso, weekdays)) days.push(iso)\n    }\n    return days\n  }\n\n  if (view === 'week') {\n    const date = parseISO(anchor)!\n    const offset = (date.getDay() - weekdays[0]! + DAYS_PER_WEEK) % DAYS_PER_WEEK\n    const weekStart = addDays(anchor, -offset)\n    const days: string[] = []\n    for (let i = 0; i < DAYS_PER_WEEK; i++) {\n      const iso = addDays(weekStart, i)\n      if (isVisibleDay(iso, weekdays)) days.push(iso)\n    }\n    return days\n  }\n\n  const total = columnCount(view, customDays)\n  const days: string[] = [snapToVisibleDay(anchor, weekdays)]\n  for (let i = 1; i < total; i++) days.push(advanceVisibleDays(days[i - 1]!, 1, weekdays))\n  return days\n}\n\n/**\n * Where Previous and Next land.\n *\n * TRAP — the day-shaped views step over VISIBLE days, not calendar ones. Stepping by one\n * calendar day from a Friday in a Monday-to-Friday calendar would land on a Saturday the\n * grid does not draw; the view would then show the same week it already showed, and the\n * button would look broken with nothing in the console to say why.\n */\nexport function stepAnchor(\n  anchor: string,\n  view: CalendarView,\n  direction: -1 | 1,\n  weekdays: readonly number[],\n  customDays: number,\n): string {\n  if (parseISO(anchor) === null) return anchor\n  if (view === 'month') return addMonths(anchor, direction)\n  if (view === 'year') return addMonths(anchor, direction * 12)\n  if (view === 'week') return snapToVisibleDay(addDays(anchor, direction * DAYS_PER_WEEK), weekdays)\n  return advanceVisibleDays(anchor, direction * columnCount(view, customDays), weekdays)\n}\n\n/** The first and last day a view covers, which is what names it in the toolbar. */\nexport function visibleRange(\n  anchor: string,\n  view: CalendarView,\n  weekdays: readonly number[],\n  customDays: number,\n): { start: string; end: string } {\n  if (view === 'year') {\n    const date = parseISO(anchor)\n    const year = date?.getFullYear() ?? new Date().getFullYear()\n    return { start: isoOf(year, 0, 1), end: isoOf(year, 11, 31) }\n  }\n  const days = visibleDays(anchor, view, weekdays, customDays)\n  if (days.length === 0) return { start: anchor, end: anchor }\n  return { start: days[0]!, end: days[days.length - 1]! }\n}\n\n/**\n * Whether an event belongs in the band above the grid rather than in a day's column.\n *\n * The second clause is not a convenience: an event running from one day to the next cannot\n * be drawn inside a single column, so the band — where it becomes a bar with its times in\n * its label — is the only place it can honestly go.\n */\nexport function isAllDayEvent(event: CalendarEvent): boolean {\n  return event.allDay === true || compareISO(event.start, event.end) !== 0\n}\n\n/** One event's box in one day column, in minutes since midnight. */\nexport interface EventSegment {\n  id: CalendarEventId\n  /** Which of the visible columns it belongs to. */\n  dayIndex: number\n  start: number\n  end: number\n  /** Whether the window cut it off, so the card can show that it carries on past the edge. */\n  clippedStart: boolean\n  clippedEnd: boolean\n}\n\n/**\n * Cuts the timed events into the boxes the day columns draw. All-day events produce none —\n * they are the band's business — and so does an event whose day is not on show or whose\n * hours fall entirely outside the window.\n *\n * `minDuration` is applied HERE, by stretching the end, so that `packDayColumn` below sees\n * ordinary intervals and can stay a plain interval algorithm. Were the minimum applied\n * during packing instead, two events fifteen minutes apart would be laid out as though\n * they did not overlap and then drawn as though they did.\n */\nexport function timedSegments(\n  events: readonly CalendarEvent[],\n  days: readonly string[],\n  window: TimeWindow,\n  minDuration: number,\n): EventSegment[] {\n  const index = new Map(days.map((iso, i) => [iso, i]))\n  const segments: EventSegment[] = []\n\n  for (const event of events) {\n    if (isAllDayEvent(event)) continue\n    const dayIndex = index.get(event.start)\n    if (dayIndex === undefined) continue\n\n    const rawStart = minutesAt(event.startTime, window.start)\n    const rawEnd = Math.max(minutesAt(event.endTime, rawStart + minDuration), rawStart + 1)\n    if (rawEnd <= window.start || rawStart >= window.end) continue\n\n    const start = clamp(rawStart, window.start, window.end - 1)\n    const end = clamp(Math.max(rawEnd, start + minDuration), start + 1, window.end)\n    segments.push({\n      id: event.id,\n      dayIndex,\n      start,\n      end,\n      clippedStart: rawStart < window.start,\n      clippedEnd: rawEnd > window.end,\n    })\n  }\n\n  return segments\n}\n\n/** A segment once it knows how much of its column's width it gets. */\nexport interface PlacedSegment extends EventSegment {\n  /** Which column of its cluster it sits in, counted from zero. */\n  column: number\n  /** How many columns it takes up — more than one when the room beside it is free. */\n  span: number\n  /** How many columns its cluster has. It is what both of the above are read against. */\n  columns: number\n}\n\n/**\n * Shares one day's width out between the events happening at the same time.\n *\n * Three passes. First the segments are cut into CLUSTERS — runs joined by overlap, where an\n * event starting after everything before it has finished begins a new one. That is what\n * stops a crowded morning from squeezing a lone afternoon meeting into a sliver. Then,\n * inside a cluster, each event takes the first column whose last occupant has already\n * ended, which is the ordinary greedy colouring of an interval graph and uses as few\n * columns as the cluster can be drawn in. Finally each event grows sideways for as long as\n * nothing in the next column overlaps it, so a single event never leaves a gap it could\n * have filled.\n *\n * The order is fixed — by start, then longest first, then by id — so the same list always\n * produces the same picture. Without the id to break the last tie, two events at the same\n * time for the same length would swap places whenever the array was re-sorted, and the\n * whole day would appear to shuffle for no reason.\n *\n * Overlap is strictly `a.start < b.end && b.start < a.end`, so events that merely touch —\n * one ending exactly as the next begins — share a column instead of splitting the width.\n */\nexport function packDayColumn(segments: readonly EventSegment[]): PlacedSegment[] {\n  const sorted = [...segments].sort(\n    (a, b) => a.start - b.start || b.end - b.start - (a.end - a.start) || compareId(a.id, b.id),\n  )\n\n  const placed: PlacedSegment[] = []\n  let cluster: PlacedSegment[] = []\n  let columnEnds: number[] = []\n  let clusterEnd = -Infinity\n\n  const flush = () => {\n    const columns = columnEnds.length\n    for (const item of cluster) {\n      let span = 1\n      while (\n        item.column + span < columns &&\n        !cluster.some(\n          (other) =>\n            other.column === item.column + span && other.start < item.end && item.start < other.end,\n        )\n      ) {\n        span++\n      }\n      item.span = span\n      item.columns = columns\n    }\n    placed.push(...cluster)\n    cluster = []\n    columnEnds = []\n    clusterEnd = -Infinity\n  }\n\n  for (const segment of sorted) {\n    if (segment.start >= clusterEnd && cluster.length > 0) flush()\n\n    let column = columnEnds.findIndex((end) => end <= segment.start)\n    if (column === -1) {\n      column = columnEnds.length\n      columnEnds.push(segment.end)\n    } else {\n      columnEnds[column] = segment.end\n    }\n\n    cluster.push({ ...segment, column, span: 1, columns: 1 })\n    clusterEnd = Math.max(clusterEnd, segment.end)\n  }\n  if (cluster.length > 0) flush()\n\n  return placed\n}\n\n/**\n * One square of the month view: a day, and whether it belongs to the month on show.\n *\n * It is `utils/date`'s own type, re-exported rather than restated: `monthWeeks` below builds\n * its cells by calling `buildMonthGrid` from that module, so a second declaration here could\n * only ever drift away from the shape it is actually handed. The re-export keeps\n * `import { type MonthCell } from './layout'` working for the two views that read it.\n */\nexport type { MonthCell }\n\n/**\n * The month view, cut into weeks.\n *\n * It keeps the fixed six rows `buildMonthGrid` produces — padded with the neighbouring\n * months — so the grid is the same height whichever month is on show and the page does not\n * jump as one steps through the year. Each row is then filtered down to the visible\n * weekdays, which is what makes a Monday-to-Friday month five columns wide rather than\n * seven with two blanks.\n */\nexport function monthWeeks(anchor: string, weekdays: readonly number[]): MonthCell[][] {\n  const date = parseISO(anchor)\n  if (!date || weekdays.length === 0) return []\n\n  const cells = buildMonthGrid(date.getFullYear(), date.getMonth(), weekdays[0]!)\n  const weeks: MonthCell[][] = []\n  for (let i = 0; i < cells.length; i += DAYS_PER_WEEK) {\n    const week = cells\n      .slice(i, i + DAYS_PER_WEEK)\n      .filter((cell) => isVisibleDay(cell.iso, weekdays))\n    if (week.length > 0) weeks.push(week)\n  }\n  return weeks\n}\n\n/** The first day of each month of the anchor's year, which is what the year view lays out. */\nexport function monthsOfYear(anchor: string): string[] {\n  const date = parseISO(anchor)\n  if (!date) return []\n  const year = date.getFullYear()\n  return Array.from({ length: 12 }, (_, month0) => isoOf(year, month0, 1))\n}\n\n/** Whether an event covers a given day at all, all-day or timed. */\nexport function coversDay(event: CalendarEvent, iso: string): boolean {\n  return compareISO(iso, event.start) >= 0 && compareISO(iso, event.end) <= 0\n}\n\n/**\n * The events falling on one day, in the order a summary should list them: the all-day ones\n * first, since they frame the day rather than sit inside it, then the rest by when they\n * start. The last tie is broken by id so the list cannot reshuffle for no reason.\n */\nexport function eventsOnDay<T extends CalendarEvent>(events: readonly T[], iso: string): T[] {\n  return events.filter((event) => coversDay(event, iso)).sort(compareForDay)\n}\n\n/** The order `eventsOnDay` and `eventsByDay` both list a day in — see `eventsOnDay`. */\nfunction compareForDay(a: CalendarEvent, b: CalendarEvent): number {\n  const allDayA = isAllDayEvent(a) ? 0 : 1\n  const allDayB = isAllDayEvent(b) ? 0 : 1\n  return (\n    allDayA - allDayB ||\n    minutesAt(a.startTime, 0) - minutesAt(b.startTime, 0) ||\n    compareId(a.id, b.id)\n  )\n}\n\n/**\n * Every visible day's events at once, in one pass over the list.\n *\n * WHY THIS EXISTS RATHER THAN A LOOP OVER `eventsOnDay`. The month view needs all 42 squares\n * filled, and asking `eventsOnDay` once per square walks the whole event list 42 times and\n * sorts it 42 times — `cells × events`, with a sort each. Measured on the bench: 7.8 ms per\n * render at 2000 events, and the month view re-renders on every `pointermove` of a drag, so\n * that is roughly half a frame spent rebuilding lists no gesture changed.\n *\n * Here each event is placed once, into the days it actually covers, and each day is sorted\n * once — `events × span + cells × k log k`. The walk is bounded to the grid on both ends, so\n * an event running from last year costs its visible part and nothing more.\n *\n * The ORDER is identical to `eventsOnDay`'s, because both sort with `compareForDay`. That\n * matters: it is the order chips are listed in, so a difference would be visible.\n */\nexport function eventsByDay<T extends CalendarEvent>(\n  events: readonly T[],\n  days: readonly string[],\n): Map<string, T[]> {\n  const buckets = new Map<string, Ranked<T>[]>()\n  for (const iso of days) buckets.set(iso, [])\n  if (days.length === 0) return new Map()\n\n  // The grid's own bounds. `days` is in order, so its ends bound every walk below — which\n  // is what keeps a long-running event from being walked outside the month on show.\n  const first = days[0]!\n  const last = days[days.length - 1]!\n\n  for (const event of events) {\n    const from = compareISO(event.start, first) > 0 ? event.start : first\n    const to = compareISO(event.end, last) < 0 ? event.end : last\n    if (compareISO(from, to) > 0) continue\n\n    /*\n     * The sort key is derived ONCE per event, not once per comparison — which is where the\n     * time in this function actually goes. `compareForDay` calls `minutesAt`, and that\n     * re-parses an `HH:mm` string every time it is asked: a 42-square month holding 2000\n     * events sorts some 17 000 pairs, so the parsing dwarfed the scan this pass replaced.\n     * Measured: removing the redundant scan alone bought 5 %, hoisting the key bought the\n     * rest. Decorate-sort-undecorate, for exactly the classic reason.\n     */\n    const ranked: Ranked<T> = {\n      event,\n      allDay: isAllDayEvent(event) ? 0 : 1,\n      minutes: minutesAt(event.startTime, 0),\n      id: String(event.id),\n    }\n\n    for (let iso = from; compareISO(iso, to) <= 0; iso = addDays(iso, 1)) {\n      // A day the weekday filter hides has no bucket, so it is simply skipped: that is what\n      // makes a Monday-to-Friday month cost nothing for the weekends it does not show.\n      buckets.get(iso)?.push(ranked)\n    }\n  }\n\n  const byDay = new Map<string, T[]>()\n  for (const [iso, list] of buckets) {\n    list.sort(compareRanked)\n    byDay.set(\n      iso,\n      list.map((item) => item.event),\n    )\n  }\n  return byDay\n}\n\n/** An event with its sort key already worked out — see `eventsByDay`. */\ninterface Ranked<T> {\n  event: T\n  allDay: number\n  minutes: number\n  id: string\n}\n\n/** `compareForDay`, reading keys that are already computed rather than deriving them. */\nfunction compareRanked<T>(a: Ranked<T>, b: Ranked<T>): number {\n  return a.allDay - b.allDay || a.minutes - b.minutes || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)\n}\n\n/** One bar in the all-day band: the columns it covers, and the row it sits on. */\nexport interface AllDaySpan {\n  id: CalendarEventId\n  /** The first visible column it covers. */\n  startIndex: number\n  /** How many visible columns it covers, at least one. */\n  span: number\n  /** Whether it reaches beyond the days on show, on either side. */\n  continuesBefore: boolean\n  continuesAfter: boolean\n  /** Which row of the band it sits on. */\n  lane: number\n}\n\n/**\n * Stacks the all-day bars into as few rows as they fit in.\n *\n * A bar covers the run from the FIRST to the LAST visible day it touches, which is what\n * makes a hidden weekday in the middle of a range simply not there rather than a gap to\n * account for: an event running Friday to Monday in a Monday-to-Friday calendar shows as\n * one day on the Friday and one on the following Monday, because those are the two days it\n * actually covers on screen.\n *\n * The rows are the same greedy pass the day columns use — each bar takes the first row\n * whose last bar has already ended — and the ordering is fixed, longest first at equal\n * starts, so the band cannot reshuffle when the array is re-sorted.\n */\nexport function packAllDay(\n  events: readonly CalendarEvent[],\n  days: readonly string[],\n): AllDaySpan[] {\n  const spans: AllDaySpan[] = []\n\n  for (const event of events) {\n    if (!isAllDayEvent(event)) continue\n\n    let first = -1\n    let last = -1\n    for (let i = 0; i < days.length; i++) {\n      if (coversDay(event, days[i]!)) {\n        if (first === -1) first = i\n        last = i\n      }\n    }\n    if (first === -1) continue\n\n    spans.push({\n      id: event.id,\n      startIndex: first,\n      span: last - first + 1,\n      continuesBefore: compareISO(event.start, days[first]!) < 0,\n      continuesAfter: compareISO(event.end, days[last]!) > 0,\n      lane: 0,\n    })\n  }\n\n  spans.sort((a, b) => a.startIndex - b.startIndex || b.span - a.span || compareId(a.id, b.id))\n\n  const laneEnds: number[] = []\n  for (const span of spans) {\n    let lane = laneEnds.findIndex((end) => end < span.startIndex)\n    if (lane === -1) {\n      lane = laneEnds.length\n      laneEnds.push(0)\n    }\n    laneEnds[lane] = span.startIndex + span.span - 1\n    span.lane = lane\n  }\n\n  return spans\n}\n\n/** Where a moment sits in the visible window, as a unitless fraction the stylesheet scales. */\nexport function fractionOf(minutes: number, window: TimeWindow): number {\n  const span = window.end - window.start\n  return span > 0 ? clamp((minutes - window.start) / span, 0, 1) : 0\n}\n\n/** The measurements of the grid a pointer is being read against, in viewport coordinates. */\nexport interface GridGeometry {\n  top: number\n  height: number\n  /** The edge the first column starts at: the left one normally, the right one in RTL. */\n  inlineStart: number\n  inlineSize: number\n  columns: number\n}\n\n/**\n * Turns a point on the screen into a point on the calendar: which day column it fell in,\n * and what moment that height stands for.\n *\n * Both answers are brought back inside the grid, so a pointer dragged past an edge keeps\n * producing the nearest sensible value rather than none — which is what makes a drag that\n * wanders off the component behave as the user expects instead of stopping dead.\n */\nexport function pointToCell(\n  point: { x: number; y: number },\n  geometry: GridGeometry,\n  window: TimeWindow,\n  rtl: boolean,\n): { columnIndex: number; minutes: number } {\n  const columns = Math.max(1, geometry.columns)\n  const columnSize = geometry.inlineSize / columns\n  const offset = rtl ? geometry.inlineStart - point.x : point.x - geometry.inlineStart\n  const columnIndex = clamp(columnSize > 0 ? Math.floor(offset / columnSize) : 0, 0, columns - 1)\n\n  const fraction = geometry.height > 0 ? (point.y - geometry.top) / geometry.height : 0\n  const minutes = clamp(\n    window.start + fraction * (window.end - window.start),\n    window.start,\n    window.end,\n  )\n\n  return { columnIndex, minutes }\n}\n\n/** Rounds a moment to the nearest step the calendar allows. */\nexport function snapToSlot(minutes: number, step: number): number {\n  const size = step > 0 ? step : 1\n  return clamp(Math.round(minutes / size) * size, 0, MINUTES_PER_DAY)\n}\n\n/** Rounds a moment DOWN to the step containing it — where a new event begins. */\nexport function floorToSlot(minutes: number, step: number): number {\n  const size = step > 0 ? step : 1\n  return clamp(Math.floor(minutes / size) * size, 0, MINUTES_PER_DAY)\n}\n\n/**\n * Where an event lands when it is dragged or nudged: it keeps its length and moves by whole\n * days and whole steps.\n *\n * An event pushed past the end of the window is held against it rather than having its tail\n * cut off — moving something must never change how long it is, which is the other gesture's\n * job.\n */\nexport function moveEvent(\n  origin: CalendarEventTimes,\n  dayDelta: number,\n  minuteDelta: number,\n  window: TimeWindow,\n  weekdays?: readonly number[],\n): CalendarEventTimes {\n  const startMinutes = minutesAt(origin.startTime, window.start)\n  const endMinutes = Math.max(minutesAt(origin.endTime, startMinutes), startMinutes + 1)\n  const duration = endMinutes - startMinutes\n\n  const start =\n    weekdays && weekdays.length > 0\n      ? advanceVisibleDays(origin.start, dayDelta, weekdays)\n      : addDays(origin.start, dayDelta)\n\n  const nextStart = clamp(\n    startMinutes + minuteDelta,\n    window.start,\n    Math.max(window.start, window.end - duration),\n  )\n\n  return {\n    start,\n    end: start,\n    startTime: timeOf(nextStart),\n    endTime: timeOf(nextStart + duration),\n  }\n}\n\n/**\n * Where the end of an event lands when its bottom edge is dragged. It can never cross the\n * start: the shortest an event may become is one step, which is also the length a new one\n * is created at.\n */\nexport function resizeEvent(\n  origin: CalendarEventTimes,\n  endMinutes: number,\n  minDuration: number,\n  window: TimeWindow,\n): CalendarEventTimes {\n  const startMinutes = minutesAt(origin.startTime, window.start)\n  const floor = Math.max(minDuration, 1)\n  const end = clamp(endMinutes, startMinutes + floor, window.end)\n\n  return {\n    start: origin.start,\n    end: origin.start,\n    startTime: timeOf(startMinutes),\n    endTime: timeOf(end),\n  }\n}\n\n/**\n * How many whole days an event covers beyond its first — zero for one that starts and ends\n * on the same day, two for a trip from Monday to Wednesday.\n */\nexport function daySpan(times: CalendarEventTimes): number {\n  const start = parseISO(times.start)\n  const end = parseISO(times.end)\n  if (!start || !end) return 0\n  return Math.max(0, Math.round((end.getTime() - start.getTime()) / MS_PER_DAY))\n}\n\n/**\n * Moves an event to another day, KEEPING its length in days as well as its times.\n *\n * This is the counterpart of `moveEvent`, and the two must not be confused: that one is for\n * a timed move INSIDE a single day and deliberately collapses `end` onto `start`, so putting\n * a three-day trip through it would silently squash it into one Tuesday. This one is for the\n * whole-day gestures — an all-day bar dragged along the band, a chip dragged across a month —\n * where the times are carried along untouched and only the dates move.\n */\nexport function moveEventToDay(origin: CalendarEventTimes, target: string): CalendarEventTimes {\n  if (parseISO(target) === null) return origin\n  return {\n    start: target,\n    end: addDays(target, daySpan(origin)),\n    startTime: origin.startTime,\n    endTime: origin.endTime,\n  }\n}\n\n/** The measurements of a month grid — the same struct, with rows where a time window was. */\nexport interface MonthGeometry {\n  top: number\n  height: number\n  inlineStart: number\n  inlineSize: number\n  columns: number\n  rows: number\n}\n\n/**\n * Turns a point on the screen into a square of the month.\n *\n * The block axis is a ROW here rather than a moment, which is the whole difference from\n * `pointToCell` — the inline half is the same arithmetic, RTL flip included. It is sound\n * because every week of a month is drawn the same height: the rows share what space there is\n * and a day too full for its box clips rather than growing.\n */\nexport function pointToMonthCell(\n  point: { x: number; y: number },\n  geometry: MonthGeometry,\n  rtl: boolean,\n): { columnIndex: number; rowIndex: number } {\n  const columns = Math.max(1, geometry.columns)\n  const rows = Math.max(1, geometry.rows)\n\n  const columnSize = geometry.inlineSize / columns\n  const offset = rtl ? geometry.inlineStart - point.x : point.x - geometry.inlineStart\n  const columnIndex = clamp(columnSize > 0 ? Math.floor(offset / columnSize) : 0, 0, columns - 1)\n\n  const rowSize = geometry.height / rows\n  const rowIndex = clamp(\n    rowSize > 0 ? Math.floor((point.y - geometry.top) / rowSize) : 0,\n    0,\n    rows - 1,\n  )\n\n  return { columnIndex, rowIndex }\n}\n\n/**\n * Which inline edge a point is resting against, as a direction to page in: -1 for the start\n * edge, 1 for the end one, nothing in between.\n *\n * It answers in READING order, so the start edge is the left one normally and the right one\n * in a right-to-left page — which is what makes \"hold at the edge to go back\" mean the same\n * thing in both.\n */\nexport function inlineEdgeAt(\n  x: number,\n  geometry: { inlineStart: number; inlineSize: number },\n  band: number,\n  rtl: boolean,\n): -1 | 1 | null {\n  if (band <= 0 || geometry.inlineSize <= 0) return null\n  const offset = rtl ? geometry.inlineStart - x : x - geometry.inlineStart\n  // Past the far side of the box counts as being against that edge: a pointer dragged clean\n  // off the calendar is asking to keep going, not to stop.\n  if (offset < band) return -1\n  if (offset > geometry.inlineSize - band) return 1\n  return null\n}\n\n/**\n * How hard a point near the top or bottom of a box is asking it to scroll: -1 at the very\n * top, 1 at the very bottom, 0 anywhere in the middle.\n *\n * A FRACTION and not a direction, so the speed can rise as the pointer nears the edge. At a\n * constant speed there is no setting that works: fast enough to be useful at the boundary is\n * uncontrollable a few pixels in, and gentle enough to be controllable never gets anywhere.\n */\nexport function blockEdgeAt(\n  y: number,\n  geometry: { top: number; height: number },\n  band: number,\n): number {\n  if (band <= 0 || geometry.height <= 0) return 0\n  const fromTop = y - geometry.top\n  const fromBottom = geometry.top + geometry.height - y\n  if (fromTop < band) return -clamp((band - fromTop) / band, 0, 1)\n  if (fromBottom < band) return clamp((band - fromBottom) / band, 0, 1)\n  return 0\n}\n\n/**\n * Whether a point falls inside a box — how a drag decides, on release, whether it is over the\n * calendar at all or over the toolbar, or over the page beside it.\n *\n * It takes the box as the browser MEASURED it, and never the `GridGeometry` the rest of this file\n * works in. Containment is a physical question with no reading direction, where `inlineStart` is\n * the box's RIGHT edge in a right-to-left page: bracketing with it would walk off the far side of\n * the screen and make every right-to-left drop read as outside. `columns` says nothing about\n * whether a point is in a box either, so asking for a `GridGeometry` would ask every caller to\n * build a thing this needs no part of.\n *\n * The edges COUNT as inside: a rect is a pair of floats on a screen that may be scaled by a\n * fraction, and an exclusive boundary would refuse a drop that looked, and was, on target.\n *\n * TRAP — a box that measures nothing contains EVERYTHING. That is the same answer `inlineEdgeAt`\n * and `blockEdgeAt` give a box of no size, and for the same reason: with no measurement there is\n * no outside to be on. Take a zero-size box literally instead and the calendar refuses every drop\n * wherever nothing has been laid out — in a hidden tab, before the first frame, and in jsdom,\n * which measures nothing at all and where all but a handful of the drag tests would go red at\n * once.\n */\nexport function pointWithin(\n  point: { x: number; y: number },\n  box: { left: number; top: number; width: number; height: number },\n): boolean {\n  if (box.width <= 0 || box.height <= 0) return true\n  return (\n    point.x >= box.left &&\n    point.x <= box.left + box.width &&\n    point.y >= box.top &&\n    point.y <= box.top + box.height\n  )\n}\n\n/** The times of an event, as the shape the move and resize events carry. */\nexport function timesOf(event: CalendarEvent): CalendarEventTimes {\n  return {\n    start: event.start,\n    end: event.end,\n    startTime: event.startTime,\n    endTime: event.endTime,\n  }\n}\n\n/** Today, as the calendar reads it. Kept here so the component has one place to call. */\nexport function todayISO(): string {\n  return formatISO(new Date())\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,78 @@
+/**
+ * The vocabulary VCalendar and its internal grids share.
+ *
+ * These types live in a module of their own rather than in `VCalendar.vue` because the
+ * grids need them and VCalendar imports the grids: declaring them beside the component
+ * would make that a cycle. The name follows the rule for an ancillary module — a role
+ * name, unprefixed, since the `V` marks a tag and a TypeScript module has none (the
+ * `VIcon/types.ts` precedent).
+ *
+ * Every date below is a local ISO `YYYY-MM-DD` string and every time a 24-hour `HH:mm`
+ * one, exactly as `utils/date` and `utils/time` define them. That is what keeps the
+ * server and the browser in agreement: no `Date` crosses this boundary, so no timezone
+ * can shift a card between the two renders.
+ */
+/** What identifies one event, and what the move and resize events refer back to. */
+export type CalendarEventId = string | number;
+/**
+ * One entry in the calendar.
+ *
+ * The seven fields below are the contract. A consumer needing more of their own writes an
+ * interface extending this one and hands it to the component, which carries the type
+ * through to the `#event` slot — so extra fields arrive typed rather than as `unknown`.
+ */
+export interface CalendarEvent {
+    /**
+     * What identifies this event. It must be unique among the events given and stable
+     * across renders: it is what the drag writes back to, what gives a card its key, and
+     * what decides the colour of an event that names none — so an event keeps its colour
+     * as the list is filtered or re-sorted.
+     */
+    id: CalendarEventId;
+    /** What the event is called. It is the accessible name of its card. */
+    title: string;
+    /** The day it starts on. */
+    start: string;
+    /** The day it ends on — the same day as `start` for an ordinary appointment. */
+    end: string;
+    /** When it starts on that day. */
+    startTime: string;
+    /** When it ends. */
+    endTime: string;
+    /** A second line under the title, shown where the card is tall enough to hold one. */
+    description?: string;
+    /**
+     * Any CSS colour. Left out, one is derived from the id, so the same event is always
+     * drawn the same way. It tints the card and paints its leading edge; the title is never
+     * set on top of it, which is what keeps an arbitrary colour readable.
+     */
+    color?: string;
+    /**
+     * The name of a time zone, shown beside the times as an annotation — "09:00 – 10:00
+     * (Europe/Paris)". It is DISPLAY ONLY: it never moves the card, which is always placed
+     * from the dates and times above, read as local time.
+     */
+    timezone?: string;
+    /**
+     * Keeps the event in the band above the grid rather than in a day's column. An event
+     * whose `start` and `end` fall on different days is already shown there without this,
+     * since a card spanning two days cannot be drawn inside one column.
+     */
+    allDay?: boolean;
+}
+/**
+ * Which period the calendar is showing. `custom` is the general case and `4days` a
+ * preset on the same machinery — they differ only in where the number of days comes from.
+ */
+export type CalendarView = 'day' | '4days' | 'week' | 'month' | 'year' | 'custom';
+/**
+ * Where an event sits in time, and nothing else. The move and resize events carry one of
+ * these as the "before" value, so a consumer can undo a drag without keeping a copy of
+ * the whole event.
+ */
+export interface CalendarEventTimes {
+    start: string;
+    end: string;
+    startTime: string;
+    endTime: string;
+}

package/dist/components/VCarousel/VCarousel.css

@@ -0,0 +1,2 @@
+@layer vectis.reset, vectis.tokens, vectis.components, vectis.utilities;
+@layer vectis.components{.v-carousel{--carousel-axis-x:1;--carousel-axis-y:0;--carousel-dir:1;--carousel-tilt:32deg;--carousel-depth:-6rem;--carousel-perspective:60rem;--carousel-scale-min:.86;--carousel-gap:var(--vectis-space-3);--carousel-item-min:0px;--carousel-peek:0px;--carousel-viewport-block:var(--vectis-control-size-carousel-block);--carousel-outset:0px;gap:var(--vectis-space-3);font-family:var(--vectis-text-family);flex-direction:column;display:flex;position:relative}.v-carousel[data-orientation=horizontal]{padding-inline:var(--carousel-outset)}.v-carousel[data-orientation=vertical]{--carousel-axis-x:0;--carousel-axis-y:1;padding-block:var(--carousel-outset);flex-direction:row}.v-carousel[data-controls=outside]:has(>.v-carousel-stage>.v-carousel-controls){--carousel-outset:calc(var(--vectis-control-height-md) + var(--vectis-space-2))}[dir=rtl] .v-carousel[data-orientation=horizontal]{--carousel-dir:-1}.v-carousel-stage{gap:var(--vectis-space-3);flex-direction:column;min-block-size:0;min-inline-size:0;display:flex;position:relative}.v-carousel[data-orientation=vertical] .v-carousel-stage{flex-grow:1}.v-carousel-viewport{gap:var(--carousel-gap);overscroll-behavior:contain;scroll-snap-type:inline mandatory;scroll-behavior:smooth;scrollbar-width:none;border-radius:var(--vectis-radius-surface);min-block-size:0;min-inline-size:0;display:flex;overflow:auto}.v-carousel-viewport::-webkit-scrollbar{display:none}.v-carousel-viewport:focus-visible{outline:var(--vectis-focus-ring-width) solid var(--vectis-focus-ring-color);outline-offset:var(--vectis-focus-ring-offset)}.v-carousel[data-orientation=vertical] .v-carousel-viewport{scroll-snap-type:block mandatory;block-size:var(--carousel-viewport-block);flex-direction:column}.v-carousel-slide{flex-grow:0;flex-shrink:0;flex-basis:max(var(--carousel-item-min), calc((100% - (var(--carousel-per-view) - 1) * var(--carousel-gap) - var(--carousel-peek)) / var(--carousel-per-view)));scroll-snap-align:start;min-block-size:0;min-inline-size:0;position:relative}.v-carousel-slide:last-child{scroll-snap-align:end}.v-carousel-effect{block-size:100%}@supports (view-timeline-name:--v) and (animation-range:cover){.v-carousel:not([data-effect=slide]) .v-carousel-slide{view-timeline:--carousel-view inline}.v-carousel[data-orientation=vertical]:not([data-effect=slide]) .v-carousel-slide{view-timeline:--carousel-view block}.v-carousel:not([data-effect=slide]) .v-carousel-effect{animation-timing-function:linear;animation-fill-mode:both;animation-timeline:--carousel-view;animation-range:cover;animation-duration:auto}.v-carousel[data-effect=fade] .v-carousel-effect{animation-name:v-carousel-fade}.v-carousel[data-effect=scale] .v-carousel-effect{animation-name:v-carousel-scale}.v-carousel[data-effect=cover] .v-carousel-effect{animation-name:v-carousel-cover}}@keyframes v-carousel-fade{0%{opacity:0;translate:calc(var(--carousel-axis-x) * var(--carousel-dir) * -100%) calc(var(--carousel-axis-y) * -100%)}50%{opacity:1;translate:0}to{opacity:0;translate:calc(var(--carousel-axis-x) * var(--carousel-dir) * 100%) calc(var(--carousel-axis-y) * 100%)}}@keyframes v-carousel-scale{0%,to{scale:var(--carousel-scale-min)}50%{scale:1}}@keyframes v-carousel-cover{0%{transform:perspective(var(--carousel-perspective)) translateZ(var(--carousel-depth)) rotate3d(var(--carousel-axis-y), var(--carousel-axis-x), 0, calc(var(--carousel-dir) * var(--carousel-tilt)))}50%{transform:perspective(var(--carousel-perspective)) translateZ(0) rotate3d(0, 1, 0, 0deg)}to{transform:perspective(var(--carousel-perspective)) translateZ(var(--carousel-depth)) rotate3d(var(--carousel-axis-y), var(--carousel-axis-x), 0, calc(var(--carousel-dir) * var(--carousel-tilt) * -1))}}.v-carousel-controls{gap:var(--vectis-space-2);transition:opacity var(--vectis-duration-fast) var(--vectis-ease-default);display:flex}.v-carousel[data-orientation=vertical] .v-carousel-controls{flex-direction:column}[dir=rtl] .v-carousel[data-orientation=horizontal] .v-carousel-control .v-icon{scale:-1 1}.v-carousel:is([data-controls=inside],[data-controls=outside]) .v-carousel-controls{pointer-events:none;justify-content:space-between;align-items:center;position:absolute;inset:0}.v-carousel[data-controls=inside] .v-carousel-controls{inset:var(--vectis-space-2)}.v-carousel[data-controls=outside] .v-carousel-controls{inset-inline:calc(-1 * var(--carousel-outset))}.v-carousel[data-orientation=vertical][data-controls=outside] .v-carousel-controls{inset-inline:0;inset-block:calc(-1 * var(--carousel-outset))}@media (hover:hover){.v-carousel[data-controls-visibility=hover] .v-carousel-controls{opacity:0}.v-carousel[data-controls-visibility=hover]:hover .v-carousel-controls,.v-carousel[data-controls-visibility=hover]:has(:focus-visible) .v-carousel-controls{opacity:1}}.v-carousel-control{pointer-events:auto}.v-carousel-indicators{gap:var(--vectis-space-1);justify-content:center;align-items:center;display:flex}.v-carousel[data-orientation=vertical] .v-carousel-indicators{flex-direction:column}.v-carousel[data-indicators=inside] .v-carousel-indicators{inline-size:fit-content;margin-inline:auto;position:absolute;inset-block-end:var(--vectis-space-3);inset-inline:0}.v-carousel[data-orientation=vertical][data-indicators=inside] .v-carousel-indicators{inset-block:0;inset-inline:auto var(--vectis-space-3);block-size:fit-content;margin-block:auto;margin-inline:0}.v-carousel-indicator{min-inline-size:var(--vectis-control-height-xs);min-block-size:var(--vectis-control-height-xs);cursor:pointer;border-radius:var(--vectis-radius-pill);background:0 0;border:0;justify-content:center;align-items:center;padding:0;display:flex}.v-carousel-indicator:focus-visible{outline:var(--vectis-focus-ring-width) solid var(--vectis-focus-ring-color);outline-offset:calc(-1 * var(--vectis-focus-ring-width))}.v-carousel-dot{inline-size:var(--vectis-control-size-carousel-indicator);block-size:var(--vectis-control-size-carousel-indicator);background:var(--vectis-color-border-strong);border-radius:var(--vectis-radius-pill);transition:inline-size var(--vectis-duration-base) var(--vectis-ease-default), block-size var(--vectis-duration-base) var(--vectis-ease-default), background var(--vectis-duration-base) var(--vectis-ease-default);display:block}.v-carousel-indicator:hover .v-carousel-dot{background:var(--vectis-color-text-subtle)}.v-carousel-indicator[aria-current] .v-carousel-dot{inline-size:var(--vectis-control-size-carousel-indicator-active);background:var(--vectis-color-accent)}.v-carousel[data-orientation=vertical] .v-carousel-indicator[aria-current] .v-carousel-dot{inline-size:var(--vectis-control-size-carousel-indicator);block-size:var(--vectis-control-size-carousel-indicator-active)}.v-carousel[data-indicators=inside] .v-carousel-dot{background:color-mix(in oklab, var(--vectis-color-text-on-accent) 55%, transparent);box-shadow:0 0 0 1px color-mix(in oklab, var(--vectis-color-surface-inverse) 45%, transparent)}.v-carousel[data-indicators=inside] .v-carousel-indicator:hover .v-carousel-dot,.v-carousel[data-indicators=inside] .v-carousel-indicator[aria-current] .v-carousel-dot{background:var(--vectis-color-text-on-accent)}@media (prefers-reduced-motion:reduce){.v-carousel-effect{animation:none}.v-carousel-viewport{scroll-behavior:auto}.v-carousel-controls,.v-carousel-dot{transition:none}}}