ropav 0.2.0 → 0.3.0

package/dist/calendar.js

@@ -1,739 +0,0 @@
-import './calendar.css';
-import { t as useControllableValue } from "./useControllableValue.js";
-import { t as useStylesApi } from "./styles-api.js";
-import { n as toPresenceAttribute } from "./attributes.js";
-import { t as bem } from "./bem.js";
-import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
-import { t as chevron_left_default } from "./chevron-left.js";
-import { t as chevron_right_default } from "./chevron-right.js";
-import { child, computed, createComponent, createFor, createIf, createSlot, defineVaporComponent, next, nextTick, on, onBeforeUnmount, onMounted, ref, renderEffect, setDynamicProps, setInsertionState, setStaticTemplateRef, setText, shallowRef, template, toDisplayString, txt, unref, useId, watch } from "vue";
-//#region src/utils/date.ts
-function isValidDate(value) {
-	return value instanceof Date && Number.isFinite(value.getTime());
-}
-function toLocalDate(value) {
-	return new Date(value.getFullYear(), value.getMonth(), value.getDate());
-}
-function normalizeDate(value) {
-	return isValidDate(value) ? toLocalDate(value) : null;
-}
-function toDateKey(value) {
-	return `${String(value.getFullYear()).padStart(4, "0")}-${String(value.getMonth() + 1).padStart(2, "0")}-${String(value.getDate()).padStart(2, "0")}`;
-}
-function parseDateKey(value) {
-	const match = /^(\d{4,})-(\d{2})-(\d{2})$/.exec(value);
-	if (!match) return null;
-	const year = Number(match[1]);
-	const month = Number(match[2]) - 1;
-	const day = Number(match[3]);
-	const parsed = new Date(year, month, day);
-	if (parsed.getFullYear() !== year || parsed.getMonth() !== month || parsed.getDate() !== day) return null;
-	return parsed;
-}
-function compareDates(left, right) {
-	return toLocalDate(left).getTime() - toLocalDate(right).getTime();
-}
-function isSameDate(left, right) {
-	return Boolean(left && right && compareDates(left, right) === 0);
-}
-function isSameMonth(left, right) {
-	return left.getFullYear() === right.getFullYear() && left.getMonth() === right.getMonth();
-}
-function startOfMonth(value) {
-	return new Date(value.getFullYear(), value.getMonth(), 1);
-}
-function endOfMonth(value) {
-	return new Date(value.getFullYear(), value.getMonth() + 1, 0);
-}
-function addCalendarDays(value, amount) {
-	return new Date(value.getFullYear(), value.getMonth(), value.getDate() + amount);
-}
-function addCalendarMonths(value, amount) {
-	const day = value.getDate();
-	const result = new Date(value.getFullYear(), value.getMonth() + amount, 1);
-	result.setDate(Math.min(day, endOfMonth(result).getDate()));
-	return result;
-}
-function addCalendarYears(value, amount) {
-	const result = new Date(value.getFullYear() + amount, value.getMonth(), 1);
-	result.setDate(Math.min(value.getDate(), endOfMonth(result).getDate()));
-	return result;
-}
-//#endregion
-//#region src/utils/dateAvailability.ts
-function isDateUnavailable(date, options) {
-	const min = normalizeDate(options.min);
-	const max = normalizeDate(options.max);
-	if (min && compareDates(date, min) < 0) return true;
-	if (max && compareDates(date, max) > 0) return true;
-	if (typeof options.disabledDates === "function") return options.disabledDates(toLocalDate(date));
-	return options.disabledDates?.some((disabledDate) => isSameDate(disabledDate, date)) ?? false;
-}
-//#endregion
-//#region src/components/calendar/calendarBehavior.ts
-function normalizeFirstDayOfWeek(value) {
-	if (!Number.isFinite(value)) return 0;
-	return (Math.trunc(value) % 7 + 7) % 7;
-}
-function createCalendarDays(options, firstDayOfWeek) {
-	const month = startOfMonth(options.month);
-	const leadingDays = (month.getDay() - firstDayOfWeek + 7) % 7;
-	const gridStart = addCalendarDays(month, -leadingDays);
-	const requiredDays = leadingDays + endOfMonth(month).getDate();
-	const dayCount = options.fixedWeeks ?? true ? 42 : Math.ceil(requiredDays / 7) * 7;
-	const dayFormatter = new Intl.DateTimeFormat(options.locale, {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	});
-	return Array.from({ length: dayCount }, (_, index) => {
-		const date = addCalendarDays(gridStart, index);
-		const outside = !isSameMonth(date, month);
-		return {
-			date,
-			key: toDateKey(date),
-			label: date.getDate(),
-			ariaLabel: dayFormatter.format(date),
-			outside,
-			hidden: outside && Boolean(options.hideOutsideDates),
-			selected: isSameDate(date, options.selectedDate),
-			today: isSameDate(date, options.today),
-			disabled: isDateUnavailable(date, options)
-		};
-	});
-}
-function createCalendarWeeks(days) {
-	const weeks = [];
-	for (let index = 0; index < days.length; index += 7) weeks.push(days.slice(index, index + 7));
-	return weeks;
-}
-function getCalendarWeekdays(locale, firstDayOfWeek, format) {
-	const shortFormatter = new Intl.DateTimeFormat(locale, {
-		weekday: format,
-		timeZone: "UTC"
-	});
-	const longFormatter = new Intl.DateTimeFormat(locale, {
-		weekday: "long",
-		timeZone: "UTC"
-	});
-	return Array.from({ length: 7 }, (_, index) => {
-		const weekday = (firstDayOfWeek + index) % 7;
-		const date = new Date(Date.UTC(2021, 7, 1 + weekday));
-		return {
-			key: weekday,
-			label: shortFormatter.format(date),
-			ariaLabel: longFormatter.format(date)
-		};
-	});
-}
-function monthHasSelectableDate(month, availability) {
-	const first = startOfMonth(month);
-	const last = endOfMonth(month);
-	for (let date = first; date <= last; date = addCalendarDays(date, 1)) if (!isDateUnavailable(date, availability)) return true;
-	return false;
-}
-function monthIntersectsBounds(month, availability) {
-	const min = normalizeDate(availability.min);
-	const max = normalizeDate(availability.max);
-	return (!min || compareDates(endOfMonth(month), min) >= 0) && (!max || compareDates(startOfMonth(month), max) <= 0);
-}
-function findNavigableMonth(requestedMonth, direction, availability) {
-	const min = normalizeDate(availability.min);
-	const max = normalizeDate(availability.max);
-	const hasDirectionalBound = direction === 1 ? Boolean(max) : Boolean(min);
-	let candidate = startOfMonth(requestedMonth);
-	if (direction === 1 && min && compareDates(endOfMonth(candidate), min) < 0) candidate = startOfMonth(min);
-	else if (direction === -1 && max && compareDates(startOfMonth(candidate), max) > 0) candidate = startOfMonth(max);
-	while (monthIntersectsBounds(candidate, availability)) {
-		if (monthHasSelectableDate(candidate, availability)) return candidate;
-		const followingMonth = addCalendarMonths(candidate, direction);
-		if (!monthIntersectsBounds(followingMonth, availability)) return null;
-		if (typeof availability.disabledDates === "function" && !hasDirectionalBound) return candidate;
-		candidate = followingMonth;
-	}
-	return null;
-}
-function findEnabledDate(search) {
-	let current = search.candidate;
-	for (let index = 0; index < 3660; index += 1) {
-		if (search.min && compareDates(current, search.min) < 0) return null;
-		if (search.max && compareDates(current, search.max) > 0) return null;
-		if (!isDateUnavailable(current, search.availability)) return current;
-		current = addCalendarDays(current, search.direction);
-	}
-	return null;
-}
-function findEnabledDateInMonth(candidate, direction, availability) {
-	const min = startOfMonth(candidate);
-	const max = endOfMonth(candidate);
-	return findEnabledDate({
-		candidate,
-		direction,
-		min,
-		max,
-		availability
-	}) ?? findEnabledDate({
-		candidate: addCalendarDays(candidate, -direction),
-		direction: direction === 1 ? -1 : 1,
-		min,
-		max,
-		availability
-	});
-}
-function getPreferredDateForMonth(options) {
-	const month = startOfMonth(options.month);
-	const selected = options.selectedDate;
-	if (selected && isSameMonth(selected, month) && !isDateUnavailable(selected, options.availability)) return selected;
-	if (isSameMonth(options.today, month) && !isDateUnavailable(options.today, options.availability)) return options.today;
-	return findEnabledDateInMonth(new Date(month.getFullYear(), month.getMonth(), Math.min(options.anchor.getDate(), endOfMonth(month).getDate())), options.direction, options.availability);
-}
-function getKeyboardTarget(action, firstDayOfWeek, availability) {
-	switch (action.key) {
-		case "ArrowLeft": return findEnabledDate({
-			candidate: addCalendarDays(action.date, -1),
-			direction: -1,
-			availability
-		});
-		case "ArrowRight": return findEnabledDate({
-			candidate: addCalendarDays(action.date, 1),
-			direction: 1,
-			availability
-		});
-		case "ArrowUp": return findEnabledDate({
-			candidate: addCalendarDays(action.date, -7),
-			direction: -1,
-			availability
-		});
-		case "ArrowDown": return findEnabledDate({
-			candidate: addCalendarDays(action.date, 7),
-			direction: 1,
-			availability
-		});
-		case "Home": {
-			const offset = (action.date.getDay() - firstDayOfWeek + 7) % 7;
-			const min = addCalendarDays(action.date, -offset);
-			return findEnabledDate({
-				candidate: min,
-				direction: 1,
-				min,
-				max: addCalendarDays(min, 6),
-				availability
-			});
-		}
-		case "End": {
-			const offset = (firstDayOfWeek + 6 - action.date.getDay() + 7) % 7;
-			const max = addCalendarDays(action.date, offset);
-			return findEnabledDate({
-				candidate: max,
-				direction: -1,
-				min: addCalendarDays(max, -6),
-				max,
-				availability
-			});
-		}
-		case "PageUp": return findEnabledDateInMonth(action.shiftKey ? addCalendarYears(action.date, -1) : addCalendarMonths(action.date, -1), -1, availability);
-		case "PageDown": return findEnabledDateInMonth(action.shiftKey ? addCalendarYears(action.date, 1) : addCalendarMonths(action.date, 1), 1, availability);
-		default: return null;
-	}
-}
-function resolveFocusableDate(context, action) {
-	const focusedDay = context.visibleDays.find((day) => isSameDate(day.date, action.focusedDate));
-	const selectedDay = context.visibleDays.find((day) => day.selected);
-	const todayDay = context.visibleDays.find((day) => day.today);
-	const focusedDate = focusedDay?.date ?? selectedDay?.date ?? todayDay?.date ?? context.visibleDays[0]?.date ?? null;
-	return focusedDate ? { focusedDate } : null;
-}
-function alignCalendarMonth(context, action) {
-	if (isSameMonth(action.focusedDate, context.month)) return null;
-	const direction = compareDates(context.month, action.previousMonth) >= 0 ? 1 : -1;
-	return { focusedDate: getPreferredDateForMonth({
-		month: context.month,
-		anchor: action.focusedDate,
-		selectedDate: context.selectedDate,
-		today: context.today,
-		direction,
-		availability: context.availability
-	}) ?? context.month };
-}
-function navigateCalendarMonth(context, action) {
-	if (context.disabled || action.amount === 0) return null;
-	const direction = action.amount > 0 ? 1 : -1;
-	const visibleMonth = findNavigableMonth(addCalendarMonths(context.month, action.amount), direction, context.availability);
-	if (!visibleMonth) return null;
-	return {
-		visibleMonth,
-		focusedDate: getPreferredDateForMonth({
-			month: visibleMonth,
-			anchor: action.focusedDate,
-			selectedDate: context.selectedDate,
-			today: context.today,
-			direction,
-			availability: context.availability
-		}) ?? visibleMonth
-	};
-}
-function moveCalendarFocus(context, action) {
-	const focusedDate = getKeyboardTarget(action, context.firstDayOfWeek, context.availability);
-	return focusedDate ? {
-		visibleMonth: startOfMonth(focusedDate),
-		focusedDate
-	} : null;
-}
-function decideCalendarBehavior(context, action) {
-	switch (action.type) {
-		case "resolve-focusable": return resolveFocusableDate(context, action);
-		case "align-month": return alignCalendarMonth(context, action);
-		case "navigate-month": return navigateCalendarMonth(context, action);
-		case "move-focus": return moveCalendarFocus(context, action);
-	}
-}
-function createCalendarBehavior(options) {
-	const month = startOfMonth(options.month);
-	const selectedDate = normalizeDate(options.selectedDate);
-	const today = toLocalDate(options.today);
-	const firstDayOfWeek = normalizeFirstDayOfWeek(options.firstDayOfWeek);
-	const availability = {
-		min: options.min,
-		max: options.max,
-		disabledDates: options.disabledDates
-	};
-	const days = createCalendarDays({
-		...options,
-		month,
-		selectedDate,
-		today
-	}, firstDayOfWeek);
-	const visibleDays = days.filter((day) => !day.hidden && !day.disabled && isSameMonth(day.date, month));
-	const view = {
-		days,
-		weeks: createCalendarWeeks(days),
-		weekdays: getCalendarWeekdays(options.locale, firstDayOfWeek, options.weekdayFormat ?? "short"),
-		monthLabel: new Intl.DateTimeFormat(options.locale, options.monthFormat ?? {
-			month: "long",
-			year: "numeric"
-		}).format(month),
-		previousDisabled: Boolean(options.disabled) || !findNavigableMonth(addCalendarMonths(month, -1), -1, availability),
-		nextDisabled: Boolean(options.disabled) || !findNavigableMonth(addCalendarMonths(month, 1), 1, availability)
-	};
-	const context = {
-		month,
-		selectedDate,
-		today,
-		firstDayOfWeek,
-		disabled: Boolean(options.disabled),
-		availability,
-		visibleDays
-	};
-	return {
-		view,
-		decide: (action) => decideCalendarBehavior(context, action)
-	};
-}
-//#endregion
-//#region src/components/calendar/useCalendar.ts
-function initialMonth(props) {
-	return startOfMonth(normalizeDate(props.month) ?? normalizeDate(props.defaultMonth) ?? normalizeDate(props.modelValue) ?? normalizeDate(props.defaultValue) ?? /* @__PURE__ */ new Date());
-}
-function useCalendar(props, emit) {
-	const rootRef = ref(null);
-	const today = shallowRef(toLocalDate(/* @__PURE__ */ new Date()));
-	const uncontrolledMonth = shallowRef(initialMonth(props));
-	const controllable = useControllableValue({
-		modelValue: () => props.modelValue,
-		defaultValue: () => normalizeDate(props.defaultValue),
-		onChange(value) {
-			if (!value) return;
-			emit.value(value);
-			emit.change(value);
-		}
-	});
-	const selectedDate = computed(() => normalizeDate(controllable.value.value));
-	const visibleMonth = computed(() => normalizeDate(props.month) ?? uncontrolledMonth.value);
-	const focusedDate = shallowRef(selectedDate.value && isSameMonth(selectedDate.value, visibleMonth.value) ? selectedDate.value : isSameMonth(today.value, visibleMonth.value) ? today.value : visibleMonth.value);
-	const behavior = computed(() => createCalendarBehavior({
-		month: visibleMonth.value,
-		selectedDate: selectedDate.value,
-		today: today.value,
-		firstDayOfWeek: props.firstDayOfWeek,
-		weekdayFormat: props.weekdayFormat,
-		locale: props.locale,
-		monthFormat: props.monthFormat,
-		fixedWeeks: props.fixedWeeks,
-		hideOutsideDates: props.hideOutsideDates,
-		disabled: props.disabled,
-		min: props.min,
-		max: props.max,
-		disabledDates: props.disabledDates
-	}));
-	const days = computed(() => behavior.value.view.days);
-	const weeks = computed(() => behavior.value.view.weeks);
-	const weekdays = computed(() => behavior.value.view.weekdays);
-	const monthLabel = computed(() => behavior.value.view.monthLabel);
-	const previousDisabled = computed(() => behavior.value.view.previousDisabled);
-	const nextDisabled = computed(() => behavior.value.view.nextDisabled);
-	const focusableDate = computed(() => behavior.value.decide({
-		type: "resolve-focusable",
-		focusedDate: focusedDate.value
-	})?.focusedDate ?? null);
-	const rootClass = computed(() => bem("rp-calendar", {
-		[`size-${props.size}`]: Boolean(props.size),
-		[`radius-${props.radius}`]: Boolean(props.radius),
-		disabled: props.disabled,
-		readonly: props.readonly
-	}));
-	let todayTimer;
-	let ownerDocument = null;
-	let ownerWindow = null;
-	watch(() => props.modelValue, (value) => {
-		const normalized = normalizeDate(value);
-		if (!normalized) return;
-		focusedDate.value = normalized;
-		if (props.month === void 0) uncontrolledMonth.value = startOfMonth(normalized);
-	}, { flush: "sync" });
-	watch(visibleMonth, (_month, previousMonth) => {
-		const transition = behavior.value.decide({
-			type: "align-month",
-			previousMonth,
-			focusedDate: focusedDate.value
-		});
-		if (transition) focusedDate.value = transition.focusedDate;
-	}, { flush: "sync" });
-	function setVisibleMonth(month) {
-		const normalized = startOfMonth(month);
-		if (isSameMonth(normalized, visibleMonth.value)) return;
-		if (props.month === void 0) uncontrolledMonth.value = normalized;
-		emit.month(normalized);
-	}
-	function selectDate(day) {
-		if (props.disabled || props.readonly || day.disabled || day.hidden) return;
-		const date = toLocalDate(day.date);
-		const calendarHadFocus = rootRef.value?.contains(rootRef.value.ownerDocument.activeElement) ?? false;
-		controllable.setValue(date);
-		focusedDate.value = date;
-		if (isSameMonth(date, visibleMonth.value)) return;
-		if (!calendarHadFocus || !rootRef.value?.contains(rootRef.value.ownerDocument.activeElement)) return;
-		focusDate(date);
-	}
-	function navigateMonth(amount) {
-		const transition = behavior.value.decide({
-			type: "navigate-month",
-			amount,
-			focusedDate: focusedDate.value
-		});
-		if (!transition?.visibleMonth) return;
-		focusedDate.value = transition.focusedDate;
-		setVisibleMonth(transition.visibleMonth);
-	}
-	async function focusDate(date) {
-		const normalized = toLocalDate(date);
-		focusedDate.value = normalized;
-		setVisibleMonth(normalized);
-		await nextTick();
-		rootRef.value?.querySelector(`[data-date="${toDateKey(normalized)}"]`)?.focus();
-	}
-	function onDayKeydown(event, day) {
-		if ((event.key === "Enter" || event.key === " ") && !day.disabled) {
-			event.preventDefault();
-			selectDate(day);
-			return;
-		}
-		const transition = behavior.value.decide({
-			type: "move-focus",
-			date: day.date,
-			key: event.key,
-			shiftKey: event.shiftKey
-		});
-		if (!transition) return;
-		event.preventDefault();
-		focusDate(transition.focusedDate);
-	}
-	function onDayFocus(day) {
-		focusedDate.value = day.date;
-	}
-	function scheduleTodayRefresh() {
-		if (todayTimer !== void 0) clearTimeout(todayTimer);
-		const now = /* @__PURE__ */ new Date();
-		const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
-		todayTimer = setTimeout(refreshToday, tomorrow.getTime() - now.getTime());
-	}
-	function refreshToday() {
-		const current = toLocalDate(/* @__PURE__ */ new Date());
-		const previous = today.value;
-		today.value = current;
-		if (!selectedDate.value && isSameDate(focusedDate.value, previous) && isSameMonth(current, visibleMonth.value)) focusedDate.value = current;
-		scheduleTodayRefresh();
-	}
-	function refreshTodayWhenVisible() {
-		if (ownerDocument?.visibilityState !== "hidden") refreshToday();
-	}
-	onMounted(() => {
-		ownerDocument = rootRef.value?.ownerDocument ?? document;
-		ownerWindow = ownerDocument.defaultView;
-		ownerDocument.addEventListener("visibilitychange", refreshTodayWhenVisible);
-		ownerWindow?.addEventListener("focus", refreshToday);
-		scheduleTodayRefresh();
-	});
-	onBeforeUnmount(() => {
-		if (todayTimer !== void 0) clearTimeout(todayTimer);
-		ownerDocument?.removeEventListener("visibilitychange", refreshTodayWhenVisible);
-		ownerWindow?.removeEventListener("focus", refreshToday);
-	});
-	return {
-		rootRef,
-		selectedDate,
-		visibleMonth,
-		days,
-		weeks,
-		weekdays,
-		monthLabel,
-		rootClass,
-		previousDisabled,
-		nextDisabled,
-		focusableDate,
-		selectDate,
-		navigateMonth,
-		onDayKeydown,
-		onDayFocus
-	};
-}
-//#endregion
-//#region src/components/calendar/calendar.vue?vue&type=script&setup=true&vapor=true&lang.ts
-var t0 = template("<div data-v-9df33d1a><button data-v-9df33d1a></button><span data-v-9df33d1a> </span><button data-v-9df33d1a></button>");
-var t1 = template("<span data-v-9df33d1a> ");
-var t2 = template("<th data-v-9df33d1a> ");
-var t3 = template(" ");
-var t4 = template("<button data-v-9df33d1a>");
-var t5 = template("<td data-v-9df33d1a>");
-var t6 = template("<tr data-v-9df33d1a>");
-var t7 = template("<div data-v-9df33d1a><table data-v-9df33d1a><thead data-v-9df33d1a><tr data-v-9df33d1a></thead><tbody data-v-9df33d1a>", 1);
-//#endregion
-//#region src/components/calendar/calendar.vue
-var calendar_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
-	name: "RpCalendar",
-	inheritAttrs: false,
-	__name: "calendar",
-	props: {
-		id: {},
-		modelValue: { default: void 0 },
-		defaultValue: { default: null },
-		month: { default: void 0 },
-		defaultMonth: { default: void 0 },
-		locale: { default: void 0 },
-		firstDayOfWeek: { default: 0 },
-		weekdayFormat: { default: "short" },
-		monthFormat: { default: void 0 },
-		min: {},
-		max: {},
-		disabledDates: {},
-		fixedWeeks: {
-			type: Boolean,
-			default: true
-		},
-		hideOutsideDates: {
-			type: Boolean,
-			default: false
-		},
-		showHeader: {
-			type: Boolean,
-			default: true
-		},
-		disabled: {
-			type: Boolean,
-			default: false
-		},
-		readonly: {
-			type: Boolean,
-			default: false
-		},
-		size: { default: "md" },
-		radius: { default: "sm" },
-		ariaLabel: { default: void 0 },
-		getDayAriaLabel: {},
-		previousLabel: { default: "Previous month" },
-		nextLabel: { default: "Next month" },
-		classNames: {},
-		styles: {}
-	},
-	emits: [
-		"update:modelValue",
-		"update:month",
-		"change"
-	],
-	setup(__props, { expose: __expose, emit: __emit }) {
-		const props = __props;
-		const emit = __emit;
-		const { rootRef, visibleMonth, weeks, weekdays, monthLabel, rootClass, previousDisabled, nextDisabled, focusableDate, selectDate, navigateMonth, onDayKeydown, onDayFocus } = useCalendar(props, {
-			value: (value) => emit("update:modelValue", value),
-			month: (month) => emit("update:month", month),
-			change: (value) => emit("change", value)
-		});
-		const monthLabelId = `${useId()}-month`;
-		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
-		const rootAttrs = computed(() => getRootAttrs({
-			id: props.id,
-			class: rootClass.value,
-			"data-month": toDateKey(visibleMonth.value),
-			"data-disabled": toPresenceAttribute(props.disabled),
-			"data-readonly": toPresenceAttribute(props.readonly)
-		}));
-		function getDayAttrs(day) {
-			return {
-				...getPartAttrs("day", { class: ["rp-calendar__day", {
-					"rp-calendar__day--outside": day.outside,
-					"rp-calendar__day--selected": day.selected,
-					"rp-calendar__day--today": day.today
-				}] }),
-				"data-date": day.key,
-				"data-outside": toPresenceAttribute(day.outside),
-				"data-selected": toPresenceAttribute(day.selected),
-				"data-today": toPresenceAttribute(day.today),
-				"data-disabled": toPresenceAttribute(props.disabled || day.disabled)
-			};
-		}
-		function getDayLabel(day) {
-			return props.getDayAriaLabel?.(day) ?? day.ariaLabel;
-		}
-		function isFocusable(day) {
-			return !props.disabled && !day.disabled && isSameDate(day.date, focusableDate.value);
-		}
-		__expose({
-			nativeElement: rootRef,
-			focus() {
-				(rootRef.value?.querySelector(".rp-calendar__day[tabindex=\"0\"]") ?? rootRef.value?.querySelector(".rp-calendar__control:not(:disabled)"))?.focus({ preventScroll: true });
-			}
-		});
-		const n33 = t7();
-		const n32 = child(n33, 1);
-		const n18 = child(n32);
-		const n17 = child(n18);
-		const n31 = next(n18, 1);
-		renderEffect(() => setDynamicProps(n33, [rootAttrs.value]));
-		setInsertionState(n33, 0);
-		createIf(() => __props.showHeader, () => {
-			const n11 = t0();
-			const n5 = child(n11);
-			const n6 = next(n5, 1);
-			const n10 = next(n6, 2);
-			renderEffect(() => {
-				const _getPartAttrs = unref(getPartAttrs);
-				setDynamicProps(n11, [_getPartAttrs("header", { class: "rp-calendar__header" })]);
-				setDynamicProps(n5, [_getPartAttrs("previousControl", { class: "rp-calendar__control rp-calendar__control--previous" }), {
-					type: "button",
-					"aria-label": __props.previousLabel,
-					disabled: unref(previousDisabled)
-				}]);
-			});
-			setInsertionState(n5, null, 0);
-			createSlot("previous-icon", null, () => {
-				return createComponent(unref(chevron_left_default), { "aria-hidden": "true" });
-			}, 1);
-			on(n5, "click", () => unref(navigateMonth)(-1));
-			const x6 = txt(n6);
-			renderEffect(() => {
-				const _getPartAttrs = unref(getPartAttrs);
-				setDynamicProps(n6, [
-					{ id: monthLabelId },
-					_getPartAttrs("monthLabel", { class: "rp-calendar__month-label" }),
-					{ "aria-live": "polite" }
-				]);
-				setText(x6, toDisplayString(unref(monthLabel)));
-				setDynamicProps(n10, [_getPartAttrs("nextControl", { class: "rp-calendar__control rp-calendar__control--next" }), {
-					type: "button",
-					"aria-label": __props.nextLabel,
-					disabled: unref(nextDisabled)
-				}]);
-			});
-			setInsertionState(n10, null, 0);
-			createSlot("next-icon", null, () => {
-				return createComponent(unref(chevron_right_default), { "aria-hidden": "true" });
-			}, 1);
-			on(n10, "click", () => unref(navigateMonth)(1));
-			return n11;
-		}, () => {
-			const n13 = t1();
-			const x13 = txt(n13);
-			renderEffect(() => {
-				setDynamicProps(n13, [
-					{ id: monthLabelId },
-					unref(getPartAttrs)("monthLabel", { class: ["rp-calendar__month-label", "rp-calendar__month-label--visually-hidden"] }),
-					{ "aria-live": "polite" }
-				]);
-				setText(x13, toDisplayString(unref(monthLabel)));
-			});
-			return n13;
-		}, 261);
-		renderEffect(() => {
-			const _getPartAttrs = unref(getPartAttrs);
-			const _ariaLabel = __props.ariaLabel;
-			setDynamicProps(n32, [_getPartAttrs("grid", { class: "rp-calendar__grid" }), {
-				role: "grid",
-				"aria-label": _ariaLabel,
-				"aria-labelledby": _ariaLabel ? void 0 : monthLabelId,
-				"aria-readonly": __props.readonly || void 0,
-				"aria-disabled": __props.disabled || void 0
-			}]);
-			setDynamicProps(n18, [_getPartAttrs("weekdays", { class: "rp-calendar__weekdays" })]);
-		});
-		setInsertionState(n17, null, 0);
-		createFor(() => unref(weekdays), (_for_item0) => {
-			const n16 = t2();
-			const x16 = txt(n16);
-			renderEffect(() => {
-				const _weekday = _for_item0.value;
-				setDynamicProps(n16, [unref(getPartAttrs)("weekday", { class: "rp-calendar__weekday" }), {
-					scope: "col",
-					"aria-label": _weekday.ariaLabel
-				}]);
-				setText(x16, toDisplayString(_weekday.label));
-			});
-			return n16;
-		}, (weekday) => weekday.key, 9);
-		setInsertionState(n31, null, 0);
-		createFor(() => unref(weeks), (_for_item0, _for_key0) => {
-			const n30 = t6();
-			renderEffect(() => setDynamicProps(n30, [unref(getPartAttrs)("week", { class: "rp-calendar__week" })]));
-			setInsertionState(n30, null, 0);
-			createFor(() => _for_item0.value, (_for_item1) => {
-				const n29 = t5();
-				renderEffect(() => {
-					const _day = _for_item1.value;
-					setDynamicProps(n29, [unref(getPartAttrs)("dayCell", { class: "rp-calendar__day-cell" }), {
-						role: "gridcell",
-						"aria-selected": _day.hidden ? void 0 : _day.selected
-					}]);
-				});
-				setInsertionState(n29, null, 0);
-				createIf(() => !_for_item1.value.hidden, () => {
-					const n28 = t4();
-					renderEffect(() => {
-						const _day = _for_item1.value;
-						setDynamicProps(n28, [getDayAttrs(_day), {
-							type: "button",
-							disabled: __props.disabled || _day.disabled,
-							"aria-label": getDayLabel(_day),
-							"aria-current": _day.today ? "date" : void 0,
-							tabindex: isFocusable(_day) ? 0 : -1
-						}]);
-					});
-					setInsertionState(n28, null, 0);
-					createSlot("day", { $: [() => _for_item1.value, { select: () => (() => unref(selectDate)(_for_item1.value)) }] }, () => {
-						const n27 = t3();
-						renderEffect(() => setText(n27, toDisplayString(_for_item1.value.label)));
-						return n27;
-					}, 1);
-					on(n28, "click", () => unref(selectDate)(_for_item1.value));
-					on(n28, "focus", () => unref(onDayFocus)(_for_item1.value));
-					on(n28, "keydown", ($event) => unref(onDayKeydown)($event, _for_item1.value));
-					return n28;
-				});
-				return n29;
-			}, (day) => day.key, 9);
-			return n30;
-		}, (week, weekIndex) => weekIndex, 9);
-		setStaticTemplateRef(n33, rootRef, null, "rootRef");
-		return n33;
-	}
-}), [["__scopeId", "data-v-9df33d1a"]]);
-//#endregion
-export { parseDateKey as a, normalizeDate as i, isDateUnavailable as n, toLocalDate as o, isValidDate as r, calendar_default as t };