@proyecto-viviana/solidaria 0.3.0 → 0.4.0

package/dist/_chunk/calendar.jsx

@@ -0,0 +1,1036 @@
+import { i as access, o as mergeProps } from "./env.jsx";
+import { S as scrollIntoViewport, i as createDescription } from "./utils.jsx";
+import { l as getScrollParent, t as focusSafely } from "./focus.jsx";
+import { o as getInteractionModality } from "./createInteractionModality.jsx";
+import { t as createFocusRing } from "./createFocusRing.jsx";
+import { a as useLocale } from "./createCollator.jsx";
+import { createId } from "../ssr/index.jsx";
+import { createEffect, createMemo, createSignal } from "solid-js";
+import { LocalizedStringDictionary, LocalizedStringFormatter } from "@internationalized/string";
+import { DateFormatter, endOfMonth, getLocalTimeZone, isSameDay, isSameYear, isToday, startOfMonth, startOfWeek, toCalendarDate, today } from "@internationalized/date";
+//#region src/calendar/intl/index.ts
+const calendarPromptDictionary = new LocalizedStringDictionary({
+	"ar-AE": {
+		startRangeSelectionPrompt: "انقر لبدء عملية تحديد نطاق التاريخ",
+		finishRangeSelectionPrompt: "انقر لإنهاء عملية تحديد نطاق التاريخ"
+	},
+	"bg-BG": {
+		startRangeSelectionPrompt: "Натиснете, за да пристъпите към избора на времеви интервал",
+		finishRangeSelectionPrompt: "Натиснете, за да довършите избора на времеви интервал"
+	},
+	"cs-CZ": {
+		startRangeSelectionPrompt: "Kliknutím zahájíte výběr rozsahu dat",
+		finishRangeSelectionPrompt: "Kliknutím dokončíte výběr rozsahu dat"
+	},
+	"da-DK": {
+		startRangeSelectionPrompt: "Klik for at starte valg af datoområde",
+		finishRangeSelectionPrompt: "Klik for at fuldføre valg af datoområde"
+	},
+	"de-DE": {
+		startRangeSelectionPrompt: "Klicken, um die Auswahl des Datumsbereichs zu beginnen",
+		finishRangeSelectionPrompt: "Klicken, um die Auswahl des Datumsbereichs zu beenden"
+	},
+	"el-GR": {
+		startRangeSelectionPrompt: "Κάντε κλικ για να ξεκινήσετε την επιλογή εύρους ημερομηνιών",
+		finishRangeSelectionPrompt: "Κάντε κλικ για να ολοκληρώσετε την επιλογή εύρους ημερομηνιών"
+	},
+	"en-US": {
+		startRangeSelectionPrompt: "Click to start selecting date range",
+		finishRangeSelectionPrompt: "Click to finish selecting date range"
+	},
+	"es-ES": {
+		startRangeSelectionPrompt: "Haga clic para comenzar a seleccionar un rango de fechas",
+		finishRangeSelectionPrompt: "Haga clic para terminar de seleccionar rango de fechas"
+	},
+	"et-EE": {
+		startRangeSelectionPrompt: "Klõpsake kuupäevavahemiku valimiseks",
+		finishRangeSelectionPrompt: "Klõpsake kuupäevavahemiku valimise lõpetamiseks"
+	},
+	"fi-FI": {
+		startRangeSelectionPrompt: "Aloita päivämääräalueen valinta napsauttamalla tätä.",
+		finishRangeSelectionPrompt: "Lopeta päivämääräalueen valinta napsauttamalla tätä."
+	},
+	"fr-FR": {
+		startRangeSelectionPrompt: "Cliquer pour commencer à sélectionner la plage de dates",
+		finishRangeSelectionPrompt: "Cliquer pour finir de sélectionner la plage de dates"
+	},
+	"he-IL": {
+		startRangeSelectionPrompt: "לחץ כדי להתחיל בבחירת טווח התאריכים",
+		finishRangeSelectionPrompt: "חץ כדי לסיים את בחירת טווח התאריכים"
+	},
+	"hr-HR": {
+		startRangeSelectionPrompt: "Kliknite da započnete raspon odabranih datuma",
+		finishRangeSelectionPrompt: "Kliknite da dovršite raspon odabranih datuma"
+	},
+	"hu-HU": {
+		startRangeSelectionPrompt: "Kattintson a dátumtartomány kijelölésének indításához",
+		finishRangeSelectionPrompt: "Kattintson a dátumtartomány kijelölésének befejezéséhez"
+	},
+	"it-IT": {
+		startRangeSelectionPrompt: "Fai clic per selezionare l’intervallo di date",
+		finishRangeSelectionPrompt: "Fai clic per completare la selezione dell’intervallo di date"
+	},
+	"ja-JP": {
+		startRangeSelectionPrompt: "クリックして日付範囲の選択を開始",
+		finishRangeSelectionPrompt: "クリックして日付範囲の選択を終了"
+	},
+	"ko-KR": {
+		startRangeSelectionPrompt: "날짜 범위 선택을 시작하려면 클릭하십시오.",
+		finishRangeSelectionPrompt: "날짜 범위 선택을 완료하려면 클릭하십시오."
+	},
+	"lt-LT": {
+		startRangeSelectionPrompt: "Spustelėkite, kad pradėtumėte pasirinkti datų intervalą",
+		finishRangeSelectionPrompt: "Spustelėkite, kad baigtumėte pasirinkti datų intervalą"
+	},
+	"lv-LV": {
+		startRangeSelectionPrompt: "Noklikšķiniet, lai sāktu datumu diapazona atlasi",
+		finishRangeSelectionPrompt: "Noklikšķiniet, lai pabeigtu datumu diapazona atlasi"
+	},
+	"nb-NO": {
+		startRangeSelectionPrompt: "Klikk for å starte valg av datoområde",
+		finishRangeSelectionPrompt: "Klikk for å fullføre valg av datoområde"
+	},
+	"nl-NL": {
+		startRangeSelectionPrompt: "Klik om het datumbereik te selecteren",
+		finishRangeSelectionPrompt: "Klik om de selectie van het datumbereik te voltooien"
+	},
+	"pl-PL": {
+		startRangeSelectionPrompt: "Kliknij, aby rozpocząć wybór zakresu dat",
+		finishRangeSelectionPrompt: "Kliknij, aby zakończyć wybór zakresu dat"
+	},
+	"pt-BR": {
+		startRangeSelectionPrompt: "Clique para iniciar a seleção do intervalo de datas",
+		finishRangeSelectionPrompt: "Clique para concluir a seleção do intervalo de datas"
+	},
+	"pt-PT": {
+		startRangeSelectionPrompt: "Clique para começar a selecionar o intervalo de datas",
+		finishRangeSelectionPrompt: "Clique para terminar de selecionar o intervalo de datas"
+	},
+	"ro-RO": {
+		startRangeSelectionPrompt: "Apăsaţi pentru a începe selecţia razei pentru dată",
+		finishRangeSelectionPrompt: "Apăsaţi pentru a finaliza selecţia razei pentru dată"
+	},
+	"ru-RU": {
+		startRangeSelectionPrompt: "Щелкните, чтобы начать выбор диапазона дат",
+		finishRangeSelectionPrompt: "Щелкните, чтобы завершить выбор диапазона дат"
+	},
+	"sk-SK": {
+		startRangeSelectionPrompt: "Kliknutím spustíte výber rozsahu dátumov",
+		finishRangeSelectionPrompt: "Kliknutím dokončíte výber rozsahu dátumov"
+	},
+	"sl-SI": {
+		startRangeSelectionPrompt: "Kliknite za začetek izbire datumskega obsega",
+		finishRangeSelectionPrompt: "Kliknite za dokončanje izbire datumskega obsega"
+	},
+	"sr-SP": {
+		startRangeSelectionPrompt: "Kliknite da započnete opseg izabranih datuma",
+		finishRangeSelectionPrompt: "Kliknite da dovršite opseg izabranih datuma"
+	},
+	"sv-SE": {
+		startRangeSelectionPrompt: "Klicka för att välja datumintervall",
+		finishRangeSelectionPrompt: "Klicka för att avsluta val av datumintervall"
+	},
+	"tr-TR": {
+		startRangeSelectionPrompt: "Tarih aralığı seçimini başlatmak için tıklayın",
+		finishRangeSelectionPrompt: "Tarih aralığı seçimini tamamlamak için tıklayın"
+	},
+	"uk-UA": {
+		startRangeSelectionPrompt: "Натисніть, щоб почати вибір діапазону дат",
+		finishRangeSelectionPrompt: "Натисніть, щоб завершити вибір діапазону дат"
+	},
+	"zh-CN": {
+		startRangeSelectionPrompt: "单击以开始选择日期范围",
+		finishRangeSelectionPrompt: "单击以完成选择日期范围"
+	},
+	"zh-TW": {
+		startRangeSelectionPrompt: "按一下以開始選取日期範圍",
+		finishRangeSelectionPrompt: "按一下以完成選取日期範圍"
+	}
+});
+const calendarLabelDictionary = new LocalizedStringDictionary({
+	"en-US": {
+		dateRange: (args) => `${args?.startDate} to ${args?.endDate}`,
+		dateSelected: (args) => `${args?.date} selected`,
+		maximumDate: "Last available date",
+		minimumDate: "First available date",
+		selectedDateDescription: (args) => `Selected Date: ${args?.date}`,
+		selectedRangeDescription: (args) => `Selected Range: ${args?.dateRange}`,
+		todayDate: (args) => `Today, ${args?.date}`,
+		todayDateSelected: (args) => `Today, ${args?.date} selected`
+	},
+	"fr-FR": {
+		dateRange: (args) => `${args?.startDate} à ${args?.endDate}`,
+		dateSelected: (args) => `${args?.date} sélectionné`,
+		maximumDate: "Dernière date disponible",
+		minimumDate: "Première date disponible",
+		selectedDateDescription: (args) => `Date sélectionnée : ${args?.date}`,
+		selectedRangeDescription: (args) => `Plage sélectionnée : ${args?.dateRange}`,
+		todayDate: (args) => `Aujourd'hui, ${args?.date}`,
+		todayDateSelected: (args) => `Aujourd’hui, ${args?.date} sélectionné`
+	},
+	"ar-AE": {
+		dateRange: (args) => `${args?.startDate} إلى ${args?.endDate}`,
+		dateSelected: (args) => `${args?.date} المحدد`,
+		maximumDate: "آخر تاريخ متاح",
+		minimumDate: "أول تاريخ متاح",
+		selectedDateDescription: (args) => `تاريخ محدد: ${args?.date}`,
+		selectedRangeDescription: (args) => `المدى الزمني المحدد: ${args?.dateRange}`,
+		todayDate: (args) => `اليوم، ${args?.date}`,
+		todayDateSelected: (args) => `اليوم، ${args?.date} محدد`
+	}
+});
+function formatCalendarPrompt(locale, key) {
+	return new LocalizedStringFormatter(locale, calendarPromptDictionary).format(key);
+}
+function formatCalendarLabel(locale, key, variables) {
+	return new LocalizedStringFormatter(locale, calendarLabelDictionary).format(key, variables);
+}
+//#endregion
+//#region src/calendar/utils.ts
+const hookData = /* @__PURE__ */ new WeakMap();
+function setCalendarHookData(state, data) {
+	hookData.set(state, data);
+}
+function getCalendarHookData(state) {
+	return hookData.get(state);
+}
+function getEraFormat(date) {
+	return date?.calendar.identifier === "gregory" && date.era === "BC" ? "short" : void 0;
+}
+function formatVisibleRangeDescription(startDate, endDate, timeZone, locale) {
+	const era = getEraFormat(startDate) || getEraFormat(endDate);
+	const monthFormatter = new DateFormatter(locale, {
+		month: "long",
+		year: "numeric",
+		era,
+		calendar: startDate.calendar.identifier,
+		timeZone
+	});
+	const dateFormatter = new DateFormatter(locale, {
+		month: "long",
+		year: "numeric",
+		day: "numeric",
+		era,
+		calendar: startDate.calendar.identifier,
+		timeZone
+	});
+	if (isSameDay(startDate, startOfMonth(startDate))) {
+		const startMonth = startDate.calendar.getFormattableMonth?.(startDate) ?? startDate;
+		const endMonth = endDate.calendar.getFormattableMonth?.(endDate) ?? endDate;
+		if (isSameDay(endDate, endOfMonth(startDate))) return monthFormatter.format(startMonth.toDate(timeZone));
+		if (isSameDay(endDate, endOfMonth(endDate))) return formatRange(monthFormatter, startMonth, endMonth, timeZone);
+	}
+	return formatRange(dateFormatter, startDate, endDate, timeZone);
+}
+function formatSelectedDateDescription(state) {
+	const locale = state.locale();
+	const timeZone = state.timeZone;
+	let start;
+	let end;
+	if ("highlightedRange" in state) {
+		const range = state.highlightedRange();
+		start = range?.start;
+		end = range?.end;
+	} else {
+		const value = state.value();
+		start = value ?? void 0;
+		end = value ?? void 0;
+	}
+	if (("anchorDate" in state ? state.anchorDate() : null) || !start || !end) return "";
+	const dateFormatter = new DateFormatter(locale, {
+		weekday: "long",
+		month: "long",
+		year: "numeric",
+		day: "numeric",
+		era: getEraFormat(start) || getEraFormat(end),
+		timeZone
+	});
+	if (isSameDay(start, end)) return formatCalendarLabel(locale, "selectedDateDescription", { date: dateFormatter.format(start.toDate(timeZone)) });
+	return formatCalendarLabel(locale, "selectedRangeDescription", { dateRange: formatLabelRange(dateFormatter, start, end, timeZone, locale) });
+}
+function formatRange(dateFormatter, startDate, endDate, timeZone) {
+	const formatter = dateFormatter;
+	const start = startDate.toDate(timeZone);
+	const end = endDate.toDate(timeZone);
+	if (!formatter.formatRangeToParts) return `${dateFormatter.format(start)} to ${dateFormatter.format(end)}`;
+	const parts = formatter.formatRangeToParts(start, end);
+	let separatorIndex = -1;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (part?.source === "shared" && part.type === "literal") separatorIndex = i;
+		else if (part?.source === "endRange") break;
+	}
+	if (separatorIndex < 0) return `${dateFormatter.format(start)} to ${dateFormatter.format(end)}`;
+	let startValue = "";
+	let endValue = "";
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (!part) continue;
+		if (i < separatorIndex) startValue += part.value;
+		else if (i > separatorIndex) endValue += part.value;
+	}
+	return `${startValue} to ${endValue}`;
+}
+function formatLabelRange(dateFormatter, startDate, endDate, timeZone, locale) {
+	const formatter = dateFormatter;
+	const start = startDate.toDate(timeZone);
+	const end = endDate.toDate(timeZone);
+	if (!formatter.formatRangeToParts) return formatCalendarLabel(locale, "dateRange", {
+		startDate: dateFormatter.format(start),
+		endDate: dateFormatter.format(end)
+	});
+	const parts = formatter.formatRangeToParts(start, end);
+	let separatorIndex = -1;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (part?.source === "shared" && part.type === "literal") separatorIndex = i;
+		else if (part?.source === "endRange") break;
+	}
+	if (separatorIndex < 0) return formatCalendarLabel(locale, "dateRange", {
+		startDate: dateFormatter.format(start),
+		endDate: dateFormatter.format(end)
+	});
+	let startValue = "";
+	let endValue = "";
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (!part) continue;
+		if (i < separatorIndex) startValue += part.value;
+		else if (i > separatorIndex) endValue += part.value;
+	}
+	return formatCalendarLabel(locale, "dateRange", {
+		startDate: startValue,
+		endDate: endValue
+	});
+}
+//#endregion
+//#region src/calendar/createCalendar.ts
+/**
+* createCalendar hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a calendar component.
+* Based on @react-aria/calendar useCalendar
+*/
+/**
+* Provides the behavior and accessibility implementation for a calendar component.
+*/
+function createCalendar(props, state) {
+	const getProps = () => access(props);
+	const id = createId(getProps().id);
+	const titleId = createId();
+	const errorMessageId = createId(getProps().errorMessageId);
+	const title = createMemo(() => state.title());
+	const visibleRangeDescription = createMemo(() => {
+		const range = state.visibleRange();
+		return formatVisibleRangeDescription(range.start, range.end, state.timeZone, state.locale());
+	});
+	const calendarLabel = createMemo(() => {
+		return [getProps()["aria-label"], visibleRangeDescription()].filter(Boolean).join(", ");
+	});
+	const initialProps = getProps();
+	if (initialProps.id || initialProps["aria-label"] || initialProps["aria-labelledby"] || initialProps["aria-describedby"] || initialProps["aria-details"] || initialProps.errorMessage || initialProps.errorMessageId) setCalendarHookData(state, {
+		errorMessageId: initialProps.errorMessage || initialProps.errorMessageId ? errorMessageId : void 0,
+		ariaLabel: initialProps["aria-label"],
+		ariaLabelledBy: initialProps["aria-labelledby"]
+	});
+	const prevButtonProps = createMemo(() => {
+		const isDisabled = getProps().isDisabled || state.isDisabled();
+		return {
+			"aria-label": "Previous month",
+			onClick: () => {
+				if (!isDisabled) state.focusPreviousPage();
+			},
+			disabled: isDisabled,
+			tabIndex: -1
+		};
+	});
+	const nextButtonProps = createMemo(() => {
+		const isDisabled = getProps().isDisabled || state.isDisabled();
+		return {
+			"aria-label": "Next month",
+			onClick: () => {
+				if (!isDisabled) state.focusNextPage();
+			},
+			disabled: isDisabled,
+			tabIndex: -1
+		};
+	});
+	const titleProps = createMemo(() => ({
+		id: titleId,
+		"aria-live": "polite"
+	}));
+	const errorMessageProps = createMemo(() => ({ id: errorMessageId }));
+	const calendarProps = createMemo(() => {
+		const p = getProps();
+		return mergeProps({
+			id,
+			role: "application",
+			"aria-labelledby": p["aria-labelledby"],
+			"aria-label": calendarLabel(),
+			"aria-describedby": p["aria-describedby"],
+			"aria-details": p["aria-details"]
+		});
+	});
+	return {
+		get calendarProps() {
+			return calendarProps();
+		},
+		get prevButtonProps() {
+			return prevButtonProps();
+		},
+		get nextButtonProps() {
+			return nextButtonProps();
+		},
+		get titleProps() {
+			return titleProps();
+		},
+		get errorMessageProps() {
+			return errorMessageProps();
+		},
+		get title() {
+			return title();
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createCalendarMonthPicker.ts
+/**
+* createCalendarMonthPicker hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a month picker
+* within a calendar — a listbox/select that jumps the focused date to a chosen
+* month of the focused year.
+* Based on @react-aria/calendar useCalendarMonthPicker.
+*/
+/**
+* Provides the behavior and accessibility implementation for a month picker
+* within a calendar.
+*/
+function createCalendarMonthPicker(props, state) {
+	const getProps = () => access(props);
+	const locale = useLocale();
+	const formatter = createMemo(() => new DateFormatter(locale().locale, {
+		month: getProps().format ?? "short",
+		calendar: state.focusedDate().calendar.identifier,
+		timeZone: state.timeZone
+	}));
+	const items = createMemo(() => {
+		const focused = state.focusedDate();
+		const fmt = formatter();
+		const numMonths = focused.calendar.getMonthsInYear(focused);
+		const months = [];
+		for (let i = 1; i <= numMonths; i++) {
+			const date = focused.set({ month: i });
+			const displayDate = date.calendar.getFormattableMonth?.(date) ?? date;
+			months.push({
+				id: i,
+				date,
+				formatted: fmt.format(displayDate.toDate(state.timeZone))
+			});
+		}
+		return months;
+	});
+	const ariaLabel = createMemo(() => new Intl.DisplayNames(locale().locale, { type: "dateTimeField" }).of("month") ?? "month");
+	return {
+		get "aria-label"() {
+			return ariaLabel();
+		},
+		get value() {
+			return state.focusedDate().month;
+		},
+		onChange: (key) => {
+			if (key != null) state.setFocusedDate(items()[Number(key) - 1].date);
+		},
+		get items() {
+			return items();
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createCalendarYearPicker.ts
+/**
+* createCalendarYearPicker hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a year picker
+* within a calendar — a listbox/select that jumps the focused date to a chosen
+* year within a sliding window centered on the focused year.
+* Based on @react-aria/calendar useCalendarYearPicker.
+*/
+/**
+* Provides the behavior and accessibility implementation for a year picker
+* within a calendar.
+*/
+function createCalendarYearPicker(props, state) {
+	const getProps = () => access(props);
+	const locale = useLocale();
+	const formatter = createMemo(() => {
+		const focused = state.focusedDate();
+		const format = getProps().format;
+		return new DateFormatter(locale().locale, {
+			year: format?.year ?? "numeric",
+			era: format?.era ?? (focused.calendar.identifier === "gregory" && focused.era === "BC" ? "short" : void 0),
+			calendar: focused.calendar.identifier,
+			timeZone: state.timeZone
+		});
+	});
+	const data = createMemo(() => {
+		const focused = state.focusedDate();
+		const fmt = formatter();
+		const visibleYears = getProps().visibleYears || 20;
+		let minDate = focused.subtract({ years: Math.floor(visibleYears / 2) });
+		let maxDate = focused.add({ years: Math.ceil(visibleYears / 2) - 1 });
+		const stateMax = state.maxValue();
+		const stateMin = state.minValue();
+		if (stateMax && maxDate.compare(stateMax) > 0) {
+			maxDate = toCalendarDate(stateMax);
+			minDate = maxDate.subtract({ years: visibleYears - 1 });
+		}
+		if (stateMin && minDate.compare(stateMin) < 0) {
+			minDate = toCalendarDate(stateMin);
+			maxDate = minDate.add({ years: visibleYears - 1 });
+			if (stateMax && maxDate.compare(stateMax) > 0) maxDate = toCalendarDate(stateMax);
+		}
+		const years = [];
+		let value = 0;
+		let date = minDate;
+		while (date.compare(maxDate) <= 0) {
+			if (isSameYear(date, focused)) value = years.length;
+			years.push({
+				id: years.length,
+				date,
+				formatted: fmt.format(date.toDate(state.timeZone))
+			});
+			date = date.add({ years: 1 });
+		}
+		return {
+			items: years,
+			value
+		};
+	});
+	const ariaLabel = createMemo(() => new Intl.DisplayNames(locale().locale, { type: "dateTimeField" }).of("year") ?? "year");
+	return {
+		get "aria-label"() {
+			return ariaLabel();
+		},
+		get value() {
+			return data().value;
+		},
+		onChange: (key) => {
+			if (key != null) state.setFocusedDate(data().items[Number(key)].date);
+		},
+		get items() {
+			return data().items;
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createCalendarGrid.ts
+/**
+* createCalendarGrid hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a calendar grid.
+* Based on @react-aria/calendar useCalendarGrid
+*/
+/**
+* Provides the behavior and accessibility implementation for a calendar grid.
+*/
+function createCalendarGrid(props, state, ref) {
+	const weekDays = createMemo(() => {
+		const gridProps = access(props);
+		const formatter = new DateFormatter(state.locale(), {
+			weekday: gridProps.weekdayStyle ?? "narrow",
+			timeZone: state.timeZone
+		});
+		const weekStart = startOfWeek(today(state.timeZone), state.locale(), state.firstDayOfWeek());
+		return Array.from({ length: 7 }, (_, index) => formatter.format(weekStart.add({ days: index }).toDate(state.timeZone)));
+	});
+	const isRTL = () => {
+		const scopedDirection = (ref?.())?.closest("[dir]")?.getAttribute("dir");
+		const documentDirection = typeof document !== "undefined" ? document.dir : "";
+		return (scopedDirection ?? documentDirection) === "rtl";
+	};
+	const handleKeyDown = (e) => {
+		if (state.isDisabled()) return;
+		switch (e.key) {
+			case "ArrowLeft":
+				e.preventDefault();
+				e.stopPropagation();
+				if (isRTL()) state.focusNextDay();
+				else state.focusPreviousDay();
+				break;
+			case "ArrowRight":
+				e.preventDefault();
+				e.stopPropagation();
+				if (isRTL()) state.focusPreviousDay();
+				else state.focusNextDay();
+				break;
+			case "ArrowUp":
+				e.preventDefault();
+				e.stopPropagation();
+				state.focusPreviousWeek();
+				break;
+			case "ArrowDown":
+				e.preventDefault();
+				e.stopPropagation();
+				state.focusNextWeek();
+				break;
+			case "PageUp":
+				e.preventDefault();
+				e.stopPropagation();
+				if (e.shiftKey) state.focusPreviousSection();
+				else state.setFocusedDate(state.focusedDate().subtract({ months: 1 }));
+				break;
+			case "PageDown":
+				e.preventDefault();
+				e.stopPropagation();
+				if (e.shiftKey) state.focusNextSection();
+				else state.setFocusedDate(state.focusedDate().add({ months: 1 }));
+				break;
+			case "Home":
+				e.preventDefault();
+				e.stopPropagation();
+				state.focusPageStart();
+				break;
+			case "End":
+				e.preventDefault();
+				e.stopPropagation();
+				state.focusPageEnd();
+				break;
+			case "Enter":
+			case " ":
+				e.preventDefault();
+				state.selectFocusedDate();
+				break;
+			case "Escape":
+				if ("anchorDate" in state && typeof state.anchorDate === "function" && state.anchorDate() && "setAnchorDate" in state && typeof state.setAnchorDate === "function") {
+					e.preventDefault();
+					e.stopPropagation();
+					state.setAnchorDate(null);
+					if ("setDragging" in state && typeof state.setDragging === "function") state.setDragging(false);
+				}
+				break;
+		}
+	};
+	const isMultiSelectable = () => {
+		if ("highlightedRange" in state) return true;
+		return "selectionMode" in state && typeof state.selectionMode === "function" && state.selectionMode() === "multiple";
+	};
+	const visibleRangeDescription = createMemo(() => {
+		const gridProps = access(props);
+		return formatVisibleRangeDescription(gridProps.startDate ?? state.visibleRange().start, gridProps.endDate ?? state.visibleRange().end, state.timeZone, state.locale());
+	});
+	const gridProps = createMemo(() => {
+		const data = getCalendarHookData(state);
+		return {
+			role: "grid",
+			"aria-label": [data?.ariaLabel, visibleRangeDescription()].filter(Boolean).join(", ") || void 0,
+			"aria-labelledby": data?.ariaLabelledBy,
+			"aria-readonly": state.isReadOnly() || void 0,
+			"aria-disabled": state.isDisabled() || void 0,
+			"aria-multiselectable": isMultiSelectable() || void 0,
+			tabIndex: state.isFocused() ? 0 : -1,
+			onFocus: () => state.setFocused(true),
+			onBlur: () => state.setFocused(false),
+			onKeyDown: handleKeyDown
+		};
+	});
+	const headerProps = createMemo(() => ({}));
+	return {
+		get gridProps() {
+			return gridProps();
+		},
+		get headerProps() {
+			return headerProps();
+		},
+		get weekDays() {
+			return weekDays();
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createCalendarCell.ts
+/**
+* createCalendarCell hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a calendar cell.
+* Based on @react-aria/calendar useCalendarCell
+*/
+/**
+* Provides the behavior and accessibility implementation for a calendar cell.
+*/
+function createCalendarCell(props, state, ref) {
+	const getProps = () => access(props);
+	const [isPressed, setIsPressed] = createSignal(false);
+	const { focusProps, isFocusVisible: isRingFocusVisible } = createFocusRing();
+	const timeZone = getLocalTimeZone();
+	const inheritedLocale = useLocale();
+	const stateWithLocale = state;
+	const locale = () => stateWithLocale.locale?.() ?? inheritedLocale().locale;
+	let ignoreNextClick = false;
+	const date = createMemo(() => getProps().date);
+	const isSelected = createMemo(() => state.isSelected(date()));
+	const isFocused = createMemo(() => state.isCellFocused(date()));
+	const isInvalid = createMemo(() => state.isValueInvalid() && isSelected());
+	const isDisabled = createMemo(() => {
+		return getProps().isDisabled || state.isCellDisabled(date());
+	});
+	const isUnavailable = createMemo(() => state.isCellUnavailable(date()));
+	const isOutsideMonth = createMemo(() => getProps().isOutsideMonth ?? state.isOutsideVisibleRange(date()));
+	const isToday$2 = createMemo(() => isToday(date(), timeZone));
+	const isCellFocusVisible = createMemo(() => isFocused() && isRingFocusVisible() && getInteractionModality() !== null);
+	const formattedDate = createMemo(() => {
+		const d = date();
+		return new DateFormatter(locale(), {
+			day: "numeric",
+			timeZone,
+			calendar: d.calendar.identifier
+		}).formatToParts(d.toDate(timeZone)).find((part) => part.type === "day")?.value ?? d.day.toString();
+	});
+	const handlePointerDown = (e) => {
+		if (!isDisabled() && !isUnavailable()) {
+			setIsPressed(true);
+			state.selectDate(date());
+			ignoreNextClick = true;
+			e.preventDefault();
+		}
+	};
+	const handleClick = () => {
+		if (ignoreNextClick) {
+			ignoreNextClick = false;
+			return;
+		}
+		if (!isDisabled() && !isUnavailable()) state.selectDate(date());
+	};
+	const handlePointerUp = () => {
+		setIsPressed(false);
+	};
+	createEffect(() => {
+		const element = ref?.();
+		if (element && isFocused()) {
+			focusSafely(element);
+			if (getInteractionModality() !== "pointer" && document.activeElement === element) scrollIntoViewport(element, { containingElement: getScrollParent(element) });
+		}
+	});
+	const cellProps = createMemo(() => ({
+		role: "gridcell",
+		"aria-disabled": isDisabled() || isUnavailable() || void 0,
+		"aria-selected": isSelected() || void 0,
+		"aria-invalid": isInvalid() || void 0
+	}));
+	const buttonProps = createMemo(() => {
+		const d = date();
+		let label = new DateFormatter(locale(), {
+			weekday: "long",
+			year: "numeric",
+			month: "long",
+			day: "numeric",
+			calendar: d.calendar.identifier
+		}).format(d.toDate(timeZone));
+		if (isToday$2()) label = formatCalendarLabel(locale(), isSelected() ? "todayDateSelected" : "todayDate", { date: label });
+		else if (isSelected()) label = formatCalendarLabel(locale(), "dateSelected", { date: label });
+		const errorMessageId = getCalendarHookData(state)?.errorMessageId;
+		return mergeProps(focusProps, {
+			role: "button",
+			tabIndex: isFocused() ? 0 : -1,
+			"aria-label": label,
+			"aria-disabled": isDisabled() || isUnavailable() || void 0,
+			"aria-invalid": isInvalid() || void 0,
+			"aria-describedby": isInvalid() ? errorMessageId : void 0,
+			"aria-pressed": isPressed() || void 0,
+			"data-focus-visible": isCellFocusVisible() || void 0,
+			disabled: isDisabled() || isUnavailable(),
+			onClick: handleClick,
+			onPointerDown: handlePointerDown,
+			onPointerUp: handlePointerUp,
+			onPointerLeave: handlePointerUp,
+			onFocus: () => {
+				if (!state.isCellFocused(d)) state.setFocusedDate(d);
+				state.setFocused(true);
+			}
+		});
+	});
+	return {
+		get cellProps() {
+			return cellProps();
+		},
+		get buttonProps() {
+			return buttonProps();
+		},
+		get isSelected() {
+			return isSelected();
+		},
+		get isFocused() {
+			return isFocused();
+		},
+		get isFocusVisible() {
+			return isCellFocusVisible();
+		},
+		get isDisabled() {
+			return isDisabled();
+		},
+		get isUnavailable() {
+			return isUnavailable();
+		},
+		get isInvalid() {
+			return isInvalid();
+		},
+		get isOutsideMonth() {
+			return isOutsideMonth();
+		},
+		get isToday() {
+			return isToday$2();
+		},
+		get isPressed() {
+			return isPressed();
+		},
+		get formattedDate() {
+			return formattedDate();
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createRangeCalendar.ts
+/**
+* createRangeCalendar hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a range calendar component.
+* Based on @react-aria/calendar useRangeCalendar
+*/
+/**
+* Provides the behavior and accessibility implementation for a range calendar component.
+*/
+function createRangeCalendar(props, state) {
+	const getProps = () => access(props);
+	const id = createId(getProps().id);
+	const titleId = createId();
+	const errorMessageId = createId(getProps().errorMessageId);
+	const title = createMemo(() => state.title());
+	const visibleRangeDescription = createMemo(() => {
+		const range = state.visibleRange();
+		return formatVisibleRangeDescription(range.start, range.end, state.timeZone, state.locale());
+	});
+	const calendarLabel = createMemo(() => {
+		return [getProps()["aria-label"], visibleRangeDescription()].filter(Boolean).join(", ");
+	});
+	const selectedDateDescription = createMemo(() => formatSelectedDateDescription(state));
+	const initialProps = getProps();
+	const existingHookData = getCalendarHookData(state);
+	setCalendarHookData(state, {
+		errorMessageId: initialProps.errorMessage || initialProps.errorMessageId ? errorMessageId : existingHookData?.errorMessageId,
+		ariaLabel: initialProps["aria-label"],
+		ariaLabelledBy: initialProps["aria-labelledby"],
+		get selectedDateDescription() {
+			return selectedDateDescription();
+		}
+	});
+	const prevButtonProps = createMemo(() => {
+		const isDisabled = getProps().isDisabled || state.isDisabled() || state.isPreviousVisibleRangeInvalid();
+		return {
+			"aria-label": "Previous month",
+			onClick: () => {
+				if (!isDisabled) state.focusPreviousPage();
+			},
+			disabled: isDisabled,
+			tabIndex: -1
+		};
+	});
+	const nextButtonProps = createMemo(() => {
+		const isDisabled = getProps().isDisabled || state.isDisabled() || state.isNextVisibleRangeInvalid();
+		return {
+			"aria-label": "Next month",
+			onClick: () => {
+				if (!isDisabled) state.focusNextPage();
+			},
+			disabled: isDisabled,
+			tabIndex: -1
+		};
+	});
+	const titleProps = createMemo(() => ({
+		id: titleId,
+		"aria-live": "polite"
+	}));
+	const errorMessageProps = createMemo(() => ({ id: errorMessageId }));
+	const calendarProps = createMemo(() => {
+		const p = getProps();
+		return mergeProps({
+			id,
+			role: "application",
+			"aria-labelledby": p["aria-labelledby"],
+			"aria-label": calendarLabel(),
+			"aria-describedby": p["aria-describedby"],
+			"aria-details": p["aria-details"]
+		});
+	});
+	return {
+		get calendarProps() {
+			return calendarProps();
+		},
+		get prevButtonProps() {
+			return prevButtonProps();
+		},
+		get nextButtonProps() {
+			return nextButtonProps();
+		},
+		get titleProps() {
+			return titleProps();
+		},
+		get errorMessageProps() {
+			return errorMessageProps();
+		},
+		get title() {
+			return title();
+		}
+	};
+}
+//#endregion
+//#region src/calendar/createRangeCalendarCell.ts
+/**
+* createRangeCalendarCell hook for Solidaria
+*
+* Provides the behavior and accessibility implementation for a range calendar cell.
+* Based on @react-aria/calendar useCalendarCell (with range support)
+*/
+/**
+* Provides the behavior and accessibility implementation for a range calendar cell.
+*/
+function createRangeCalendarCell(props, state, ref) {
+	const getProps = () => access(props);
+	const [isPressed, setIsPressed] = createSignal(false);
+	const timeZone = getLocalTimeZone();
+	const date = createMemo(() => getProps().date);
+	const isSelected = createMemo(() => state.isSelected(date()));
+	const isSelectionStart = createMemo(() => state.isSelectionStart(date()));
+	const isSelectionEnd = createMemo(() => state.isSelectionEnd(date()));
+	const isFocused = createMemo(() => state.isCellFocused(date()));
+	const isInvalid = createMemo(() => {
+		const range = state.highlightedRange();
+		const d = date();
+		return state.isValueInvalid() && !state.anchorDate() && !!range && d.compare(range.start) >= 0 && d.compare(range.end) <= 0;
+	});
+	const isDisabled = createMemo(() => {
+		return getProps().isDisabled || state.isCellDisabled(date());
+	});
+	const isUnavailable = createMemo(() => state.isCellUnavailable(date()));
+	const isSelectable = createMemo(() => !isDisabled() && !isUnavailable());
+	const isOutsideMonth = createMemo(() => {
+		return getProps().isOutsideMonth ?? state.isOutsideVisibleRange(date());
+	});
+	const isToday$1 = createMemo(() => isToday(date(), timeZone));
+	const descriptionProps = createDescription(createMemo(() => {
+		if (!isFocused() || state.isReadOnly() || !isSelectable()) return;
+		return formatCalendarPrompt(state.locale(), state.anchorDate() ? "finishRangeSelectionPrompt" : "startRangeSelectionPrompt");
+	}));
+	const formattedDate = createMemo(() => {
+		return date().day.toString();
+	});
+	const handlePointerDown = (e) => {
+		if (isSelectable()) {
+			setIsPressed(true);
+			state.selectDate(date());
+			e.preventDefault();
+		}
+	};
+	const handleClick = () => {
+		if (isSelectable()) state.selectDate(date());
+	};
+	const handlePointerUp = () => {
+		setIsPressed(false);
+	};
+	const handlePointerEnter = () => {
+		if (state.isDragging() && isSelectable()) state.setFocusedDate(date());
+	};
+	createEffect(() => {
+		const element = ref?.();
+		if (element && isFocused()) focusSafely(element);
+	});
+	const cellProps = createMemo(() => ({
+		role: "gridcell",
+		"aria-disabled": isDisabled() || isUnavailable() || void 0,
+		"aria-selected": isSelected() || void 0,
+		"aria-invalid": isInvalid() || void 0
+	}));
+	const buttonProps = createMemo(() => {
+		const d = date();
+		const formatter = new DateFormatter(state.locale(), {
+			weekday: "long",
+			year: "numeric",
+			month: "long",
+			day: "numeric",
+			era: getEraFormat(d),
+			calendar: d.calendar.identifier,
+			timeZone
+		});
+		const hookData = getCalendarHookData(state);
+		let label = "";
+		if (hookData?.selectedDateDescription && !state.anchorDate() && state.value() && (state.isSelectionStart(d) || state.isSelectionEnd(d))) label = `${hookData.selectedDateDescription}, `;
+		label += formatter.format(d.toDate(timeZone));
+		if (isToday$1()) label = formatCalendarLabel(state.locale(), isSelected() ? "todayDateSelected" : "todayDate", { date: label });
+		else if (isSelected()) label = formatCalendarLabel(state.locale(), "dateSelected", { date: label });
+		const errorMessageId = hookData?.errorMessageId;
+		const describedByIds = [isInvalid() ? errorMessageId : void 0, descriptionProps["aria-describedby"]].filter(Boolean);
+		return {
+			role: "button",
+			tabIndex: isFocused() ? 0 : -1,
+			"aria-label": label,
+			"aria-disabled": isDisabled() || isUnavailable() || void 0,
+			"aria-invalid": isInvalid() || void 0,
+			"aria-describedby": describedByIds.length ? describedByIds.join(" ") : void 0,
+			"aria-pressed": isPressed() || void 0,
+			disabled: isDisabled() || isUnavailable(),
+			onClick: handleClick,
+			onPointerDown: handlePointerDown,
+			onPointerUp: handlePointerUp,
+			onPointerLeave: handlePointerUp,
+			onPointerEnter: handlePointerEnter,
+			onFocus: () => {
+				if (!state.isCellFocused(d)) state.setFocusedDate(d);
+				state.setFocused(true);
+			}
+		};
+	});
+	return {
+		get cellProps() {
+			return cellProps();
+		},
+		get buttonProps() {
+			return buttonProps();
+		},
+		get isSelected() {
+			return isSelected();
+		},
+		get isSelectionStart() {
+			return isSelectionStart();
+		},
+		get isSelectionEnd() {
+			return isSelectionEnd();
+		},
+		get isFocused() {
+			return isFocused();
+		},
+		get isDisabled() {
+			return isDisabled();
+		},
+		get isUnavailable() {
+			return isUnavailable();
+		},
+		get isInvalid() {
+			return isInvalid();
+		},
+		get isOutsideMonth() {
+			return isOutsideMonth();
+		},
+		get isToday() {
+			return isToday$1();
+		},
+		get isPressed() {
+			return isPressed();
+		},
+		get formattedDate() {
+			return formattedDate();
+		}
+	};
+}
+//#endregion
+export { createCalendarYearPicker as a, createCalendarGrid as i, createRangeCalendar as n, createCalendarMonthPicker as o, createCalendarCell as r, createCalendar as s, createRangeCalendarCell as t };
+
+//# sourceMappingURL=calendar.jsx.map