@vunset/vue 0.0.0-stage → 1.0.0-rc.2

package/dist/components/calendar/use-calendar.js

@@ -0,0 +1,657 @@
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { useControlled } from "../../shared/use-controlled.js";
+import { createContext } from "../../shared/context.js";
+import { useFieldValue, useOptionalFieldContext } from "../../shared/use-field.js";
+import { computed, nextTick, ref, shallowRef, toValue, watch } from "vue";
+import { DAYS_IN_WEEK, MONTHS_IN_YEAR, addDays, addMonths, addYears, clampDate, compareDay, daysInMonth, endOfMonth, endOfYear, firstDayOfWeek, formatISO, formatSafeISO, isSameDay, isSameMonth, isToday, isWeekend, isWithin, monthNames, presetRange, setDateRange, startOfDay, startOfMonth, startOfYear, subDays, toDate, weekDayNames } from "@vunset/utils";
+//#region src/components/calendar/use-calendar.ts
+var YEARS_PER_PAGE = 12;
+var DEFAULT_PRESETS = [
+	"today",
+	"yesterday",
+	"last-7",
+	"last-30",
+	"this-month",
+	"last-month"
+];
+var PRESET_GROUPS = {
+	base: DEFAULT_PRESETS,
+	all: [
+		...DEFAULT_PRESETS,
+		"this-year",
+		"q1",
+		"q2",
+		"q3",
+		"q4"
+	]
+};
+var PRESET_LABELS = {
+	today: "Today",
+	yesterday: "Yesterday",
+	"last-7": "Last 7 Days",
+	"last-30": "Last 30 Days",
+	"this-month": "This Month",
+	"last-month": "Last Month",
+	"this-year": "This Year",
+	q1: "Q1",
+	q2: "Q2",
+	q3: "Q3",
+	q4: "Q4"
+};
+var QUARTERS = /* @__PURE__ */ new Set([
+	"q1",
+	"q2",
+	"q3",
+	"q4"
+]);
+function isPresetKey(key) {
+	return Object.prototype.hasOwnProperty.call(PRESET_LABELS, key);
+}
+function useCalendar(options = {}) {
+	const mode = () => toValue(options.mode) ?? "single";
+	const locale = () => toValue(options.locale);
+	const localeFirstDay = computed(() => firstDayOfWeek(locale()));
+	const firstDayOfWeek$1 = () => toValue(options.firstDayOfWeek) ?? localeFirstDay.value;
+	const fixedWeeks = () => toValue(options.fixedWeeks) ?? false;
+	const includeToday = () => toValue(options.includeToday) ?? false;
+	const field = useOptionalFieldContext();
+	const disabled = () => (toValue(options.disabled) ?? false) || (field?.state.value.disabled ?? false);
+	const readOnly = () => (toValue(options.readOnly) ?? false) || (field?.state.value.readOnly ?? false);
+	const required = () => (toValue(options.required) ?? false) || (field?.required() ?? false);
+	const invalid = () => (toValue(options.invalid) ?? false) || (field?.state.value.invalid ?? false);
+	const min = computed(() => boundary(toValue(options.min)));
+	const max = computed(() => {
+		const given = boundary(toValue(options.max));
+		if (!toValue(options.maxToday)) return given;
+		const today = startOfDay(/* @__PURE__ */ new Date());
+		return given && compareDay(given, today) < 0 ? given : today;
+	});
+	const disabledDates = computed(() => normalizeList(toValue(options.disabledDates)));
+	const value = useControlled({
+		value: () => normalizeValue(toValue(options.value)),
+		defaultValue: () => normalizeValue(toValue(options.defaultValue)) ?? startingPreset() ?? emptyValue(mode()),
+		prop: "modelValue",
+		empty: () => emptyValue(mode()),
+		onChange: (next) => options.onChange?.(next),
+		name: "useCalendar",
+		label: "value"
+	});
+	const filledByPreset = toList(value.value).length === 0 ? startingPreset() : void 0;
+	const selection = shallowRef(toList(value.value));
+	function syncFromValue() {
+		const incoming = toList(value.value);
+		if (!sameDays(incoming, selection.value)) selection.value = incoming;
+	}
+	watch(() => value.value, syncFromValue);
+	function publish(next) {
+		value.value = next;
+		syncFromValue();
+	}
+	if (filledByPreset) publish(filledByPreset);
+	const cursor = ref(clampToBounds(toDate(toValue(options.defaultMonth)) ?? selection.value[0] ?? toList(filledByPreset ?? null)[0] ?? /* @__PURE__ */ new Date()));
+	const view = ref("day");
+	const hovered = shallowRef(null);
+	const gridElement = ref(null);
+	const displayedMonth = computed(() => cursor.value.getMonth());
+	const displayedYear = computed(() => cursor.value.getFullYear());
+	const yearPageStart = computed(() => Math.floor(displayedYear.value / 12) * 12);
+	const months = computed(() => monthNames(locale()));
+	const weekDays = computed(() => weekDayNames(locale(), firstDayOfWeek$1()));
+	const years = computed(() => Array.from({ length: 12 }, (_, index) => yearPageStart.value + index));
+	const dayLabelFormat = computed(() => new Intl.DateTimeFormat(locale(), { dateStyle: "long" }));
+	const weeks = computed(() => {
+		const year = displayedYear.value;
+		const month = displayedMonth.value;
+		const first = new Date(year, month, 1);
+		const offset = (first.getDay() - firstDayOfWeek$1() + DAYS_IN_WEEK) % DAYS_IN_WEEK;
+		const start = subDays(first, offset);
+		const rows = fixedWeeks() ? 6 : Math.ceil((daysInMonth(year, month) + offset) / DAYS_IN_WEEK);
+		return Array.from({ length: rows }, (_, row) => Array.from({ length: DAYS_IN_WEEK }, (_, column) => addDays(start, row * DAYS_IN_WEEK + column)));
+	});
+	const activeRange = computed(() => {
+		if (mode() !== "range") return null;
+		const [first, second] = selection.value;
+		if (first && second) return compareDay(first, second) <= 0 ? [first, second] : [second, first];
+		if (first && hovered.value) return compareDay(first, hovered.value) <= 0 ? [first, hovered.value] : [hovered.value, first];
+		return null;
+	});
+	const selecting = computed(() => mode() === "range" && selection.value.length === 1);
+	const state = computed(() => ({
+		mode: mode(),
+		view: view.value,
+		month: displayedMonth.value,
+		year: displayedYear.value,
+		monthLabel: months.value[displayedMonth.value] ?? "",
+		yearLabel: String(displayedYear.value),
+		selected: selection.value,
+		selecting: selecting.value,
+		empty: selection.value.length === 0,
+		disabled: disabled(),
+		readOnly: readOnly(),
+		required: required(),
+		invalid: invalid()
+	}));
+	useFieldValue(field, () => value.value);
+	watch(() => selection.value.length > 0, (filled) => field?.setFilled(filled), { immediate: true });
+	const hiddenInputs = computed(() => {
+		const name = toValue(options.name) ?? field?.name();
+		if (!name || mode() === "range" && selection.value.length !== 2) return [];
+		const form = toValue(options.form);
+		return [...selection.value].sort(compareDay).map((date) => ({
+			name,
+			value: formatISO(date),
+			form
+		}));
+	});
+	const ROOT_ATTRS = {
+		month: () => null,
+		year: () => null,
+		monthLabel: () => null,
+		yearLabel: () => null,
+		selected: () => null,
+		readOnly: (on) => on ? { "data-readonly": "" } : null
+	};
+	const rootProps = computed(() => ({
+		"data-part": "calendar",
+		...dataAttrs(state.value, ROOT_ATTRS),
+		...field && {
+			role: "group",
+			"aria-labelledby": field.labelledBy.value,
+			"aria-describedby": field.describedBy.value,
+			"aria-required": required() || void 0,
+			"aria-invalid": invalid() || void 0,
+			onFocusin: () => field.setFocused(true),
+			onFocusout(event) {
+				const next = event.relatedTarget;
+				if (next instanceof Node && event.currentTarget.contains(next)) return;
+				field.setFocused(false);
+				field.setTouched(true);
+			}
+		}
+	}));
+	function boundary(input) {
+		const parsed = toDate(input);
+		return parsed ? startOfDay(parsed) : null;
+	}
+	function clampToBounds(date) {
+		return startOfDay(clampDate(date, min.value, max.value));
+	}
+	function isDayDisabled(date) {
+		if (disabled()) return true;
+		if (!isWithin(date, min.value, max.value)) return true;
+		if (disabledDates.value.some((entry) => isSameDay(entry, date))) return true;
+		return options.isDateDisabled?.(date) ?? false;
+	}
+	function pageRange(date, current = view.value) {
+		if (current === "day") return [startOfMonth(date), endOfMonth(date)];
+		if (current === "month") return [startOfYear(date), endOfYear(date)];
+		const start = Math.floor(date.getFullYear() / 12) * 12;
+		return [new Date(start, 0, 1), new Date(start + 12 - 1, 11, 31)];
+	}
+	function setCursor(next) {
+		const clamped = clampToBounds(next);
+		if (!isSameDay(clamped, cursor.value)) cursor.value = clamped;
+	}
+	function focusCursor() {
+		nextTick(() => {
+			const active = document.activeElement;
+			if (!focusInsideGrid() && active !== document.body && active !== null) return;
+			const target = gridElement.value?.querySelector("[data-highlighted]");
+			if (target && target !== active) target.focus();
+		});
+	}
+	function focusInsideGrid() {
+		const grid = gridElement.value;
+		return !!grid && typeof document !== "undefined" && grid.contains(document.activeElement);
+	}
+	watch(cursor, () => {
+		if (focusInsideGrid()) focusCursor();
+	});
+	function select(date) {
+		const day = startOfDay(date);
+		setCursor(day);
+		if (readOnly() || isDayDisabled(day)) return;
+		if (mode() === "single") {
+			publish(day);
+			return;
+		}
+		if (mode() === "multiple") {
+			const without = selection.value.filter((entry) => !isSameDay(entry, day));
+			const next = without.length === selection.value.length ? [...selection.value, day] : without;
+			next.sort(compareDay);
+			publish(next);
+			return;
+		}
+		if (selection.value.length === 1) {
+			const pair = compareDay(selection.value[0], day) <= 0 ? [selection.value[0], day] : [day, selection.value[0]];
+			hovered.value = null;
+			publish(pair);
+			return;
+		}
+		selection.value = [day];
+	}
+	function clear() {
+		publish(emptyValue(mode()));
+	}
+	function completeRange() {
+		if (mode() !== "range" || selection.value.length !== 1) return;
+		const only = selection.value[0];
+		hovered.value = null;
+		publish([only, only]);
+	}
+	function setView(next) {
+		view.value = next;
+	}
+	function step(direction, current = view.value) {
+		if (current === "day") return addMonths(cursor.value, direction);
+		if (current === "month") return addYears(cursor.value, direction);
+		return addYears(cursor.value, direction * 12);
+	}
+	function goto(direction) {
+		const inside = focusInsideGrid();
+		setCursor(step(direction));
+		if (inside) focusCursor();
+	}
+	function canGo(direction) {
+		const [start, end] = pageRange(step(direction));
+		return direction === -1 ? !min.value || compareDay(end, min.value) >= 0 : !max.value || compareDay(start, max.value) <= 0;
+	}
+	function selectMonth(month) {
+		const inside = focusInsideGrid();
+		const year = displayedYear.value;
+		const day = Math.min(cursor.value.getDate(), daysInMonth(year, month));
+		setCursor(new Date(year, month, day));
+		setView("day");
+		if (inside) focusCursor();
+	}
+	function selectYear(year) {
+		const inside = focusInsideGrid();
+		const month = displayedMonth.value;
+		const day = Math.min(cursor.value.getDate(), daysInMonth(year, month));
+		setCursor(new Date(year, month, day));
+		setView("day");
+		if (inside) focusCursor();
+	}
+	function unit(amount) {
+		if (view.value === "day") return addDays(cursor.value, amount);
+		if (view.value === "month") return addMonths(cursor.value, amount);
+		return addYears(cursor.value, amount);
+	}
+	function rowStep() {
+		return view.value === "day" ? DAYS_IN_WEEK : 3;
+	}
+	function rowEdge(edge) {
+		if (view.value === "day") {
+			const offset = (cursor.value.getDay() - firstDayOfWeek$1() + DAYS_IN_WEEK) % DAYS_IN_WEEK;
+			return addDays(cursor.value, edge === "start" ? -offset : DAYS_IN_WEEK - 1 - offset);
+		}
+		if (view.value === "month") return addMonths(cursor.value, edge === "start" ? -displayedMonth.value : MONTHS_IN_YEAR - 1 - displayedMonth.value);
+		const offset = displayedYear.value - yearPageStart.value;
+		return addYears(cursor.value, edge === "start" ? -offset : 11 - offset);
+	}
+	function pageBy(direction, large) {
+		if (view.value === "day") return large ? addYears(cursor.value, direction) : addMonths(cursor.value, direction);
+		if (view.value === "month") return addYears(cursor.value, direction * (large ? 12 : 1));
+		return addYears(cursor.value, direction * 12);
+	}
+	function onKeydown(event) {
+		let next = null;
+		switch (event.key) {
+			case "ArrowLeft":
+				next = unit(-1);
+				break;
+			case "ArrowRight":
+				next = unit(1);
+				break;
+			case "ArrowUp":
+				next = unit(-rowStep());
+				break;
+			case "ArrowDown":
+				next = unit(rowStep());
+				break;
+			case "Home":
+				next = rowEdge("start");
+				break;
+			case "End":
+				next = rowEdge("end");
+				break;
+			case "PageUp":
+				next = pageBy(-1, event.shiftKey);
+				break;
+			case "PageDown":
+				next = pageBy(1, event.shiftKey);
+				break;
+			default: return;
+		}
+		event.preventDefault();
+		setCursor(next);
+		focusCursor();
+	}
+	const gridLabel = computed(() => {
+		if (view.value === "day") return `${state.value.monthLabel} ${displayedYear.value}`;
+		if (view.value === "month") return String(displayedYear.value);
+		return `${yearPageStart.value}–${yearPageStart.value + 12 - 1}`;
+	});
+	const gridProps = computed(() => ({
+		"data-part": "grid",
+		"data-view": view.value,
+		ref: setGridElement,
+		role: "grid",
+		"aria-label": gridLabel.value,
+		"aria-disabled": disabled() || void 0,
+		"aria-readonly": readOnly() || void 0,
+		"aria-multiselectable": mode() === "single" ? void 0 : true,
+		onKeydown,
+		onPointerleave() {
+			hovered.value = null;
+		}
+	}));
+	function setGridElement(element) {
+		gridElement.value = element ?? null;
+	}
+	const rowProps = computed(() => ({
+		"data-part": "row",
+		role: "row"
+	}));
+	const DAY_ATTRS = {
+		date: () => null,
+		rangeStart: (on) => on ? { "data-range-start": "" } : null,
+		rangeEnd: (on) => on ? { "data-range-end": "" } : null,
+		inRange: (on) => on ? { "data-in-range": "" } : null
+	};
+	function getDayState(date) {
+		const range = activeRange.value;
+		const selected = selection.value.some((entry) => isSameDay(entry, date));
+		return {
+			date,
+			selected,
+			rangeStart: !!range && isSameDay(date, range[0]),
+			rangeEnd: !!range && isSameDay(date, range[1]),
+			inRange: !!range && compareDay(date, range[0]) > 0 && compareDay(date, range[1]) < 0,
+			preview: selecting.value && !selected && !!hovered.value && isSameDay(date, hovered.value),
+			outside: !isSameMonth(date, cursor.value),
+			today: isToday(date),
+			weekend: isWeekend(date),
+			disabled: isDayDisabled(date),
+			highlighted: isSameDay(date, cursor.value)
+		};
+	}
+	function getDayProps(date) {
+		const day = getDayState(date);
+		return {
+			"data-part": "day",
+			"data-value": formatISO(date),
+			...dataAttrs(day, DAY_ATTRS),
+			role: "gridcell",
+			type: "button",
+			"aria-disabled": day.disabled || void 0,
+			"aria-selected": day.selected,
+			"aria-current": day.today ? "date" : void 0,
+			"aria-label": dayLabelFormat.value.format(date),
+			tabindex: day.highlighted ? 0 : -1,
+			autofocus: day.highlighted && toValue(options.autofocusDay) || void 0,
+			onClick() {
+				select(date);
+			},
+			onFocus() {
+				setCursor(date);
+			},
+			onPointerenter() {
+				if (!day.disabled) hovered.value = date;
+			}
+		};
+	}
+	function getWeekDayState(index) {
+		const entry = weekDays.value.find((day) => day.index === index) ?? weekDays.value[0];
+		return {
+			...entry,
+			weekend: entry.index === 0 || entry.index === 6
+		};
+	}
+	function getWeekDayProps(index) {
+		const day = getWeekDayState(index);
+		return {
+			"data-part": "week-day",
+			"data-value": day.index,
+			...day.weekend ? { "data-weekend": "" } : null,
+			role: "columnheader",
+			"aria-label": day.long
+		};
+	}
+	function getMonthState(month) {
+		const now = /* @__PURE__ */ new Date();
+		const [start, end] = pageRange(new Date(displayedYear.value, month, 1), "day");
+		return {
+			month,
+			label: months.value[month] ?? "",
+			selected: month === displayedMonth.value,
+			current: month === now.getMonth() && displayedYear.value === now.getFullYear(),
+			disabled: disabled() || !overlapsBounds(start, end),
+			highlighted: month === displayedMonth.value
+		};
+	}
+	function getMonthProps(month) {
+		const item = getMonthState(month);
+		return {
+			"data-part": "month",
+			"data-value": month,
+			...dataAttrs(item, {
+				month: () => null,
+				label: () => null
+			}),
+			role: "gridcell",
+			type: "button",
+			"aria-disabled": item.disabled || void 0,
+			"aria-selected": item.selected,
+			"aria-label": `${item.label} ${displayedYear.value}`,
+			tabindex: item.highlighted ? 0 : -1,
+			onClick() {
+				if (!item.disabled) selectMonth(month);
+			}
+		};
+	}
+	function getYearState(year) {
+		return {
+			year,
+			selected: year === displayedYear.value,
+			current: year === (/* @__PURE__ */ new Date()).getFullYear(),
+			disabled: disabled() || !overlapsBounds(new Date(year, 0, 1), new Date(year, 11, 31)),
+			highlighted: year === displayedYear.value
+		};
+	}
+	function getYearProps(year) {
+		const item = getYearState(year);
+		return {
+			"data-part": "year",
+			"data-value": year,
+			...dataAttrs(item, { year: () => null }),
+			role: "gridcell",
+			type: "button",
+			"aria-disabled": item.disabled || void 0,
+			"aria-selected": item.selected,
+			tabindex: item.highlighted ? 0 : -1,
+			onClick() {
+				if (!item.disabled) selectYear(year);
+			}
+		};
+	}
+	function overlapsBounds(start, end) {
+		if (min.value && compareDay(end, min.value) < 0) return false;
+		if (max.value && compareDay(start, max.value) > 0) return false;
+		return true;
+	}
+	const PAGE_NOUN = {
+		day: "month",
+		month: "year",
+		year: "years"
+	};
+	const prevProps = computed(() => ({
+		"data-part": "prev",
+		type: "button",
+		disabled: disabled() || !canGo(-1) || void 0,
+		"aria-label": `Previous ${PAGE_NOUN[view.value]}`,
+		onClick() {
+			goto(-1);
+		}
+	}));
+	const nextProps = computed(() => ({
+		"data-part": "next",
+		type: "button",
+		disabled: disabled() || !canGo(1) || void 0,
+		"aria-label": `Next ${PAGE_NOUN[view.value]}`,
+		onClick() {
+			goto(1);
+		}
+	}));
+	function getViewTriggerProps(target) {
+		const open = view.value === target;
+		return {
+			"data-part": "view-trigger",
+			"data-view": target,
+			...open ? { "data-open": "" } : null,
+			type: "button",
+			disabled: disabled() || void 0,
+			"aria-expanded": open,
+			onClick() {
+				setView(open ? "day" : target);
+			}
+		};
+	}
+	function resolvePreset(entry) {
+		const option = typeof entry === "string" ? { key: entry } : entry;
+		const raw = option.range ? option.range() : isPresetKey(option.key) ? presetRange(option.key, { includeToday: includeToday() }) : null;
+		if (!raw) return null;
+		const start = toDate(raw[0]);
+		const end = toDate(raw[1]);
+		if (!start || !end) return null;
+		const ordered = compareDay(start, end) <= 0 ? [startOfDay(start), startOfDay(end)] : [startOfDay(end), startOfDay(start)];
+		const notStarted = !option.range && QUARTERS.has(option.key) && compareDay(ordered[0], /* @__PURE__ */ new Date()) > 0;
+		return {
+			key: option.key,
+			label: option.label ?? (isPresetKey(option.key) ? PRESET_LABELS[option.key] : option.key),
+			range: [clampToBounds(ordered[0]), clampToBounds(ordered[1])],
+			disabled: notStarted || !overlapsBounds(ordered[0], ordered[1])
+		};
+	}
+	function presetValue([start, end]) {
+		if (mode() === "range") return [start, end];
+		if (mode() === "multiple") return setDateRange(start, end).filter((day) => !isDayDisabled(day));
+		return start;
+	}
+	function startingPreset() {
+		const key = toValue(options.preset);
+		if (!key) return void 0;
+		const entry = presetList(toValue(options.presets)).find((option) => (typeof option === "string" ? option : option.key) === key) ?? (isPresetKey(key) ? key : void 0);
+		const item = entry && resolvePreset(entry);
+		return item && !item.disabled ? presetValue(item.range) : void 0;
+	}
+	const presets = computed(() => presetList(toValue(options.presets)).flatMap((entry) => {
+		const item = resolvePreset(entry);
+		return item ? [{
+			...item,
+			disabled: disabled() || readOnly() || item.disabled
+		}] : [];
+	}));
+	const presetsProps = computed(() => ({ "data-part": "presets" }));
+	function getPresetState(key) {
+		return presets.value.find((item) => item.key === key);
+	}
+	function getPresetProps(key) {
+		const item = getPresetState(key);
+		return {
+			"data-part": "preset",
+			"data-value": key,
+			...item?.disabled ? { "data-disabled": "" } : null,
+			type: "button",
+			disabled: item?.disabled || void 0,
+			onClick() {
+				applyPreset(key);
+			}
+		};
+	}
+	function applyPreset(key) {
+		const item = getPresetState(key);
+		if (!item || item.disabled) return;
+		publish(presetValue(item.range));
+		hovered.value = null;
+		setView("day");
+		setCursor(item.range[0]);
+	}
+	return {
+		value,
+		state,
+		selection,
+		weeks,
+		weekDays,
+		months,
+		years,
+		presets,
+		rootProps,
+		hiddenInputs,
+		gridProps,
+		rowProps,
+		prevProps,
+		nextProps,
+		presetsProps,
+		getDayProps,
+		getDayState,
+		getWeekDayProps,
+		getWeekDayState,
+		getMonthProps,
+		getMonthState,
+		getYearProps,
+		getYearState,
+		getViewTriggerProps,
+		getPresetProps,
+		getPresetState,
+		select,
+		clear,
+		applyPreset,
+		completeRange,
+		setView,
+		goto,
+		isDayDisabled,
+		cursor
+	};
+}
+function presetList(input) {
+	if (input === void 0) return DEFAULT_PRESETS;
+	const entries = (typeof input === "string" ? [input] : input).flatMap((entry) => entry === "base" || entry === "all" ? PRESET_GROUPS[entry] : [entry]);
+	const seen = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => {
+		const key = typeof entry === "string" ? entry : entry.key;
+		return !seen.has(key) && !!seen.add(key);
+	});
+}
+/** The value as `v-model` writes it back, through its modifiers. */
+function serializeCalendarValue(value, modifiers = {}) {
+	const { iso, safe } = modifiers;
+	if (!iso && !safe) return value;
+	const write = (date) => iso ? safe ? formatSafeISO(date) : formatISO(date) : toDate(formatSafeISO(date));
+	if (value === null) return null;
+	return Array.isArray(value) ? value.map(write) : write(value);
+}
+function normalizeList(input) {
+	if (!input) return [];
+	return input.map((entry) => toDate(entry)).filter((entry) => entry !== null).map(startOfDay);
+}
+function normalizeValue(input) {
+	if (input === void 0) return void 0;
+	if (input === null) return null;
+	if (Array.isArray(input)) return normalizeList(input);
+	const parsed = toDate(input);
+	return parsed ? startOfDay(parsed) : null;
+}
+function emptyValue(mode) {
+	return mode === "single" ? null : [];
+}
+function toList(value) {
+	if (value === null || value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function sameDays(a, b) {
+	return a.length === b.length && a.every((date, index) => isSameDay(date, b[index]));
+}
+var { provideContext: provideCalendarContext, useContext: useCalendarContext } = createContext("Calendar");
+//#endregion
+export { YEARS_PER_PAGE, provideCalendarContext, serializeCalendarValue, useCalendar, useCalendarContext };

package/dist/components/chart/ChartArea.js

@@ -0,0 +1,5 @@
+import ChartArea_vue_vue_type_script_setup_true_lang_default from "./ChartArea.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/chart/ChartArea.vue
+var ChartArea_default = ChartArea_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ChartArea_default as default };

package/dist/components/chart/ChartArea.vue.d.ts

@@ -0,0 +1,23 @@
+import { type ChartCurve } from './ChartRoot.vue';
+type __VLS_Props = {
+    /** The key plotted, read off each row. */
+    yKey: string;
+    /** Its name in the legend, the tooltip and the chart's accessible name. Defaults to `y-key`. */
+    label?: string;
+    /** Defaults to `var(--chart-color-N)`, `N` its place among the chart's series. */
+    color?: string;
+    /** The value scale it reads against. A name of your own puts it on an axis of its own. @default 'y' */
+    scale?: string;
+    /** Formats its value in the tooltip. Defaults to its scale's axis. */
+    format?: (value: any) => string;
+    /** Bend the line through the points, or run it straight. @default 'smooth' */
+    curve?: ChartCurve;
+    /** Mark each row with a dot. */
+    points?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    curve: ChartCurve;
+    scale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;