bootstrap-vue-next
Version:
Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development
1,516 lines • 168 kB
JavaScript
require("./chunk-CoQrYLCe.js");
const require_dist = require("./dist-BJ15ThEs.js");
const require_useDefaults = require("./useDefaults-DsLf4iRY.js");
const require_useId = require("./useId-DHrBgM7P.js");
const require_useDateField = require("./useDateField-COTiu3aN.js");
const require_VisuallyHidden = require("./VisuallyHidden-DaN947I0.js");
const require_useForwardExpose = require("./useForwardExpose-DrJOy0jY.js");
const require_PopperContent = require("./PopperContent-CSwv2Fih.js");
const require_useKbd = require("./useKbd-ZZushx7D.js");
const require_DateRangeFieldInput = require("./DateRangeFieldInput-Ce7PM3PJ.js");
let vue = require("vue");
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/date/calendar.js
/**
* Retrieves an array of date values representing the days between
* the provided start and end dates.
*/
function getDaysBetween(start, end) {
const days = [];
let dCurrent = start.add({ days: 1 });
const dEnd = end;
while (dCurrent.compare(dEnd) < 0) {
days.push(dCurrent);
dCurrent = dCurrent.add({ days: 1 });
}
return days;
}
function createMonth(props) {
const { dateObj, weekStartsOn, fixedWeeks, locale } = props;
const daysInMonth = require_useDateField.getDaysInMonth(dateObj);
const datesArray = Array.from({ length: daysInMonth }, (_, i) => dateObj.set({ day: i + 1 }));
const firstDayOfMonth = require_useDateField.$14e0f24ef4ac5c92$export$a5a3b454ada2268e(dateObj);
const lastDayOfMonth = require_useDateField.$14e0f24ef4ac5c92$export$a2258d9c4118825c(dateObj);
const lastSunday = require_useDateField.getLastFirstDayOfWeek(firstDayOfMonth, weekStartsOn, locale);
const nextSaturday = require_useDateField.getNextLastDayOfWeek(lastDayOfMonth, weekStartsOn, locale);
const lastMonthDays = getDaysBetween(lastSunday.subtract({ days: 1 }), firstDayOfMonth);
const nextMonthDays = getDaysBetween(lastDayOfMonth, nextSaturday.add({ days: 1 }));
const totalDays = lastMonthDays.length + datesArray.length + nextMonthDays.length;
if (fixedWeeks && totalDays < 42) {
const extraDays = 42 - totalDays;
let startFrom = nextMonthDays[nextMonthDays.length - 1];
if (!startFrom) startFrom = require_useDateField.$14e0f24ef4ac5c92$export$a2258d9c4118825c(dateObj);
const extraDaysArray = Array.from({ length: extraDays }, (_, i) => {
const incr = i + 1;
return startFrom.add({ days: incr });
});
nextMonthDays.push(...extraDaysArray);
}
const allDays = lastMonthDays.concat(datesArray, nextMonthDays);
return {
value: dateObj,
cells: allDays,
rows: require_useDateField.chunk(allDays, 7)
};
}
function createMonths(props) {
const { numberOfMonths, dateObj, ...monthProps } = props;
const months = [];
if (!numberOfMonths || numberOfMonths === 1) {
months.push(createMonth({
...monthProps,
dateObj
}));
return months;
}
months.push(createMonth({
...monthProps,
dateObj
}));
for (let i = 1; i < numberOfMonths; i++) {
const nextMonth = dateObj.add({ months: i });
months.push(createMonth({
...monthProps,
dateObj: nextMonth
}));
}
return months;
}
/**
* It's better to use `getWeekStart` from `@internationalized/date`,
* but sadly it is not yet exported from the package.
* And the `Intl.Locale` API is not supported well enough yet.
*/
function getWeekStartsOn(locale) {
return (1 - require_useDateField.$14e0f24ef4ac5c92$export$2061056d06d7cdf7(new require_useDateField.$35ea8db9cb2ccb90$export$99faa760c7908e4f(2025, 1, 6), locale) + 7) % 7;
}
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/useCalendar.js
function useCalendarState(props) {
function isDateSelected(dateObj) {
if (Array.isArray(props.date.value)) return props.date.value.some((d) => require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(d, dateObj));
else if (!props.date.value) return false;
else return require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.date.value, dateObj);
}
return {
isDateSelected,
isInvalid: (0, vue.computed)(() => {
if (Array.isArray(props.date.value)) {
if (!props.date.value.length) return false;
for (const dateObj of props.date.value) {
if (props.isDateDisabled?.(dateObj)) return true;
if (props.isDateUnavailable?.(dateObj)) return true;
}
} else {
if (!props.date.value) return false;
if (props.isDateDisabled?.(props.date.value)) return true;
if (props.isDateUnavailable?.(props.date.value)) return true;
}
return false;
}),
hasSelectedDate: (0, vue.computed)(() => {
return Array.isArray(props.date.value) ? props.date.value.length > 0 : !!props.date.value;
}),
isSelectedDateDisabled: (0, vue.computed)(() => {
if (Array.isArray(props.date.value)) {
if (!props.date.value.length) return false;
return props.date.value.some((dateObj) => props.isDateDisabled?.(dateObj));
}
if (!props.date.value) return false;
return !!props.isDateDisabled?.(props.date.value);
})
};
}
function handleNextDisabled(lastPeriodInView, nextPageFunc) {
const firstPeriodOfNextPage = nextPageFunc(lastPeriodInView);
const diff = firstPeriodOfNextPage.compare(lastPeriodInView);
const duration = {};
if (diff >= 7) duration.day = 1;
if (diff >= require_useDateField.getDaysInMonth(lastPeriodInView)) duration.month = 1;
return firstPeriodOfNextPage.set({ ...duration });
}
function handlePrevDisabled(firstPeriodInView, prevPageFunc) {
const lastPeriodOfPrevPage = prevPageFunc(firstPeriodInView);
const diff = firstPeriodInView.compare(lastPeriodOfPrevPage);
const duration = {};
if (diff >= 7) duration.day = 35;
if (diff >= require_useDateField.getDaysInMonth(firstPeriodInView)) duration.month = 13;
return lastPeriodOfPrevPage.set({ ...duration });
}
function handleNextPage(date, nextPageFunc) {
return nextPageFunc(date);
}
function handlePrevPage(date, prevPageFunc) {
return prevPageFunc(date);
}
function useCalendar(props) {
const formatter = require_useDateField.useDateFormatter(props.locale.value);
const headingFormatOptions = (0, vue.computed)(() => {
const options = { calendar: props.placeholder.value.calendar.identifier };
if (props.placeholder.value.calendar.identifier === "gregory" && props.placeholder.value.era === "BC") options.era = "short";
return options;
});
const grid = (0, vue.ref)(createMonths({
dateObj: props.placeholder.value,
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
}));
const visibleView = (0, vue.computed)(() => {
return grid.value.map((month) => month.value);
});
function isOutsideVisibleView(date) {
return !visibleView.value.some((month) => require_useDateField.$14e0f24ef4ac5c92$export$5a8da0c44a3afdf2(date, month));
}
const isNextButtonDisabled = (nextPageFunc) => {
if (!props.maxValue.value || !grid.value.length) return false;
if (props.disabled.value) return true;
const lastPeriodInView = grid.value[grid.value.length - 1].value;
if (!nextPageFunc && !props.nextPage.value) return require_useDateField.isAfter(lastPeriodInView.add({ months: 1 }).set({ day: 1 }), props.maxValue.value);
return require_useDateField.isAfter(handleNextDisabled(lastPeriodInView, nextPageFunc || props.nextPage.value), props.maxValue.value);
};
const isPrevButtonDisabled = (prevPageFunc) => {
if (!props.minValue.value || !grid.value.length) return false;
if (props.disabled.value) return true;
const firstPeriodInView = grid.value[0].value;
if (!prevPageFunc && !props.prevPage.value) return require_useDateField.isBefore(firstPeriodInView.subtract({ months: 1 }).set({ day: 35 }), props.minValue.value);
return require_useDateField.isBefore(handlePrevDisabled(firstPeriodInView, prevPageFunc || props.prevPage.value), props.minValue.value);
};
function isDateDisabled(dateObj) {
if (props.isDateDisabled?.(dateObj) || props.disabled.value) return true;
if (props.maxValue.value && require_useDateField.isAfter(dateObj, props.maxValue.value)) return true;
if (props.minValue.value && require_useDateField.isBefore(dateObj, props.minValue.value)) return true;
return false;
}
const isDateUnavailable = (date) => {
if (props.isDateUnavailable?.(date)) return true;
return false;
};
const weekdays = (0, vue.computed)(() => {
if (!grid.value.length) return [];
return grid.value[0].rows[0].map((date) => {
return formatter.dayOfWeek(require_useDateField.toDate(date), props.weekdayFormat.value);
});
});
const nextPage = (nextPageFunc) => {
const firstDate = grid.value[0].value;
if (!nextPageFunc && !props.nextPage.value) {
const newGrid$1 = createMonths({
dateObj: firstDate.add({ months: props.pagedNavigation.value ? props.numberOfMonths.value : 1 }),
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
grid.value = newGrid$1;
props.placeholder.value = newGrid$1[0].value.set({ day: 1 });
return;
}
const newGrid = createMonths({
dateObj: handleNextPage(firstDate, nextPageFunc || props.nextPage.value),
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
grid.value = newGrid;
const duration = {};
if (!nextPageFunc) {
const diff = newGrid[0].value.compare(firstDate);
if (diff >= require_useDateField.getDaysInMonth(firstDate)) duration.day = 1;
if (diff >= 365) duration.month = 1;
}
props.placeholder.value = newGrid[0].value.set({ ...duration });
};
const prevPage = (prevPageFunc) => {
const firstDate = grid.value[0].value;
if (!prevPageFunc && !props.prevPage.value) {
const newGrid$1 = createMonths({
dateObj: firstDate.subtract({ months: props.pagedNavigation.value ? props.numberOfMonths.value : 1 }),
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
grid.value = newGrid$1;
props.placeholder.value = newGrid$1[0].value.set({ day: 1 });
return;
}
const newGrid = createMonths({
dateObj: handlePrevPage(firstDate, prevPageFunc || props.prevPage.value),
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
grid.value = newGrid;
const duration = {};
if (!prevPageFunc) {
const diff = firstDate.compare(newGrid[0].value);
if (diff >= require_useDateField.getDaysInMonth(firstDate)) duration.day = 1;
if (diff >= 365) duration.month = 1;
}
props.placeholder.value = newGrid[0].value.set({ ...duration });
};
(0, vue.watch)(props.placeholder, (value) => {
if (visibleView.value.some((month) => require_useDateField.$14e0f24ef4ac5c92$export$5a8da0c44a3afdf2(month, value))) return;
grid.value = createMonths({
dateObj: value,
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
});
(0, vue.watch)([
props.locale,
props.weekStartsOn,
props.fixedWeeks,
props.numberOfMonths
], () => {
grid.value = createMonths({
dateObj: props.placeholder.value,
weekStartsOn: props.weekStartsOn.value,
locale: props.locale.value,
fixedWeeks: props.fixedWeeks.value,
numberOfMonths: props.numberOfMonths.value
});
});
const headingValue = (0, vue.computed)(() => {
if (!grid.value.length) return "";
if (props.locale.value !== formatter.getLocale()) formatter.setLocale(props.locale.value);
if (grid.value.length === 1) {
const month = grid.value[0].value;
return `${formatter.fullMonthAndYear(require_useDateField.toDate(month), headingFormatOptions.value)}`;
}
const startMonth = require_useDateField.toDate(grid.value[0].value);
const endMonth = require_useDateField.toDate(grid.value[grid.value.length - 1].value);
const startMonthName = formatter.fullMonth(startMonth, headingFormatOptions.value);
const endMonthName = formatter.fullMonth(endMonth, headingFormatOptions.value);
const startMonthYear = formatter.fullYear(startMonth, headingFormatOptions.value);
const endMonthYear = formatter.fullYear(endMonth, headingFormatOptions.value);
return startMonthYear === endMonthYear ? `${startMonthName} - ${endMonthName} ${endMonthYear}` : `${startMonthName} ${startMonthYear} - ${endMonthName} ${endMonthYear}`;
});
return {
isDateDisabled,
isDateUnavailable,
isNextButtonDisabled,
isPrevButtonDisabled,
grid,
weekdays,
visibleView,
isOutsideVisibleView,
formatter,
nextPage,
prevPage,
headingValue,
fullCalendarLabel: (0, vue.computed)(() => `${props.calendarLabel.value ?? "Event Date"}, ${headingValue.value}`),
isPlaceholderFocusable: (0, vue.computed)(() => {
return !(isDateDisabled(props.placeholder.value) || isDateUnavailable(props.placeholder.value) || isOutsideVisibleView(props.placeholder.value));
}),
firstFocusableDate: (0, vue.computed)(() => {
for (const month of grid.value) {
if (props.minValue.value && require_useDateField.isBefore(month.value, props.minValue.value)) continue;
const daysInMonth = require_useDateField.getDaysInMonth(month.value);
const startDay = props.minValue.value && require_useDateField.$14e0f24ef4ac5c92$export$a18c89cbd24170ff(props.minValue.value, month.value) ? props.minValue.value.day : 1;
for (let day = startDay; day <= daysInMonth; day++) {
const date = month.value.set({ day });
if (isDateDisabled(date) || isDateUnavailable(date)) continue;
return date;
}
}
})
};
}
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarRoot.js
var _hoisted_1$3 = { style: {
"border": "0px",
"clip": "rect(0px, 0px, 0px, 0px)",
"clip-path": "inset(50%)",
"height": "1px",
"margin": "-1px",
"overflow": "hidden",
"padding": "0px",
"position": "absolute",
"white-space": "nowrap",
"width": "1px"
} };
var _hoisted_2$1 = {
role: "heading",
"aria-level": "2"
};
var [injectCalendarRootContext, provideCalendarRootContext] = require_VisuallyHidden.createContext("CalendarRoot");
var CalendarRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarRoot",
props: {
defaultValue: {
type: null,
required: false,
default: void 0
},
defaultPlaceholder: {
type: null,
required: false
},
placeholder: {
type: null,
required: false,
default: void 0
},
pagedNavigation: {
type: Boolean,
required: false,
default: false
},
preventDeselect: {
type: Boolean,
required: false,
default: false
},
weekStartsOn: {
type: Number,
required: false
},
weekdayFormat: {
type: String,
required: false,
default: "narrow"
},
calendarLabel: {
type: String,
required: false
},
fixedWeeks: {
type: Boolean,
required: false,
default: false
},
maxValue: {
type: null,
required: false
},
minValue: {
type: null,
required: false
},
locale: {
type: String,
required: false
},
numberOfMonths: {
type: Number,
required: false,
default: 1
},
disabled: {
type: Boolean,
required: false,
default: false
},
readonly: {
type: Boolean,
required: false,
default: false
},
initialFocus: {
type: Boolean,
required: false,
default: false
},
isDateDisabled: {
type: Function,
required: false,
default: void 0
},
isDateUnavailable: {
type: Function,
required: false,
default: void 0
},
dir: {
type: String,
required: false
},
nextPage: {
type: Function,
required: false
},
prevPage: {
type: Function,
required: false
},
modelValue: {
type: null,
required: false
},
multiple: {
type: Boolean,
required: false,
default: false
},
disableDaysOutsideCurrentView: {
type: Boolean,
required: false,
default: false
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "div"
}
},
emits: ["update:modelValue", "update:placeholder"],
setup(__props, { emit: __emit }) {
const props = __props;
const emits = __emit;
const { disabled, readonly, initialFocus, pagedNavigation, weekdayFormat, fixedWeeks, multiple, minValue, maxValue, numberOfMonths, preventDeselect, isDateDisabled: propsIsDateDisabled, isDateUnavailable: propsIsDateUnavailable, calendarLabel, defaultValue, nextPage: propsNextPage, prevPage: propsPrevPage, dir: propDir, locale: propLocale, disableDaysOutsideCurrentView } = (0, vue.toRefs)(props);
const { primitiveElement, currentElement: parentElement } = require_VisuallyHidden.usePrimitiveElement();
const locale = require_useDateField.useLocale(propLocale);
const dir = require_VisuallyHidden.useDirection(propDir);
const weekStartsOn = (0, vue.computed)(() => props.weekStartsOn ?? getWeekStartsOn(locale.value));
const modelValue = require_dist.useVModel(props, "modelValue", emits, {
defaultValue: defaultValue.value,
passive: props.modelValue === void 0
});
const defaultDate = require_useDateField.getDefaultDate({
defaultPlaceholder: props.placeholder,
defaultValue: modelValue.value,
locale: props.locale
});
const placeholder = require_dist.useVModel(props, "placeholder", emits, {
defaultValue: props.defaultPlaceholder ?? defaultDate.copy(),
passive: props.placeholder === void 0
});
function onPlaceholderChange(value) {
placeholder.value = value.copy();
}
const { fullCalendarLabel, headingValue, isDateDisabled, isDateUnavailable, isNextButtonDisabled, isPrevButtonDisabled, weekdays, isOutsideVisibleView, nextPage, prevPage, formatter, grid, isPlaceholderFocusable, firstFocusableDate } = useCalendar({
locale,
placeholder,
weekStartsOn,
fixedWeeks,
numberOfMonths,
minValue,
maxValue,
disabled,
weekdayFormat,
pagedNavigation,
isDateDisabled: propsIsDateDisabled.value,
isDateUnavailable: propsIsDateUnavailable.value,
calendarLabel,
nextPage: propsNextPage,
prevPage: propsPrevPage
});
const { isInvalid, isDateSelected, hasSelectedDate, isSelectedDateDisabled } = useCalendarState({
date: modelValue,
isDateDisabled,
isDateUnavailable
});
(0, vue.watch)(modelValue, (_modelValue) => {
if (Array.isArray(_modelValue) && _modelValue.length) {
const lastValue = _modelValue[_modelValue.length - 1];
if (lastValue && !require_useDateField.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(placeholder.value, lastValue)) onPlaceholderChange(lastValue);
} else if (!Array.isArray(_modelValue) && _modelValue && !require_useDateField.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(placeholder.value, _modelValue)) onPlaceholderChange(_modelValue);
});
function onDateChange(value) {
if (!multiple.value) {
if (!modelValue.value) {
modelValue.value = value.copy();
return;
}
if (!preventDeselect.value && require_useDateField.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee(modelValue.value, value)) {
placeholder.value = value.copy();
modelValue.value = void 0;
} else modelValue.value = value.copy();
} else if (!modelValue.value) modelValue.value = [value.copy()];
else if (Array.isArray(modelValue.value)) {
if (modelValue.value.findIndex((date) => require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(date, value)) === -1) modelValue.value = [...modelValue.value, value];
else if (!preventDeselect.value) {
const next = modelValue.value.filter((date) => !require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(date, value));
if (!next.length) {
placeholder.value = value.copy();
modelValue.value = void 0;
return;
}
modelValue.value = next.map((date) => date.copy());
}
}
}
(0, vue.onMounted)(() => {
if (initialFocus.value) require_useDateField.handleCalendarInitialFocus(parentElement.value);
});
provideCalendarRootContext({
isDateUnavailable,
dir,
isDateDisabled,
locale,
formatter,
modelValue,
placeholder,
disabled,
initialFocus,
pagedNavigation,
grid,
weekDays: weekdays,
weekStartsOn,
weekdayFormat,
fixedWeeks,
multiple,
numberOfMonths,
readonly,
preventDeselect,
fullCalendarLabel,
headingValue,
isInvalid,
isDateSelected,
isNextButtonDisabled,
isPrevButtonDisabled,
isOutsideVisibleView,
nextPage,
prevPage,
parentElement,
onPlaceholderChange,
onDateChange,
disableDaysOutsideCurrentView,
minValue,
maxValue,
isPlaceholderFocusable,
firstFocusableDate,
hasSelectedDate,
isSelectedDateDisabled
});
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), {
ref_key: "primitiveElement",
ref: primitiveElement,
as: _ctx.as,
"as-child": _ctx.asChild,
"aria-label": (0, vue.unref)(fullCalendarLabel),
"data-readonly": (0, vue.unref)(readonly) ? "" : void 0,
"data-disabled": (0, vue.unref)(disabled) ? "" : void 0,
"data-invalid": (0, vue.unref)(isInvalid) ? "" : void 0,
dir: (0, vue.unref)(dir)
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {
date: (0, vue.unref)(placeholder),
grid: (0, vue.unref)(grid),
weekDays: (0, vue.unref)(weekdays),
weekStartsOn: weekStartsOn.value,
locale: (0, vue.unref)(locale),
fixedWeeks: (0, vue.unref)(fixedWeeks),
modelValue: (0, vue.unref)(modelValue)
}), (0, vue.createElementVNode)("div", _hoisted_1$3, [(0, vue.createElementVNode)("div", _hoisted_2$1, (0, vue.toDisplayString)((0, vue.unref)(fullCalendarLabel)), 1)])]),
_: 3
}, 8, [
"as",
"as-child",
"aria-label",
"data-readonly",
"data-disabled",
"data-invalid",
"dir"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarCell.js
var CalendarCell_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarCell",
props: {
date: {
type: null,
required: true
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "td"
}
},
setup(__props) {
const rootContext = injectCalendarRootContext();
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), {
as: _ctx.as,
"as-child": _ctx.asChild,
role: "gridcell",
"aria-selected": (0, vue.unref)(rootContext).isDateSelected(_ctx.date) ? true : void 0,
"aria-disabled": (0, vue.unref)(rootContext).isDateDisabled(_ctx.date) || (0, vue.unref)(rootContext).isDateUnavailable?.(_ctx.date) || (0, vue.unref)(rootContext).disableDaysOutsideCurrentView.value,
"data-disabled": (0, vue.unref)(rootContext).isDateDisabled(_ctx.date) || (0, vue.unref)(rootContext).disableDaysOutsideCurrentView.value ? "" : void 0
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 8, [
"as",
"as-child",
"aria-selected",
"aria-disabled",
"data-disabled"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarCellTrigger.js
var CalendarCellTrigger_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarCellTrigger",
props: {
day: {
type: null,
required: true
},
month: {
type: null,
required: true
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "div"
}
},
setup(__props) {
const props = __props;
const kbd = require_useKbd.useKbd();
const rootContext = injectCalendarRootContext();
const { primitiveElement, currentElement } = require_VisuallyHidden.usePrimitiveElement();
const dayValue = (0, vue.computed)(() => props.day.day.toLocaleString(rootContext.locale.value));
const labelText = (0, vue.computed)(() => {
return rootContext.formatter.custom(require_useDateField.toDate(props.day), {
weekday: "long",
month: "long",
day: "numeric",
year: "numeric"
});
});
const isUnavailable = (0, vue.computed)(() => rootContext.isDateUnavailable?.(props.day) ?? false);
const isDateToday = (0, vue.computed)(() => {
return require_useDateField.$14e0f24ef4ac5c92$export$629b0a497aa65267(props.day, require_useDateField.$14e0f24ef4ac5c92$export$aa8b41735afcabd2());
});
const isOutsideView = (0, vue.computed)(() => {
return !require_useDateField.$14e0f24ef4ac5c92$export$a18c89cbd24170ff(props.day, props.month);
});
const isOutsideVisibleView = (0, vue.computed)(() => rootContext.isOutsideVisibleView(props.day));
const isDisabled = (0, vue.computed)(() => rootContext.isDateDisabled(props.day) || rootContext.disableDaysOutsideCurrentView.value && isOutsideView.value);
const isFocusedDate = (0, vue.computed)(() => {
if (isOutsideView.value || isDisabled.value) return false;
if (!rootContext.disabled.value && rootContext.isPlaceholderFocusable.value && require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.placeholder.value)) return true;
if ((!rootContext.hasSelectedDate.value || rootContext.isSelectedDateDisabled.value) && !rootContext.isPlaceholderFocusable.value) return rootContext.firstFocusableDate.value && require_useDateField.$14e0f24ef4ac5c92$export$ea39ec197993aef0(props.day, rootContext.firstFocusableDate.value);
return false;
});
const isSelectedDate = (0, vue.computed)(() => rootContext.isDateSelected(props.day));
function changeDate(date) {
if (rootContext.readonly.value) return;
if (rootContext.isDateDisabled(date) || rootContext.isDateUnavailable?.(date)) return;
rootContext.onDateChange(date);
}
function handleClick() {
if (isDisabled.value) return;
changeDate(props.day);
}
function handleArrowKey(e) {
if (isDisabled.value) return;
e.preventDefault();
e.stopPropagation();
const parentElement = rootContext.parentElement.value;
const indexIncrementation = 7;
const sign = rootContext.dir.value === "rtl" ? -1 : 1;
switch (e.code) {
case kbd.ARROW_RIGHT:
shiftFocus(props.day, sign);
break;
case kbd.ARROW_LEFT:
shiftFocus(props.day, -sign);
break;
case kbd.ARROW_UP:
shiftFocus(props.day, -indexIncrementation);
break;
case kbd.ARROW_DOWN:
shiftFocus(props.day, indexIncrementation);
break;
case kbd.ENTER:
case kbd.SPACE_CODE: changeDate(props.day);
}
function shiftFocus(day, add) {
const candidateDayValue = day.add({ days: add });
if (rootContext.minValue.value && candidateDayValue.compare(rootContext.minValue.value) < 0 || rootContext.maxValue.value && candidateDayValue.compare(rootContext.maxValue.value) > 0) return;
const candidateDay = parentElement.querySelector(`[data-value='${candidateDayValue.toString()}']:not([data-outside-view])`);
if (!candidateDay) {
if (add > 0) {
if (rootContext.isNextButtonDisabled()) return;
rootContext.nextPage();
} else {
if (rootContext.isPrevButtonDisabled()) return;
rootContext.prevPage();
}
(0, vue.nextTick)(() => {
shiftFocus(day, add);
});
return;
}
if (candidateDay && candidateDay.hasAttribute("data-disabled")) return shiftFocus(candidateDayValue, add);
rootContext.onPlaceholderChange(candidateDayValue);
candidateDay?.focus();
}
}
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), {
ref_key: "primitiveElement",
ref: primitiveElement,
as: props.as,
"as-child": props.asChild,
role: "button",
"aria-label": labelText.value,
"data-reka-calendar-cell-trigger": "",
"aria-disabled": isDisabled.value || isUnavailable.value ? true : void 0,
"data-selected": isSelectedDate.value ? true : void 0,
"data-value": _ctx.day.toString(),
"data-disabled": isDisabled.value ? "" : void 0,
"data-unavailable": isUnavailable.value ? "" : void 0,
"data-today": isDateToday.value ? "" : void 0,
"data-outside-view": isOutsideView.value ? "" : void 0,
"data-outside-visible-view": isOutsideVisibleView.value ? "" : void 0,
"data-focused": isFocusedDate.value ? "" : void 0,
tabindex: isFocusedDate.value ? 0 : isOutsideView.value || isDisabled.value ? void 0 : -1,
onClick: handleClick,
onKeydown: [(0, vue.withKeys)(handleArrowKey, [
"up",
"down",
"left",
"right",
"space",
"enter"
]), _cache[0] || (_cache[0] = (0, vue.withKeys)((0, vue.withModifiers)(() => {}, ["prevent"]), ["enter"]))]
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {
dayValue: dayValue.value,
disabled: isDisabled.value,
today: isDateToday.value,
selected: isSelectedDate.value,
outsideView: isOutsideView.value,
outsideVisibleView: isOutsideVisibleView.value,
unavailable: isUnavailable.value
}, () => [(0, vue.createTextVNode)((0, vue.toDisplayString)(dayValue.value), 1)])]),
_: 3
}, 8, [
"as",
"as-child",
"aria-label",
"aria-disabled",
"data-selected",
"data-value",
"data-disabled",
"data-unavailable",
"data-today",
"data-outside-view",
"data-outside-visible-view",
"data-focused",
"tabindex"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarGrid.js
var CalendarGrid_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarGrid",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "table"
}
},
setup(__props) {
const props = __props;
const rootContext = injectCalendarRootContext();
const disabled = (0, vue.computed)(() => rootContext.disabled.value ? true : void 0);
const readonly = (0, vue.computed)(() => rootContext.readonly.value ? true : void 0);
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.mergeProps)(props, {
tabindex: "-1",
role: "application",
"aria-readonly": readonly.value,
"aria-disabled": disabled.value,
"data-readonly": readonly.value && "",
"data-disabled": disabled.value && ""
}), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16, [
"aria-readonly",
"aria-disabled",
"data-readonly",
"data-disabled"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarGridBody.js
var CalendarGridBody_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarGridBody",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "tbody"
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarGridHead.js
var CalendarGridHead_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarGridHead",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "thead"
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.mergeProps)(props, { "aria-hidden": "true" }), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarGridRow.js
var CalendarGridRow_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarGridRow",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "tr"
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarHeadCell.js
var CalendarHeadCell_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarHeadCell",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "th"
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarHeader.js
var CalendarHeader_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarHeader",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "div"
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarHeading.js
var CalendarHeading_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarHeading",
props: {
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "div"
}
},
setup(__props) {
const props = __props;
const rootContext = injectCalendarRootContext();
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), (0, vue.mergeProps)(props, { "data-disabled": (0, vue.unref)(rootContext).disabled.value ? "" : void 0 }), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { headingValue: (0, vue.unref)(rootContext).headingValue.value }, () => [(0, vue.createTextVNode)((0, vue.toDisplayString)((0, vue.unref)(rootContext).headingValue.value), 1)])]),
_: 3
}, 16, ["data-disabled"]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarNext.js
var CalendarNext_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarNext",
props: {
nextPage: {
type: Function,
required: false
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "button"
}
},
setup(__props) {
const props = __props;
const disabled = (0, vue.computed)(() => rootContext.disabled.value || rootContext.isNextButtonDisabled(props.nextPage));
const rootContext = injectCalendarRootContext();
function handleClick() {
if (disabled.value) return;
rootContext.nextPage(props.nextPage);
}
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), {
as: props.as,
"as-child": props.asChild,
"aria-label": "Next page",
type: props.as === "button" ? "button" : void 0,
"aria-disabled": disabled.value || void 0,
"data-disabled": disabled.value || void 0,
disabled: disabled.value,
onClick: handleClick
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = (0, vue.createTextVNode)(" Next page "))])]),
_: 3
}, 8, [
"as",
"as-child",
"type",
"aria-disabled",
"data-disabled",
"disabled"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Calendar/CalendarPrev.js
var CalendarPrev_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "CalendarPrev",
props: {
prevPage: {
type: Function,
required: false
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false,
default: "button"
}
},
setup(__props) {
const props = __props;
const disabled = (0, vue.computed)(() => rootContext.disabled.value || rootContext.isPrevButtonDisabled(props.prevPage));
const rootContext = injectCalendarRootContext();
function handleClick() {
if (disabled.value) return;
rootContext.prevPage(props.prevPage);
}
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_VisuallyHidden.Primitive), {
"aria-label": "Previous page",
as: props.as,
"as-child": props.asChild,
type: props.as === "button" ? "button" : void 0,
"aria-disabled": disabled.value || void 0,
"data-disabled": disabled.value || void 0,
disabled: disabled.value,
onClick: handleClick
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { disabled: disabled.value }, () => [_cache[0] || (_cache[0] = (0, vue.createTextVNode)(" Prev page "))])]),
_: 3
}, 8, [
"as",
"as-child",
"type",
"aria-disabled",
"data-disabled",
"disabled"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Popover/PopoverRoot.js
var [injectPopoverRootContext, providePopoverRootContext] = require_VisuallyHidden.createContext("PopoverRoot");
var PopoverRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "PopoverRoot",
props: {
defaultOpen: {
type: Boolean,
required: false,
default: false
},
open: {
type: Boolean,
required: false,
default: void 0
},
modal: {
type: Boolean,
required: false,
default: false
}
},
emits: ["update:open"],
setup(__props, { emit: __emit }) {
const props = __props;
const emit = __emit;
const { modal } = (0, vue.toRefs)(props);
const open = require_dist.useVModel(props, "open", emit, {
defaultValue: props.defaultOpen,
passive: props.open === void 0
});
providePopoverRootContext({
contentId: "",
triggerId: "",
modal,
open,
onOpenChange: (value) => {
open.value = value;
},
onOpenToggle: () => {
open.value = !open.value;
},
triggerElement: (0, vue.ref)(),
hasCustomAnchor: (0, vue.ref)(false)
});
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperContent.PopperRoot_default), null, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {
open: (0, vue.unref)(open),
close: () => open.value = false
})]),
_: 3
});
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/DatePicker/DatePickerRoot.js
var [injectDatePickerRootContext, provideDatePickerRootContext] = require_VisuallyHidden.createContext("DatePickerRoot");
var DatePickerRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
inheritAttrs: false,
__name: "DatePickerRoot",
props: {
defaultValue: {
type: null,
required: false,
default: void 0
},
defaultPlaceholder: {
type: null,
required: false
},
placeholder: {
type: null,
required: false,
default: void 0
},
modelValue: {
type: null,
required: false
},
hourCycle: {
type: null,
required: false
},
step: {
type: Object,
required: false
},
granularity: {
type: String,
required: false
},
hideTimeZone: {
type: Boolean,
required: false
},
maxValue: {
type: null,
required: false
},
minValue: {
type: null,
required: false
},
locale: {
type: String,
required: false
},
disabled: {
type: Boolean,
required: false,
default: false
},
readonly: {
type: Boolean,
required: false,
default: false
},
isDateUnavailable: {
type: Function,
required: false,
default: void 0
},
id: {
type: String,
required: false
},
dir: {
type: String,
required: false
},
name: {
type: String,
required: false
},
required: {
type: Boolean,
required: false
},
defaultOpen: {
type: Boolean,
required: false,
default: false
},
open: {
type: Boolean,
required: false,
default: void 0
},
modal: {
type: Boolean,
required: false,
default: false
},
isDateDisabled: {
type: Function,
required: false,
default: void 0
},
pagedNavigation: {
type: Boolean,
required: false,
default: false
},
weekStartsOn: {
type: Number,
required: false
},
weekdayFormat: {
type: String,
required: false,
default: "narrow"
},
fixedWeeks: {
type: Boolean,
required: false,
default: false
},
numberOfMonths: {
type: Number,
required: false,
default: 1
},
preventDeselect: {
type: Boolean,
required: false,
default: false
},
closeOnSelect: {
type: Boolean,
required: false,
default: false
}
},
emits: [
"update:open",
"update:modelValue",
"update:placeholder"
],
setup(__props, { emit: __emit }) {
const props = __props;
const emits = __emit;
const { locale: propLocale, disabled, readonly, pagedNavigation, weekdayFormat, fixedWeeks, numberOfMonths, preventDeselect, isDateDisabled: propsIsDateDisabled, isDateUnavailable: propsIsDateUnavailable, defaultOpen, modal, id, name, required, minValue, maxValue, granularity, hideTimeZone, hourCycle, defaultValue, dir: propDir, step, closeOnSelect } = (0, vue.toRefs)(props);
const dir = require_VisuallyHidden.useDirection(propDir);
const locale = require_useDateField.useLocale(propLocale);
const weekStartsOn = (0, vue.computed)(() => props.weekStartsOn ?? getWeekStartsOn(locale.value));
const modelValue = require_dist.useVModel(props, "modelValue", emits, {
defaultValue: defaultValue.value,
passive: props.modelValue === void 0
});
const defaultDate = (0, vue.computed)(() => require_useDateField.getDefaultDate({
defaultPlaceholder: props.placeholder,
granularity: props.granularity,
defaultValue: modelValue.value,
locale: locale.value
}));
const placeholder = require_dist.useVModel(props, "placeholder", emits, {
defaultValue: props.defaultPlaceholder ?? defaultDate.value.copy(),
passive: props.placeholder === void 0
});
const open = require_dist.useVModel(props, "open", emits, {
defaultValue: defaultOpen.value,
passive: props.open === void 0
});
const dateFieldRef = (0, vue.ref)();
(0, vue.watch)(modelValue, (value) => {
if (value && value.compare(placeholder.value) !== 0) placeholder.value = value.copy();
if (closeOnSelect.value) open.value = false;
});
provideDatePickerRootContext({
isDateUnavailable: propsIsDateUnavailable.value,
isDateDisabled: propsIsDateDisabled.value,
locale,
disabled,
pagedNavigation,
weekStartsOn,
weekdayFormat,
fixedWeeks,
numberOfMonths,
readonly,
preventDeselect,
modelValue,
placeholder,
defaultOpen,
modal,
open,
id,
name,
required,
minValue,
maxValue,
granularity,
hideTimeZone,
hourCycle,
dateFieldRef,
dir,
step,
onDateChange(date) {
if (!date || !modelValue.value) modelValue.value = date?.copy() ?? void 0;
else if (!preventDeselect.value && date && modelValue.value.compare(date) === 0) modelValue.value = void 0;
else modelValue.value = date.copy();
},
onPlaceholderChange(date) {
placeholder.value = date.copy();
},
closeOnSelect
});
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(PopoverRoot_default), {
open: (0, vue.unref)(open),
"onUpdate:open": _cache[0] || (_cache[0] = ($event) => (0, vue.isRef)(open) ? open.value = $event : null),
"default-open": (0, vue.unref)(defaultOpen),
modal: (0, vue.unref)(modal)
}, {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 8, [
"open",
"default-open",
"modal"
]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/DatePicker/DatePickerCalendar.js
var DatePickerCalendar_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "DatePickerCalendar",
setup(__props) {
const rootContext = injectDatePickerRootContext();
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(CalendarRoot_default), (0, vue.mergeProps)({
isDateDisabled: (0, vue.unref)(rootContext).isDateDisabled,
isDateUnavailable: (0, vue.unref)(rootContext).isDateUnavailable,
minValue: (0, vue.unref)(rootContext).minValue.value,
maxValue: (0, vue.unref)(rootContext).maxValue.value,
locale: (0, vue.unref)(rootContext).locale.value,
disabled: (0, vue.unref)(rootContext).disabled.value,
pagedNavigation: (0, vue.unref)(rootContext).pagedNavigation.value,
weekStartsOn: (0, vue.unref)(rootContext).weekStartsOn.value,
weekdayFormat: (0, vue.unref)(rootContext).weekdayFormat.value,
fixedWeeks: (0, vue.unref)(rootContext).fixedWeeks.value,
numberOfMonths: (0, vue.unref)(rootContext).numberOfMonths.value,
readonly: (0, vue.unref)(rootContext).readonly.value,
preventDeselect: (0, vue.unref)(rootContext).preventDeselect.value,
dir: (0, vue.unref)(rootContext).dir.value
}, {
"model-value": (0, vue.unref)(rootContext).modelValue.value,
placeholder: (0, vue.unref)(rootContext).placeholder.value,
multiple: false,
"onUpdate:modelValue": _cache[0] || (_cache[0] = (date) => {
if (date && (0, vue.unref)(rootContext).modelValue.value && (0, vue.unref)(require_useDateField.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee)(date, (0, vue.unref)(rootContext).modelValue.value)) return;
(0, vue.unref)(rootContext).onDateChange(date);
}),
"onUpdate:placeholder": _cache[1] || (_cache[1] = (date) => {
if ((0, vue.unref)(require_useDateField.$14e0f24ef4ac5c92$export$91b62ebf2ba703ee)(date, (0, vue.unref)(rootContext).placeholder.value)) return;
(0, vue.unref)(rootContext).onPlaceholderChange(date);
})
}), {
default: (0, vue.withCtx)(({ weekDays, grid, date, weekStartsOn, locale, fixedWeeks }) => [(0, vue.renderSlot)(_ctx.$slots, "default", {
date,
grid,
weekDays,
weekStartsOn,
locale,
fixedWeeks
})]),
_: 3
}, 16, ["model-value", "placeholder"]);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/DatePicker/DatePickerCell.js
var DatePickerCell_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "DatePickerCell",
props: {
date: {
type: null,
required: true
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(CalendarCell_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/DatePicker/DatePickerCellTrigger.js
var DatePickerCellTrigger_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "DatePickerCellTrigger",
props: {
day: {
type: null,
required: true
},
month: {
type: null,
required: true
},
asChild: {
type: Boolean,
required: false
},
as: {
type: null,
required: false
}
},
setup(__props) {
const props = __props;
return (_ctx, _cache) => {
return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(CalendarCellTrigger_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
default: (0, vue.withCtx)((slotProps) => [(0, vue.renderSlot)(_ctx.$slots, "default", (0, vue.normalizeProps)((0, vue.guardReactiveProps)(slotProps)))]),
_: 3
}, 16);
};
}
});
//#endregion
//#region ../../node_modules/.pnpm/reka-ui@2.9.2_vue@3.5.31_typescript@5.9.3_/node_modules/reka-ui/dist/Popover/PopoverContentImpl.js
var PopoverContentImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
__name: "PopoverCont