ropav 0.1.6 → 0.1.8

package/dist/calendar.js

@@ -0,0 +1,714 @@
+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, createTemplateRefSetter, defineVaporComponent, next, nextTick, on, onBeforeUnmount, onMounted, ref, renderEffect, setDynamicProps, setInsertionState, 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("<th data-v-d3ae1d38> ");
+var t1 = template(" ");
+var t2 = template("<button data-v-d3ae1d38>");
+var t3 = template("<td data-v-d3ae1d38>");
+var t4 = template("<tr data-v-d3ae1d38>");
+var t5 = template("<div data-v-d3ae1d38><div data-v-d3ae1d38><button data-v-d3ae1d38></button><span data-v-d3ae1d38> </span><button data-v-d3ae1d38></button></div><table data-v-d3ae1d38><thead data-v-d3ae1d38><tr data-v-d3ae1d38></thead><tbody data-v-d3ae1d38>", 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
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		readonly: {
+			type: Boolean,
+			default: false
+		},
+		size: { default: "md" },
+		radius: { default: "sm" },
+		ariaLabel: { default: void 0 },
+		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 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 _setTemplateRef = createTemplateRefSetter();
+		const n29 = t5();
+		const n9 = child(n29);
+		const n3 = child(n9);
+		const n4 = next(n3, 1);
+		const n8 = next(n4, 2);
+		const n28 = next(n9, 1);
+		const n14 = child(n28);
+		const n13 = child(n14);
+		const n27 = next(n14, 1);
+		renderEffect(() => {
+			const _getPartAttrs = unref(getPartAttrs);
+			setDynamicProps(n29, [rootAttrs.value]);
+			setDynamicProps(n9, [_getPartAttrs("header", { class: "rp-calendar__header" })]);
+			setDynamicProps(n3, [_getPartAttrs("previousControl", { class: "rp-calendar__control rp-calendar__control--previous" }), {
+				type: "button",
+				"aria-label": __props.previousLabel,
+				disabled: unref(previousDisabled)
+			}]);
+		});
+		setInsertionState(n3, null, 0);
+		createSlot("previous-icon", null, () => {
+			return createComponent(unref(chevron_left_default), { "aria-hidden": "true" });
+		}, 1);
+		on(n3, "click", () => unref(navigateMonth)(-1));
+		const x4 = txt(n4);
+		renderEffect(() => {
+			const _getPartAttrs = unref(getPartAttrs);
+			setDynamicProps(n4, [
+				{ id: monthLabelId },
+				_getPartAttrs("monthLabel", { class: "rp-calendar__month-label" }),
+				{ "aria-live": "polite" }
+			]);
+			setText(x4, toDisplayString(unref(monthLabel)));
+			setDynamicProps(n8, [_getPartAttrs("nextControl", { class: "rp-calendar__control rp-calendar__control--next" }), {
+				type: "button",
+				"aria-label": __props.nextLabel,
+				disabled: unref(nextDisabled)
+			}]);
+		});
+		setInsertionState(n8, null, 0);
+		createSlot("next-icon", null, () => {
+			return createComponent(unref(chevron_right_default), { "aria-hidden": "true" });
+		}, 1);
+		on(n8, "click", () => unref(navigateMonth)(1));
+		renderEffect(() => {
+			const _getPartAttrs = unref(getPartAttrs);
+			const _ariaLabel = __props.ariaLabel;
+			setDynamicProps(n28, [_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(n14, [_getPartAttrs("weekdays", { class: "rp-calendar__weekdays" })]);
+		});
+		setInsertionState(n13, null, 0);
+		createFor(() => unref(weekdays), (_for_item0) => {
+			const n12 = t0();
+			const x12 = txt(n12);
+			renderEffect(() => {
+				const _weekday = _for_item0.value;
+				setDynamicProps(n12, [unref(getPartAttrs)("weekday", { class: "rp-calendar__weekday" }), {
+					scope: "col",
+					"aria-label": _weekday.ariaLabel
+				}]);
+				setText(x12, toDisplayString(_weekday.label));
+			});
+			return n12;
+		}, (weekday) => weekday.key, 9);
+		setInsertionState(n27, null, 0);
+		createFor(() => unref(weeks), (_for_item0, _for_key0) => {
+			const n26 = t4();
+			renderEffect(() => setDynamicProps(n26, [unref(getPartAttrs)("week", { class: "rp-calendar__week" })]));
+			setInsertionState(n26, null, 0);
+			createFor(() => _for_item0.value, (_for_item1) => {
+				const n25 = t3();
+				renderEffect(() => {
+					const _day = _for_item1.value;
+					setDynamicProps(n25, [unref(getPartAttrs)("dayCell", { class: "rp-calendar__day-cell" }), {
+						role: "gridcell",
+						"aria-selected": _day.hidden ? void 0 : _day.selected
+					}]);
+				});
+				setInsertionState(n25, null, 0);
+				createIf(() => !_for_item1.value.hidden, () => {
+					const n24 = t2();
+					renderEffect(() => {
+						const _day = _for_item1.value;
+						setDynamicProps(n24, [getDayAttrs(_day), {
+							type: "button",
+							disabled: __props.disabled || _day.disabled,
+							"aria-label": _day.ariaLabel,
+							"aria-current": _day.today ? "date" : void 0,
+							tabindex: isFocusable(_day) ? 0 : -1
+						}]);
+					});
+					setInsertionState(n24, null, 0);
+					createSlot("day", { $: [() => _for_item1.value, { select: () => (() => unref(selectDate)(_for_item1.value)) }] }, () => {
+						const n23 = t1();
+						renderEffect(() => setText(n23, toDisplayString(_for_item1.value.label)));
+						return n23;
+					}, 1);
+					on(n24, "click", () => unref(selectDate)(_for_item1.value));
+					on(n24, "focus", () => unref(onDayFocus)(_for_item1.value));
+					on(n24, "keydown", ($event) => unref(onDayKeydown)($event, _for_item1.value));
+					return n24;
+				});
+				return n25;
+			}, (day) => day.key, 9);
+			return n26;
+		}, (week, weekIndex) => weekIndex, 9);
+		_setTemplateRef(n29, rootRef, null, "rootRef");
+		return n29;
+	}
+}), [["__scopeId", "data-v-d3ae1d38"]]);
+//#endregion
+export { parseDateKey as a, normalizeDate as i, isDateUnavailable as n, toLocalDate as o, isValidDate as r, calendar_default as t };