@astryx-vue/core 0.2.2 → 0.2.3

package/dist/Calendar-CnOsSjMY.js

@@ -0,0 +1,656 @@
+import { t as _sfc_main$1 } from "./VisuallyHidden-C7NN3VEP.js";
+import { t as useAnnounce } from "./announce-Cnio10Wk.js";
+import { c as resolveWeekStart } from "./useDateRange-CIXoE_8k.js";
+import { t as useHandleRef } from "./useHandleRef-6cdKugm8.js";
+import { a as useAstryxMessages, i as useAstryxLocale } from "./context-DmOLCubj.js";
+import { n as standaloneShortWeekdayNames, r as weekdayNames, t as formatCalendarMonth } from "./locale-CCwVnyMZ.js";
+import { t as _sfc_main$2 } from "./Icon-bteSId7T.js";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, nextTick, normalizeClass, openBlock, renderList, renderSlot, shallowRef, toDisplayString, unref, useTemplateRef, watch, withCtx } from "vue";
+import { CalendarDate } from "@internationalized/date";
+import "../styles/calendar.css";
+//#region src/Calendar/calendarDate.ts
+function toCalendarDate(date) {
+	return new CalendarDate(date.getFullYear(), date.getMonth() + 1, date.getDate());
+}
+function fromCalendarDate(date) {
+	return new Date(date.year, date.month - 1, date.day);
+}
+function calendarISO(date) {
+	const month = String(date.month).padStart(2, "0");
+	const day = String(date.day).padStart(2, "0");
+	return `${date.year}-${month}-${day}`;
+}
+function dateISO(date) {
+	return calendarISO(toCalendarDate(date));
+}
+function sameCalendarDay(a, b) {
+	return a.compare(b) === 0;
+}
+function calendarDiffDays(a, b) {
+	const start = Date.UTC(a.year, a.month - 1, a.day);
+	const end = Date.UTC(b.year, b.month - 1, b.day);
+	return Math.round((end - start) / 864e5);
+}
+function monthIndex(date) {
+	return date.year * 12 + date.month;
+}
+function shiftMonth(date, amount) {
+	return new CalendarDate(date.year, date.month, 1).add({ months: amount });
+}
+function weekdayIndex(date) {
+	return date.toDate("UTC").getUTCDay();
+}
+function weekStartIndex(value) {
+	return resolveWeekStart(value);
+}
+/** ISO week number. The Thursday of the week decides the year. */
+function isoWeekNumber(date) {
+	const utc = new Date(Date.UTC(date.year, date.month - 1, date.day));
+	const day = utc.getUTCDay() || 7;
+	utc.setUTCDate(utc.getUTCDate() + 4 - day);
+	const yearStart = Date.UTC(utc.getUTCFullYear(), 0, 1);
+	return Math.ceil(((utc.getTime() - yearStart) / 864e5 + 1) / 7);
+}
+function weekFieldName(locale) {
+	try {
+		const name = new Intl.DisplayNames(locale, { type: "dateTimeField" }).of("weekOfYear");
+		if (name) return name;
+	} catch {}
+	return locale.startsWith("zh") ? "周" : "week";
+}
+function formatWeekdayDate(date, locale) {
+	return new Intl.DateTimeFormat(locale, {
+		weekday: "long",
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	}).format(fromCalendarDate(date));
+}
+/**
+* The month the calendar opens on. An explicit focus date wins, then the
+* selection. Otherwise today is clamped into the min/max window so the first
+* paint is not an all-disabled month.
+*/
+function initialCalendarFocus(options) {
+	if (options.focusDate) return toCalendarDate(options.focusDate);
+	if (options.selected) return toCalendarDate(options.selected);
+	if (options.rangeStart) return toCalendarDate(options.rangeStart);
+	const today = options.today ? toCalendarDate(options.today) : toCalendarDate(/* @__PURE__ */ new Date());
+	const min = options.min ? toCalendarDate(options.min) : null;
+	const max = options.max ? toCalendarDate(options.max) : null;
+	if (min && today.compare(min) < 0) return min;
+	if (max && today.compare(max) > 0) {
+		const shifted = shiftMonth(max, -Math.max(0, options.numberOfMonths - 1));
+		if (min && shifted.compare(new CalendarDate(min.year, min.month, 1)) < 0) return min;
+		return shifted;
+	}
+	return today;
+}
+//#endregion
+//#region src/Calendar/useCalendarConstraints.ts
+/**
+* Bounds, custom constraints, and an in-progress range span.
+* Span counts both endpoints, so a max of 7 reaches six days either side of the anchor.
+* The anchor itself stays enabled so the start can be moved or cancelled.
+*/
+function isCalendarDateDisabled(date, input) {
+	const min = input.min ? toCalendarDate(input.min) : null;
+	const max = input.max ? toCalendarDate(input.max) : null;
+	if (min && date.compare(min) < 0) return true;
+	if (max && date.compare(max) > 0) return true;
+	const anchor = input.rangeAnchor;
+	if (anchor) {
+		const distance = Math.abs(calendarDiffDays(anchor, date));
+		if (input.maxRangeSpan != null && distance > input.maxRangeSpan - 1) return true;
+		if (input.minRangeSpan != null && distance > 0 && distance < input.minRangeSpan - 1) return true;
+	}
+	const jsDate = fromCalendarDate(date);
+	if (input.isDateDisabled?.(jsDate)) return true;
+	if (input.dateConstraints?.some((constraint) => !constraint(jsDate))) return true;
+	return false;
+}
+function isOutsideCalendarBounds(date, min, max) {
+	const earliest = min ? toCalendarDate(min) : null;
+	const latest = max ? toCalendarDate(max) : null;
+	if (earliest && date.compare(earliest) < 0) return true;
+	if (latest && date.compare(latest) > 0) return true;
+	return false;
+}
+//#endregion
+//#region src/Calendar/useCalendarGrid.ts
+function buildCalendarWeeks(year, month, weekStartsOn = 0, variableRows = false) {
+	const first = new CalendarDate(year, month, 1);
+	const offset = (weekdayIndex(first) - weekStartsOn + 7) % 7;
+	const daysInMonth = first.add({ months: 1 }).subtract({ days: 1 }).day;
+	const rows = variableRows ? Math.ceil((daysInMonth + offset) / 7) : 6;
+	let cursor = first.subtract({ days: offset });
+	const weeks = [];
+	for (let row = 0; row < rows; row += 1) {
+		const days = [];
+		for (let column = 0; column < 7; column += 1) {
+			days.push({
+				date: cursor,
+				iso: calendarISO(cursor),
+				outside: cursor.month !== month || cursor.year !== year,
+				day: cursor.day
+			});
+			cursor = cursor.add({ days: 1 });
+		}
+		const anchor = days.find((day) => !day.outside)?.date ?? days[0].date;
+		weeks.push({
+			number: isoWeekNumber(anchor),
+			days
+		});
+	}
+	return weeks;
+}
+function firstEnabledDay(year, month, isDisabled) {
+	const total = new CalendarDate(year, month, 1).add({ months: 1 }).subtract({ days: 1 }).day;
+	for (let day = 1; day <= total; day += 1) {
+		const date = new CalendarDate(year, month, day);
+		if (!isDisabled(date)) return date;
+	}
+	return null;
+}
+//#endregion
+//#region src/Calendar/useCalendarKeyboard.ts
+function startOfWeek(date, weekStartsOn) {
+	const delta = (weekdayIndex(date) - weekStartsOn + 7) % 7;
+	return date.subtract({ days: delta });
+}
+function viewFor(target, input) {
+	const targetMonth = monthIndex(target);
+	const first = input.viewYear * 12 + input.viewMonth;
+	const last = first + input.numberOfMonths - 1;
+	if (targetMonth >= first && targetMonth <= last) return void 0;
+	if (targetMonth < first) return new CalendarDate(target.year, target.month, 1);
+	return shiftMonth({
+		year: target.year,
+		month: target.month
+	}, -(input.numberOfMonths - 1));
+}
+function walk(focused, step, input) {
+	let candidate = focused.add({ days: step });
+	while (Math.abs(calendarDiffDays(focused, candidate)) <= 366) {
+		if (input.isOutOfBounds(candidate)) return null;
+		if (!input.isDisabled(candidate)) return candidate;
+		candidate = candidate.add({ days: step });
+	}
+	return null;
+}
+function page(focused, delta, input) {
+	const candidate = focused.add({ months: delta });
+	if (input.isOutOfBounds(candidate)) return null;
+	if (!input.isDisabled(candidate)) return candidate;
+	return firstEnabledDay(candidate.year, candidate.month, (date) => input.isDisabled(date) || input.isOutOfBounds(date));
+}
+function weekEdge(focused, edge, input) {
+	const start = startOfWeek(focused, input.weekStartsOn);
+	const days = Array.from({ length: 7 }, (_, index) => start.add({ days: index })).filter((date) => date.year === focused.year && date.month === focused.month).filter((date) => !input.isDisabled(date) && !input.isOutOfBounds(date));
+	if (days.length === 0) return null;
+	return edge === "home" ? days[0] : days[days.length - 1];
+}
+/** Where an arrow, Home, End, or Page key should land. Null means the focus stays put. */
+function resolveCalendarKey(input) {
+	const { key, focused } = input;
+	let target = null;
+	if (key === "Home" || key === "End") target = weekEdge(focused, key === "Home" ? "home" : "end", input);
+	else if (key === "PageUp" || key === "PageDown") target = page(focused, key === "PageDown" ? 1 : -1, input);
+	else if (key === "ArrowLeft" || key === "ArrowRight" || key === "ArrowUp" || key === "ArrowDown") {
+		const horizontal = key === "ArrowLeft" || key === "ArrowRight";
+		let direction = key === "ArrowRight" || key === "ArrowDown" ? 1 : -1;
+		if (input.rtl && horizontal) direction = -direction;
+		target = walk(focused, horizontal ? direction : direction * 7, input);
+	} else return null;
+	if (!target || target.compare(focused) === 0) return null;
+	return {
+		date: target,
+		view: viewFor(target, input)
+	};
+}
+//#endregion
+//#region src/Calendar/Calendar.vue
+const _hoisted_1 = [
+	"data-months",
+	"data-mode",
+	"data-week-numbers",
+	"aria-label"
+];
+const _hoisted_2 = { class: "astryx-calendar-header" };
+const _hoisted_3 = ["disabled", "aria-label"];
+const _hoisted_4 = { class: "astryx-calendar-month-year" };
+const _hoisted_5 = ["disabled", "aria-label"];
+const _hoisted_6 = { class: "astryx-calendar-months" };
+const _hoisted_7 = [
+	"aria-label",
+	"aria-multiselectable",
+	"data-week-numbers"
+];
+const _hoisted_8 = {
+	class: "astryx-calendar-weekdays",
+	role: "row"
+};
+const _hoisted_9 = {
+	key: 0,
+	class: "astryx-calendar-weekday",
+	role: "columnheader"
+};
+const _hoisted_10 = ["aria-label"];
+const _hoisted_11 = {
+	key: 0,
+	class: "astryx-calendar-week-number",
+	role: "rowheader"
+};
+const _hoisted_12 = ["aria-selected"];
+const _hoisted_13 = [
+	"data-date",
+	"tabindex",
+	"aria-disabled",
+	"aria-current",
+	"aria-label",
+	"onClick",
+	"onMouseenter",
+	"onFocus"
+];
+const _hoisted_14 = { class: "astryx-calendar-day" };
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	name: "AstryxCalendar",
+	__name: "Calendar",
+	props: {
+		modelValue: { default: null },
+		mode: { default: "single" },
+		range: { default: null },
+		numberOfMonths: { default: 1 },
+		focusDate: {},
+		min: {},
+		max: {},
+		isDateDisabled: {},
+		dateConstraints: {},
+		minRangeSpan: { default: 1 },
+		maxRangeSpan: {},
+		hasOutsideDays: {
+			type: Boolean,
+			default: true
+		},
+		hasWeekNumbers: {
+			type: Boolean,
+			default: false
+		},
+		hasVariableRowCount: {
+			type: Boolean,
+			default: false
+		},
+		weekStartsOn: { default: 0 },
+		handleRef: {},
+		label: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"update:range",
+		"update:focusDate",
+		"change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const locale = useAstryxLocale();
+		const messages = useAstryxMessages();
+		const announce = useAnnounce();
+		const rootRef = useTemplateRef("root");
+		const monthCount = computed(() => props.numberOfMonths === 2 ? 2 : 1);
+		const weekStart = computed(() => weekStartIndex(props.weekStartsOn));
+		const todayDate = toCalendarDate(/* @__PURE__ */ new Date());
+		const pending = shallowRef(null);
+		const hover = shallowRef(null);
+		const opened = initialCalendarFocus({
+			focusDate: props.focusDate,
+			selected: props.mode === "single" ? props.modelValue : null,
+			rangeStart: props.range?.start ?? null,
+			min: props.min,
+			max: props.max,
+			numberOfMonths: monthCount.value,
+			today: fromCalendarDate(todayDate)
+		});
+		const view = shallowRef(shiftMonth(opened, 0));
+		const focused = shallowRef(opened);
+		const rtl = computed(() => {
+			if (typeof document !== "undefined" && document.documentElement.dir === "rtl") return true;
+			return /^(?:ar|he|fa|ur)\b/i.test(locale.value);
+		});
+		const resolvedLabel = computed(() => props.label ?? messages.value.calendar.label);
+		const weekName = computed(() => weekFieldName(locale.value));
+		const headers = computed(() => {
+			const short = standaloneShortWeekdayNames(locale.value);
+			const long = weekdayNames(locale.value, "long");
+			const start = weekStart.value;
+			return Array.from({ length: 7 }, (_, index) => ({
+				short: short[(index + start) % 7],
+				long: long[(index + start) % 7]
+			}));
+		});
+		function constraints() {
+			return {
+				min: props.min,
+				max: props.max,
+				isDateDisabled: props.isDateDisabled,
+				dateConstraints: props.dateConstraints,
+				minRangeSpan: props.mode === "range" ? props.minRangeSpan : void 0,
+				maxRangeSpan: props.mode === "range" ? props.maxRangeSpan : void 0,
+				rangeAnchor: props.mode === "range" ? pending.value : null
+			};
+		}
+		function blocked(date) {
+			return isCalendarDateDisabled(date, constraints());
+		}
+		function visible(date) {
+			const start = view.value.year * 12 + view.value.month;
+			const index = date.year * 12 + date.month;
+			return index >= start && index < start + monthCount.value;
+		}
+		function seed(month) {
+			const candidates = [];
+			if (props.mode === "single" && props.modelValue) candidates.push(toCalendarDate(props.modelValue));
+			candidates.push(todayDate);
+			for (const date of candidates) if (date.year === month.year && date.month === month.month && !blocked(date)) return date;
+			for (const week of buildCalendarWeeks(month.year, month.month, weekStart.value, false)) for (const day of week.days) if (!day.outside && !blocked(day.date)) return day.date;
+			return shiftMonth(month, 0);
+		}
+		focused.value = seed(view.value);
+		const months = computed(() => Array.from({ length: monthCount.value }, (_, index) => {
+			const cursor = shiftMonth(view.value, index);
+			return {
+				year: cursor.year,
+				month: cursor.month,
+				label: formatCalendarMonth(cursor.year, cursor.month, locale.value),
+				weeks: buildCalendarWeeks(cursor.year, cursor.month, weekStart.value, props.hasVariableRowCount)
+			};
+		}));
+		const headerLabel = computed(() => months.value.map((month) => month.label).join(" – "));
+		const canPrevious = computed(() => {
+			if (!props.min) return true;
+			const min = toCalendarDate(props.min);
+			return min.year < view.value.year || min.year === view.value.year && min.month < view.value.month;
+		});
+		const canNext = computed(() => {
+			if (!props.max) return true;
+			const max = toCalendarDate(props.max);
+			const last = shiftMonth(view.value, monthCount.value - 1);
+			return max.year > last.year || max.year === last.year && max.month > last.month;
+		});
+		const selectedSingle = computed(() => props.mode === "single" && props.modelValue ? toCalendarDate(props.modelValue) : null);
+		const committedStart = computed(() => props.mode === "range" && props.range?.start ? toCalendarDate(props.range.start) : null);
+		const committedEnd = computed(() => props.mode === "range" && props.range?.end ? toCalendarDate(props.range.end) : null);
+		const preview = computed(() => {
+			if (!pending.value || !hover.value || sameCalendarDay(pending.value, hover.value)) return null;
+			if (blocked(hover.value)) return null;
+			return pending.value.compare(hover.value) <= 0 ? {
+				start: pending.value,
+				end: hover.value
+			} : {
+				start: hover.value,
+				end: pending.value
+			};
+		});
+		const visualStart = computed(() => preview.value?.start ?? pending.value ?? committedStart.value);
+		const visualEnd = computed(() => preview.value?.end ?? (pending.value ? null : committedEnd.value));
+		function setView(next, keep) {
+			view.value = shiftMonth(next, 0);
+			emit("update:focusDate", fromCalendarDate(view.value));
+			if (keep) focused.value = keep;
+			else if (!visible(focused.value)) focused.value = seed(view.value);
+		}
+		function focusStop() {
+			nextTick(() => {
+				rootRef.value?.querySelector(".astryx-calendar-cell[tabindex=\"0\"]")?.focus();
+			});
+		}
+		function shift(amount) {
+			if (props.disabled) return;
+			if (amount < 0 && !canPrevious.value) return;
+			if (amount > 0 && !canNext.value) return;
+			setView(shiftMonth(view.value, amount));
+			focusStop();
+		}
+		function navigateTo(date) {
+			const target = toCalendarDate(date);
+			setView(target, blocked(target) ? seed(target) : target);
+			focusStop();
+		}
+		const handle = { navigateTo };
+		useHandleRef(() => props.handleRef, handle);
+		__expose(handle);
+		watch(() => props.focusDate ? dateISO(props.focusDate) : "", (iso) => {
+			if (!iso || !props.focusDate) return;
+			const next = toCalendarDate(props.focusDate);
+			if (next.year === view.value.year && next.month === view.value.month) return;
+			view.value = shiftMonth(next, 0);
+			if (!visible(focused.value)) focused.value = seed(view.value);
+		});
+		watch(headerLabel, (label) => announce(label));
+		function inSpan(date, start, end) {
+			return !!start && !!end && date.compare(start) >= 0 && date.compare(end) <= 0;
+		}
+		function paint(week) {
+			const start = visualStart.value;
+			const end = visualEnd.value;
+			return week.days.map((day, index) => {
+				const outside = day.outside;
+				const disabled = outside || blocked(day.date);
+				const continues = !outside && !blocked(day.date) && inSpan(day.date, start, end);
+				const previous = index > 0 ? week.days[index - 1] : null;
+				const next = index < 6 ? week.days[index + 1] : null;
+				const previousContinues = !!previous && !previous.outside && !blocked(previous.date) && inSpan(previous.date, start, end);
+				const nextContinues = !!next && !next.outside && !blocked(next.date) && inSpan(next.date, start, end);
+				const isStart = !!start && !outside && sameCalendarDay(day.date, start);
+				const isEnd = !!end && !outside && sameCalendarDay(day.date, end);
+				const selected = !outside && (props.mode === "single" && !!selectedSingle.value && sameCalendarDay(day.date, selectedSingle.value) || isStart || isEnd);
+				const named = formatWeekdayDate(day.date, locale.value);
+				let label = named;
+				if (props.mode === "range" && isStart && isEnd) label = messages.value.calendar.rangeBoth(named);
+				else if (props.mode === "range" && isStart) label = messages.value.calendar.rangeStartName(named);
+				else if (props.mode === "range" && isEnd) label = messages.value.calendar.rangeEndName(named);
+				return {
+					iso: day.iso,
+					date: day.date,
+					text: day.day,
+					outside,
+					shown: props.hasOutsideDays || !outside,
+					disabled,
+					selected,
+					inRange: continues && !isStart && !isEnd,
+					rangeStart: isStart,
+					rangeEnd: isEnd,
+					today: !outside && sameCalendarDay(day.date, todayDate),
+					tab: !outside && !props.disabled && sameCalendarDay(day.date, focused.value),
+					roundStart: continues && (isStart || index === 0 || !previousContinues),
+					roundEnd: continues && (isEnd || index === 6 || !nextContinues),
+					label
+				};
+			});
+		}
+		function pick(date) {
+			if (props.disabled || blocked(date)) return;
+			focused.value = date;
+			if (props.mode !== "range") {
+				const value = fromCalendarDate(date);
+				emit("update:modelValue", value);
+				emit("change", value);
+				return;
+			}
+			if (!pending.value) {
+				pending.value = date;
+				const value = fromCalendarDate(date);
+				emit("update:range", {
+					start: value,
+					end: null
+				});
+				emit("change", value);
+				announce(messages.value.calendar.rangeStart(formatWeekdayDate(date, locale.value)));
+				return;
+			}
+			if (sameCalendarDay(date, pending.value) && props.minRangeSpan > 1) {
+				pending.value = null;
+				hover.value = null;
+				emit("update:range", {
+					start: null,
+					end: null
+				});
+				emit("change", null);
+				announce(messages.value.calendar.rangeCleared(formatWeekdayDate(date, locale.value)));
+				return;
+			}
+			const start = pending.value.compare(date) <= 0 ? pending.value : date;
+			const end = pending.value.compare(date) <= 0 ? date : pending.value;
+			pending.value = null;
+			hover.value = null;
+			const value = {
+				start: fromCalendarDate(start),
+				end: fromCalendarDate(end)
+			};
+			emit("update:range", value);
+			emit("change", value.end);
+			announce(messages.value.calendar.rangeComplete(formatWeekdayDate(start, locale.value), formatWeekdayDate(end, locale.value)));
+		}
+		function onKeyDown(event) {
+			if (props.disabled) return;
+			if (event.key === "Escape" && pending.value) {
+				event.preventDefault();
+				event.stopPropagation();
+				const date = pending.value;
+				pending.value = null;
+				hover.value = null;
+				emit("update:range", {
+					start: null,
+					end: null
+				});
+				announce(messages.value.calendar.rangeCleared(formatWeekdayDate(date, locale.value)));
+				return;
+			}
+			if (event.key === "Enter" || event.key === " ") {
+				event.preventDefault();
+				if (!blocked(focused.value)) pick(focused.value);
+				return;
+			}
+			const move = resolveCalendarKey({
+				key: event.key,
+				rtl: rtl.value,
+				focused: focused.value,
+				weekStartsOn: weekStart.value,
+				numberOfMonths: monthCount.value,
+				viewYear: view.value.year,
+				viewMonth: view.value.month,
+				isOutOfBounds: (date) => isOutsideCalendarBounds(date, props.min, props.max),
+				isDisabled: (date) => isCalendarDateDisabled(date, constraints())
+			});
+			if (!move) return;
+			event.preventDefault();
+			if (move.view) setView(move.view, move.date);
+			else focused.value = move.date;
+			focusStop();
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref: "root",
+				class: normalizeClass(["astryx-calendar", { "is-disabled": __props.disabled }]),
+				"data-months": monthCount.value,
+				"data-mode": __props.mode,
+				"data-week-numbers": __props.hasWeekNumbers || void 0,
+				"aria-label": resolvedLabel.value
+			}, [createElementVNode("div", _hoisted_2, [renderSlot(_ctx.$slots, "header", {}, () => [
+				createElementVNode("button", {
+					type: "button",
+					class: "astryx-calendar-nav-button",
+					disabled: __props.disabled || !canPrevious.value,
+					"aria-label": unref(messages).calendar.previousMonth,
+					onClick: _cache[0] || (_cache[0] = ($event) => shift(-1))
+				}, [createVNode(_sfc_main$2, {
+					icon: "chevronLeft",
+					size: "sm"
+				})], 8, _hoisted_3),
+				createElementVNode("span", _hoisted_4, toDisplayString(headerLabel.value), 1),
+				createElementVNode("button", {
+					type: "button",
+					class: "astryx-calendar-nav-button",
+					disabled: __props.disabled || !canNext.value,
+					"aria-label": unref(messages).calendar.nextMonth,
+					onClick: _cache[1] || (_cache[1] = ($event) => shift(1))
+				}, [createVNode(_sfc_main$2, {
+					icon: "chevronRight",
+					size: "sm"
+				})], 8, _hoisted_5)
+			])]), createElementVNode("div", _hoisted_6, [(openBlock(true), createElementBlock(Fragment, null, renderList(months.value, (month) => {
+				return openBlock(), createElementBlock("section", {
+					key: `${month.year}-${month.month}`,
+					class: "astryx-calendar-month"
+				}, [createElementVNode("div", {
+					class: "astryx-calendar-grid",
+					role: "grid",
+					"aria-label": month.label,
+					"aria-multiselectable": __props.mode === "range" ? "true" : void 0,
+					"data-week-numbers": __props.hasWeekNumbers || void 0,
+					tabindex: "-1",
+					onKeydown: onKeyDown
+				}, [createElementVNode("div", _hoisted_8, [__props.hasWeekNumbers ? (openBlock(), createElementBlock("div", _hoisted_9, [createVNode(_sfc_main$1, null, {
+					default: withCtx(() => [createTextVNode(toDisplayString(weekName.value), 1)]),
+					_: 1
+				})])) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(Fragment, null, renderList(headers.value, (day) => {
+					return openBlock(), createElementBlock("div", {
+						key: day.long,
+						class: "astryx-calendar-weekday",
+						role: "columnheader",
+						"aria-label": day.long
+					}, toDisplayString(day.short), 9, _hoisted_10);
+				}), 128))]), (openBlock(true), createElementBlock(Fragment, null, renderList(month.weeks, (week, rowIndex) => {
+					return openBlock(), createElementBlock("div", {
+						key: `${month.year}-${month.month}-${rowIndex}`,
+						class: "astryx-calendar-row",
+						role: "row"
+					}, [__props.hasWeekNumbers ? (openBlock(), createElementBlock("div", _hoisted_11, toDisplayString(week.number), 1)) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(Fragment, null, renderList(paint(week), (day) => {
+						return openBlock(), createElementBlock("div", {
+							key: day.iso,
+							class: "astryx-calendar-gridcell",
+							role: "gridcell",
+							"aria-selected": day.selected || day.inRange
+						}, [day.shown ? (openBlock(), createElementBlock("button", {
+							key: 0,
+							type: "button",
+							class: normalizeClass(["astryx-calendar-cell", {
+								"is-selected": day.selected,
+								"is-range-start": day.rangeStart,
+								"is-range-end": day.rangeEnd,
+								"is-in-range": day.inRange,
+								"is-round-start": day.roundStart,
+								"is-round-end": day.roundEnd,
+								"is-disabled": day.disabled,
+								"is-today": day.today,
+								"is-other-month": day.outside
+							}]),
+							"data-date": day.iso,
+							tabindex: day.tab ? 0 : -1,
+							"aria-disabled": day.disabled || void 0,
+							"aria-current": day.today ? "date" : void 0,
+							"aria-label": day.label,
+							onClick: ($event) => day.outside ? void 0 : pick(day.date),
+							onMouseenter: ($event) => hover.value = day.outside || day.disabled ? null : day.date,
+							onMouseleave: _cache[2] || (_cache[2] = ($event) => hover.value = null),
+							onBlur: _cache[3] || (_cache[3] = ($event) => hover.value = null),
+							onFocus: ($event) => focused.value = day.outside ? focused.value : day.date
+						}, [renderSlot(_ctx.$slots, "day", {
+							date: day.date,
+							isSelected: day.selected,
+							isDisabled: day.disabled,
+							isToday: day.today,
+							isInMonth: !day.outside
+						}, () => [createElementVNode("span", _hoisted_14, toDisplayString(day.text), 1)])], 42, _hoisted_13)) : createCommentVNode("v-if", true)], 8, _hoisted_12);
+					}), 128))]);
+				}), 128))], 40, _hoisted_7)]);
+			}), 128))])], 10, _hoisted_1);
+		};
+	}
+});
+//#endregion
+export { isCalendarDateDisabled as n, toCalendarDate as r, _sfc_main as t };

package/dist/Card/index.d.ts

@@ -1,2 +1,2 @@
-import { a as CardSlots, i as CardSizeValue, n as CardElevation, o as CardVariant, r as CardProps, t as _default } from "../index-D_nYxnNv.js";
+import { a as CardSlots, i as CardSizeValue, n as CardElevation, o as CardVariant, r as CardProps, t as _default } from "../index-D7-WTV6I.js";
 export { _default as Card, type CardElevation, type CardProps, type CardSizeValue, type CardSlots, type CardVariant };

package/dist/Carousel/index.js

@@ -1,2 +1,2 @@
-import { t as _sfc_main } from "../Carousel-X0cuQkvg.js";
+import { t as _sfc_main } from "../Carousel-JA7ilqI_.js";
 export { _sfc_main as Carousel };

package/dist/{Carousel-X0cuQkvg.js → Carousel-JA7ilqI_.js}

@@ -1,6 +1,6 @@
-import { a as useAstryxMessages } from "./context-CiKncNSH.js";
+import { a as useAstryxMessages } from "./context-DmOLCubj.js";
 import { t as _sfc_main$1 } from "./IconButton-BNQuz9W_.js";
-import { t as _sfc_main$2 } from "./Icon-CJKjdJy-.js";
+import { t as _sfc_main$2 } from "./Icon-bteSId7T.js";
 import { Comment, Fragment, Text, computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, unref, useSlots, watch, withCtx } from "vue";
 import "../styles/carousel.css";
 //#region src/Carousel/slides.ts