@solid2-aria/components 0.0.0-stage → 0.0.1

package/dist/browser/calendar.d.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-aria-components/src/Calendar.tsx.
+ * Modified for Solid Aria: composed Solid Aria and Stately primitives with Solid 2 contexts, reactive getters, and DOM refs; uses Solid class props.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { ContextValue, DOMRenderProps, Ref, RenderProps, SlotProps, StyleProps } from "./utils.js";
+import { HeadingProps } from "./heading.js";
+import { JSX } from "@solidjs/web";
+import { Calendar as Calendar$1, CalendarDate, CalendarIdentifier, DateDuration } from "@internationalized/date";
+import { AriaCalendarProps } from "@solid2-aria/core/calendar/create-calendar";
+import { CalendarCellAria } from "@solid2-aria/core/calendar/create-calendar-cell";
+import { CalendarHeadingProps as CalendarHeadingProps$1 } from "@solid2-aria/core/calendar/create-calendar-heading";
+import { CalendarMonthPickerAria, CalendarMonthPickerProps as CalendarMonthPickerProps$1 } from "@solid2-aria/core/calendar/create-calendar-month-picker";
+import { CalendarYearPickerAria, CalendarYearPickerProps as CalendarYearPickerProps$1 } from "@solid2-aria/core/calendar/create-calendar-year-picker";
+import { AriaRangeCalendarProps } from "@solid2-aria/core/calendar/create-range-calendar";
+import { HoverEvents } from "@solid2-aria/types-shared";
+import { GlobalDOMAttributes } from "@solid2-aria/types-shared-web";
+import { CalendarSelectionMode, CalendarState, DateValue, RangeCalendarState } from "@solid2-aria/stately/calendar/types";
+export interface CalendarRenderProps<M extends CalendarSelectionMode = "single"> {
+  isDisabled: boolean;
+  state: CalendarState<M>;
+  isInvalid: boolean;
+}
+export interface RangeCalendarRenderProps extends Omit<CalendarRenderProps, "state"> {
+  state: RangeCalendarState;
+}
+export interface CalendarProps<T extends DateValue, M extends CalendarSelectionMode = "single"> extends Omit<AriaCalendarProps<T, M>, "errorMessage" | "validationState">, RenderProps<CalendarRenderProps<M>>, SlotProps, GlobalDOMAttributes<HTMLDivElement> {
+  visibleDuration?: DateDuration;
+  createCalendar?: (identifier: CalendarIdentifier) => Calendar$1;
+  ref?: Ref<HTMLDivElement>;
+}
+export interface RangeCalendarProps<T extends DateValue> extends Omit<AriaRangeCalendarProps<T>, "errorMessage" | "validationState">, RenderProps<RangeCalendarRenderProps>, SlotProps, GlobalDOMAttributes<HTMLDivElement> {
+  visibleDuration?: DateDuration;
+  createCalendar?: (identifier: CalendarIdentifier) => Calendar$1;
+  ref?: Ref<HTMLDivElement>;
+}
+type CalendarContextProps = CalendarProps<DateValue, CalendarSelectionMode>;
+export declare const CalendarContext: import("solid-js").Context<ContextValue<CalendarContextProps, HTMLDivElement>>;
+export declare const RangeCalendarContext: import("solid-js").Context<ContextValue<RangeCalendarProps<DateValue>, HTMLDivElement>>;
+export declare const CalendarStateContext: import("solid-js").Context<CalendarState<CalendarSelectionMode> | null>;
+export declare const RangeCalendarStateContext: import("solid-js").Context<RangeCalendarState<DateValue> | null>;
+export declare function Calendar<T extends DateValue, M extends CalendarSelectionMode = "single">(input: CalendarProps<T, M>): JSX.Element;
+export declare function RangeCalendar<T extends DateValue>(input: RangeCalendarProps<T>): JSX.Element;
+export interface CalendarGridProps extends StyleProps, DOMRenderProps<"table", undefined>, GlobalDOMAttributes<HTMLTableElement> {
+  children?: JSX.Element | ((date: CalendarDate) => JSX.Element);
+  offset?: DateDuration;
+  weekdayStyle?: "narrow" | "short" | "long";
+  ref?: Ref<HTMLTableElement>;
+}
+export interface CalendarGridHeaderProps extends StyleProps, DOMRenderProps<"thead", undefined>, GlobalDOMAttributes<HTMLTableSectionElement> {
+  children: (day: string) => JSX.Element;
+  ref?: Ref<HTMLTableSectionElement>;
+}
+export interface CalendarHeaderCellProps extends StyleProps, DOMRenderProps<"th", undefined>, GlobalDOMAttributes<HTMLTableCellElement> {
+  children?: JSX.Element;
+  ref?: Ref<HTMLTableCellElement>;
+  id?: string;
+}
+export interface CalendarGridBodyProps extends StyleProps, DOMRenderProps<"tbody", undefined>, GlobalDOMAttributes<HTMLTableSectionElement> {
+  children: (date: CalendarDate) => JSX.Element;
+  ref?: Ref<HTMLTableSectionElement>;
+}
+export declare function CalendarGrid(props: CalendarGridProps): JSX.Element;
+export declare function CalendarGridHeader(props: CalendarGridHeaderProps): JSX.Element;
+export declare function CalendarHeaderCell(props: CalendarHeaderCellProps): JSX.Element;
+export declare function CalendarGridBody(props: CalendarGridBodyProps): JSX.Element;
+export interface CalendarCellRenderProps extends Omit<CalendarCellAria, "cellProps" | "buttonProps"> {
+  date: CalendarDate;
+  isHovered: boolean;
+  isSelectionStart: boolean;
+  isSelectionEnd: boolean;
+  isFocusVisible: boolean;
+  isOutsideMonth: boolean;
+  isToday: boolean;
+}
+export interface CalendarCellProps extends RenderProps<CalendarCellRenderProps>, HoverEvents, GlobalDOMAttributes<HTMLTableCellElement> {
+  date: CalendarDate;
+  ref?: Ref<HTMLTableCellElement>;
+}
+export declare function CalendarCell(props: CalendarCellProps): JSX.Element;
+export interface CalendarYearPickerProps extends CalendarYearPickerProps$1 {
+  children: (props: CalendarYearPickerAria) => JSX.Element;
+}
+export declare function CalendarYearPicker(props: CalendarYearPickerProps): JSX.Element;
+export interface CalendarMonthPickerProps extends CalendarMonthPickerProps$1 {
+  children: (props: CalendarMonthPickerAria) => JSX.Element;
+}
+export declare function CalendarMonthPicker(props: CalendarMonthPickerProps): JSX.Element;
+export interface CalendarHeadingProps extends CalendarHeadingProps$1, HeadingProps {}
+export declare function CalendarHeading(props: CalendarHeadingProps): JSX.Element;
+export {};
+//# sourceMappingURL=calendar.d.ts.map

package/dist/browser/calendar.js

@@ -0,0 +1,581 @@
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+/*
+ * Derived from Adobe React Spectrum: packages/react-aria-components/src/Calendar.tsx.
+ * Modified for Solid Aria: composed Solid Aria and Stately primitives with Solid 2 contexts, reactive getters, and DOM refs; uses Solid class props.
+ * Licensed under Apache-2.0. See LICENSES/Apache-2.0.txt and NOTICE.txt at the repository root.
+ */
+import { assignRef, createContextProps, createRenderProps, createSlottedContext, dom } from "./utils.js";
+import { ButtonContext } from "./button.js";
+import { Heading, HeadingContext } from "./heading.js";
+import { TextContext } from "./text.js";
+import { createComponent, delegateEvents, effect, getNextElement, insert, memo, mergeProps, ref, runHydrationEvents, scope, setAttribute, spread, template } from "@solidjs/web";
+import { mergeProps as mergeProps$1 } from "@solid2-aria/core/utils/merge-props";
+import { For, Show, createContext, createMemo, createSignal, merge, omit, untrack, useContext } from "solid-js";
+import { requireValue } from "@solid2-aria/core/utils/require-value";
+import { filterDOMProps } from "@solid2-aria/core/utils/filter-dom-props";
+import { createFocusRing } from "@solid2-aria/core/focus/create-focus-ring";
+import { createHover } from "@solid2-aria/core/interactions/create-hover";
+import { createCalendar, endOfMonth, isSameDay, isSameMonth, isToday } from "@internationalized/date";
+import { createCalendar as createCalendar$1 } from "@solid2-aria/core/calendar/create-calendar";
+import { createCalendarCell } from "@solid2-aria/core/calendar/create-calendar-cell";
+import { createCalendarGrid } from "@solid2-aria/core/calendar/create-calendar-grid";
+import { createCalendarHeading } from "@solid2-aria/core/calendar/create-calendar-heading";
+import { createCalendarMonthPicker } from "@solid2-aria/core/calendar/create-calendar-month-picker";
+import { createCalendarYearPicker } from "@solid2-aria/core/calendar/create-calendar-year-picker";
+import { createRangeCalendar } from "@solid2-aria/core/calendar/create-range-calendar";
+import { createLocale } from "@solid2-aria/core/i18n/i18n-provider";
+import { VisuallyHidden } from "@solid2-aria/core/visually-hidden/visually-hidden";
+import { createCalendarState } from "@solid2-aria/stately/calendar/create-calendar-state";
+import { createRangeCalendarState } from "@solid2-aria/stately/calendar/create-range-calendar-state";
+// src/calendar.tsx
+var _tmpl$ = /* @__PURE__ */ template(`<h2>`);
+var _tmpl$2 = /* @__PURE__ */ template(`<button tabindex=-1>`);
+var _tmpl$3 = /* @__PURE__ */ template(`<tr>`);
+var _tmpl$4 = /* @__PURE__ */ template(`<td>`);
+const CalendarContext = createContext(null);
+const RangeCalendarContext = createContext(null);
+const CalendarStateContext = createContext(null);
+const RangeCalendarStateContext = createContext(null);
+function Calendar(input) {
+	const [props, , setRef] = createContextProps(input, untrack(() => input.ref), CalendarContext);
+	const locale = createLocale();
+	const contextProps = props;
+	const state = createCalendarState(mergeProps$1(props, {
+		get createCalendar() {
+			return props.createCalendar ?? createCalendar;
+		},
+		get locale() {
+			return locale.locale;
+		}
+	}));
+	const aria = createCalendar$1(props, state);
+	const render = createRenderProps(mergeProps$1(props, {
+		defaultClass: "solid2-aria-Calendar",
+		values: {
+			get isDisabled() {
+				return props.isDisabled ?? false;
+			},
+			get isInvalid() {
+				return state.isValueInvalid;
+			},
+			state
+		}
+	}));
+	return createComponent(dom.div, mergeProps(() => {
+		return mergeProps$1(filterDOMProps(props, { global: true }), render, merge(() => aria.calendarProps));
+	}, {
+		ref: (element) => {
+			setRef(element);
+		},
+		get slot() {
+			return memo(() => {
+				return !!(typeof props.slot === "string" && props.slot.length > 0);
+			})() ? props.slot : void 0;
+		},
+		get "data-disabled"() {
+			return props.isDisabled === true ? true : void 0;
+		},
+		get "data-invalid"() {
+			return state.isValueInvalid || void 0;
+		},
+		get children() {
+			return createComponent(ButtonContext, {
+				value: { slots: {
+					get next() {
+						return aria.nextButtonProps;
+					},
+					get previous() {
+						return aria.prevButtonProps;
+					}
+				} },
+				get children() {
+					return createComponent(HeadingContext, {
+						value: {
+							"aria-hidden": "true",
+							get children() {
+								return aria.title;
+							},
+							level: 2
+						},
+						get children() {
+							return createComponent(CalendarStateContext, {
+								value: state,
+								get children() {
+									return createComponent(CalendarContext, {
+										value: contextProps,
+										get children() {
+											return createComponent(TextContext, {
+												value: { slots: { get errorMessage() {
+													return aria.errorMessageProps;
+												} } },
+												get children() {
+													return [
+														createComponent(VisuallyHidden, { get children() {
+															var _el$ = getNextElement(_tmpl$);
+															insert(_el$, scope(() => {
+																return aria.calendarProps["aria-label"];
+															}));
+															return _el$;
+														} }),
+														memo(() => {
+															return render.children;
+														}),
+														createComponent(VisuallyHidden, { get children() {
+															var _el$2 = getNextElement(_tmpl$2);
+															_el$2._$$click = () => {
+																state.focusNextPage();
+															};
+															effect(() => {
+																return {
+																	e: aria.nextButtonProps["aria-label"],
+																	t: aria.nextButtonProps.isDisabled
+																};
+															}, ({ e, t }, _p$) => {
+																e !== _p$?.e && setAttribute(_el$2, "aria-label", e);
+																t !== _p$?.t && setAttribute(_el$2, "disabled", t);
+															});
+															runHydrationEvents();
+															return _el$2;
+														} })
+													];
+												}
+											});
+										}
+									});
+								}
+							});
+						}
+					});
+				}
+			});
+		}
+	}));
+}
+function RangeCalendar(input) {
+	const [props, ref, setRef] = createContextProps(input, untrack(() => input.ref), RangeCalendarContext);
+	const locale = createLocale();
+	const contextProps = props;
+	const state = createRangeCalendarState(mergeProps$1(contextProps, {
+		get createCalendar() {
+			return props.createCalendar ?? createCalendar;
+		},
+		get locale() {
+			return locale.locale;
+		}
+	}));
+	const aria = createRangeCalendar(props, state, ref);
+	const render = createRenderProps(mergeProps$1(props, {
+		defaultClass: "solid2-aria-RangeCalendar",
+		values: {
+			get isDisabled() {
+				return props.isDisabled ?? false;
+			},
+			get isInvalid() {
+				return state.isValueInvalid;
+			},
+			state
+		}
+	}));
+	return createComponent(dom.div, mergeProps(() => {
+		return mergeProps$1(filterDOMProps(props, { global: true }), render, merge(() => aria.calendarProps));
+	}, {
+		ref: (element) => {
+			setRef(element);
+		},
+		get slot() {
+			return memo(() => {
+				return !!(typeof props.slot === "string" && props.slot.length > 0);
+			})() ? props.slot : void 0;
+		},
+		get "data-disabled"() {
+			return props.isDisabled === true ? true : void 0;
+		},
+		get "data-invalid"() {
+			return state.isValueInvalid || void 0;
+		},
+		get children() {
+			return createComponent(ButtonContext, {
+				value: { slots: {
+					get next() {
+						return aria.nextButtonProps;
+					},
+					get previous() {
+						return aria.prevButtonProps;
+					}
+				} },
+				get children() {
+					return createComponent(HeadingContext, {
+						value: {
+							"aria-hidden": "true",
+							get children() {
+								return aria.title;
+							},
+							level: 2
+						},
+						get children() {
+							return createComponent(RangeCalendarStateContext, {
+								value: state,
+								get children() {
+									return createComponent(RangeCalendarContext, {
+										value: contextProps,
+										get children() {
+											return createComponent(TextContext, {
+												value: { slots: { get errorMessage() {
+													return aria.errorMessageProps;
+												} } },
+												get children() {
+													return [
+														createComponent(VisuallyHidden, { get children() {
+															var _el$3 = getNextElement(_tmpl$);
+															insert(_el$3, scope(() => {
+																return aria.calendarProps["aria-label"];
+															}));
+															return _el$3;
+														} }),
+														memo(() => {
+															return render.children;
+														}),
+														createComponent(VisuallyHidden, { get children() {
+															var _el$4 = getNextElement(_tmpl$2);
+															_el$4._$$click = () => {
+																state.focusNextPage();
+															};
+															effect(() => {
+																return {
+																	e: aria.nextButtonProps["aria-label"],
+																	t: aria.nextButtonProps.isDisabled
+																};
+															}, ({ e, t }, _p$) => {
+																e !== _p$?.e && setAttribute(_el$4, "aria-label", e);
+																t !== _p$?.t && setAttribute(_el$4, "disabled", t);
+															});
+															runHydrationEvents();
+															return _el$4;
+														} })
+													];
+												}
+											});
+										}
+									});
+								}
+							});
+						}
+					});
+				}
+			});
+		}
+	}));
+}
+const InternalCalendarGridContext = createContext(null);
+function calendarState() {
+	return useContext(CalendarStateContext) ?? requireValue(useContext(RangeCalendarStateContext), "Expected required element or component context");
+}
+function CalendarGrid(props) {
+	const state = calendarState();
+	const calendar = createSlottedContext(CalendarContext);
+	const rangeCalendar = createSlottedContext(RangeCalendarContext);
+	const start = createMemo(() => props.offset ? state.visibleRange.start.add(props.offset) : state.visibleRange.start);
+	const aria = createCalendarGrid({
+		get endDate() {
+			return endOfMonth(start());
+		},
+		get firstDayOfWeek() {
+			return calendar?.firstDayOfWeek ?? rangeCalendar?.firstDayOfWeek;
+		},
+		get startDate() {
+			return start();
+		},
+		get weekdayStyle() {
+			return props.weekdayStyle;
+		}
+	}, state);
+	return createComponent(InternalCalendarGridContext, {
+		value: {
+			get headerProps() {
+				return aria.headerProps;
+			},
+			get startDate() {
+				return start();
+			},
+			get weekDays() {
+				return aria.weekDays;
+			},
+			get weeksInMonth() {
+				return aria.weeksInMonth;
+			}
+		},
+		get children() {
+			return createComponent(dom.table, mergeProps(() => {
+				return mergeProps$1(filterDOMProps(props, { global: true }), merge(() => aria.gridProps));
+			}, {
+				ref: (element) => {
+					assignRef(untrack(() => props.ref), element);
+				},
+				get style() {
+					return props.style;
+				},
+				get "class"() {
+					return props.class ?? "solid2-aria-CalendarGrid";
+				},
+				get render() {
+					return props.render;
+				},
+				get children() {
+					return memo(() => {
+						return typeof props.children === "function";
+					})() ? [createComponent(CalendarGridHeader, { children: (day) => createComponent(CalendarHeaderCell, { children: day }) }), createComponent(CalendarGridBody, { children: (date) => memo(() => {
+						return memo(() => {
+							return typeof props.children === "function";
+						})() ? props.children(date) : null;
+					}) })] : props.children;
+				}
+			}));
+		}
+	});
+}
+function CalendarGridHeader(props) {
+	const ctx = requireValue(useContext(InternalCalendarGridContext), "Expected required element or component context");
+	return createComponent(dom.thead, mergeProps(() => {
+		return mergeProps$1(filterDOMProps(props, { global: true }), merge(() => ctx.headerProps));
+	}, {
+		ref: (el) => {
+			assignRef(untrack(() => props.ref), el);
+		},
+		get style() {
+			return props.style;
+		},
+		get "class"() {
+			return props.class ?? "solid2-aria-CalendarGridHeader";
+		},
+		get render() {
+			return props.render;
+		},
+		get children() {
+			var _el$5 = getNextElement(_tmpl$3);
+			insert(_el$5, createComponent(For, {
+				get each() {
+					return ctx.weekDays;
+				},
+				children: (day) => memo(() => {
+					return props.children(day);
+				})
+			}));
+			return _el$5;
+		}
+	}));
+}
+function CalendarHeaderCell(props) {
+	return createComponent(dom.th, mergeProps(() => {
+		return filterDOMProps(props, { global: true });
+	}, {
+		ref: (el) => {
+			assignRef(untrack(() => props.ref), el);
+		},
+		get style() {
+			return props.style;
+		},
+		get "class"() {
+			return props.class ?? "solid2-aria-CalendarHeaderCell";
+		},
+		get render() {
+			return props.render;
+		},
+		get children() {
+			return props.children;
+		}
+	}));
+}
+function CalendarGridBody(props) {
+	const state = calendarState();
+	const ctx = requireValue(useContext(InternalCalendarGridContext), "Expected required element or component context");
+	const weeks = createMemo(() => Array.from({ length: ctx.weeksInMonth }, (_, index) => index));
+	return createComponent(dom.tbody, mergeProps(() => {
+		return filterDOMProps(props, { global: true });
+	}, {
+		ref: (el) => {
+			assignRef(untrack(() => props.ref), el);
+		},
+		get style() {
+			return props.style;
+		},
+		get "class"() {
+			return props.class ?? "solid2-aria-CalendarGridBody";
+		},
+		get render() {
+			return props.render;
+		},
+		get children() {
+			return createComponent(For, {
+				get each() {
+					return weeks();
+				},
+				children: (week) => (() => {
+					var _el$6 = getNextElement(_tmpl$3);
+					insert(_el$6, createComponent(For, {
+						get each() {
+							return state.getDatesInWeek(week, ctx.startDate);
+						},
+						keyed: false,
+						children: (date) => createComponent(Show, {
+							get when() {
+								return date();
+							},
+							get fallback() {
+								return getNextElement(_tmpl$4);
+							},
+							children: (current) => memo(() => {
+								return props.children(current());
+							})
+						})
+					}));
+					return _el$6;
+				})()
+			});
+		}
+	}));
+}
+function CalendarCell(props) {
+	const state = calendarState();
+	const grid = useContext(InternalCalendarGridContext);
+	const [buttonRef, setButtonRef] = createSignal(null, { ownedWrite: true });
+	const outside = () => Boolean(state.visibleDuration.days) || Boolean(state.visibleDuration.weeks) ? false : !isSameMonth(grid?.startDate ?? state.visibleRange.start, props.date);
+	const aria = createCalendarCell({
+		get date() {
+			return props.date;
+		},
+		get isOutsideMonth() {
+			return outside();
+		}
+	}, state, buttonRef);
+	const focus = createFocusRing();
+	const hover = createHover(mergeProps$1(props, { get isDisabled() {
+		return aria.isDisabled || aria.isUnavailable;
+	} }));
+	const boundary = (end) => "highlightedRange" in state && !!state.highlightedRange && isSameDay(props.date, end ? state.highlightedRange.end : state.highlightedRange.start);
+	const values = mergeProps$1(omit(aria, "cellProps", "buttonProps"), {
+		get date() {
+			return props.date;
+		},
+		get isFocusVisible() {
+			return aria.isFocused && focus.isFocusVisible;
+		},
+		get isHovered() {
+			return hover.isHovered;
+		},
+		get isOutsideMonth() {
+			return outside();
+		},
+		get isSelectionEnd() {
+			return boundary(true);
+		},
+		get isSelectionStart() {
+			return boundary(false);
+		},
+		get isToday() {
+			return isToday(props.date, state.timeZone);
+		}
+	});
+	const render = createRenderProps(mergeProps$1(props, {
+		get defaultChildren() {
+			return aria.formattedDate;
+		},
+		defaultClass: "solid2-aria-CalendarCell",
+		values
+	}));
+	const content = createMemo(() => render.children);
+	var _el$8 = getNextElement(_tmpl$4);
+	spread(_el$8, () => {
+		return aria.cellProps;
+	}, true);
+	ref(() => {
+		return (element) => {
+			assignRef(untrack(() => props.ref), element);
+		};
+	}, _el$8);
+	insert(_el$8, createComponent(dom.div, mergeProps(() => {
+		return mergeProps$1(filterDOMProps(props, { global: true }), merge(() => aria.buttonProps), merge(() => focus.focusProps ?? {}), merge(() => hover.hoverProps ?? {}), omit(render, "children"));
+	}, {
+		ref: (element) => {
+			setButtonRef(element);
+		},
+		get "data-focused"() {
+			return aria.isFocused || void 0;
+		},
+		get "data-hovered"() {
+			return hover.isHovered || void 0;
+		},
+		get "data-pressed"() {
+			return aria.isPressed || void 0;
+		},
+		get "data-unavailable"() {
+			return aria.isUnavailable || void 0;
+		},
+		get "data-disabled"() {
+			return aria.isDisabled || void 0;
+		},
+		get "data-focus-visible"() {
+			return values.isFocusVisible || void 0;
+		},
+		get "data-outside-visible-range"() {
+			return aria.isOutsideVisibleRange || void 0;
+		},
+		get "data-outside-month"() {
+			return outside() || void 0;
+		},
+		get "data-selected"() {
+			return aria.isSelected || void 0;
+		},
+		get "data-selection-start"() {
+			return values.isSelectionStart || void 0;
+		},
+		get "data-selection-end"() {
+			return values.isSelectionEnd || void 0;
+		},
+		get "data-invalid"() {
+			return aria.isInvalid || void 0;
+		},
+		get "data-today"() {
+			return values.isToday || void 0;
+		},
+		get children() {
+			return content();
+		}
+	})));
+	runHydrationEvents();
+	return _el$8;
+}
+function CalendarYearPicker(props) {
+	const aria = createCalendarYearPicker(props, calendarState());
+	return untrack(() => props.children(aria));
+}
+function CalendarMonthPicker(props) {
+	const aria = createCalendarMonthPicker(props, calendarState());
+	return untrack(() => props.children(aria));
+}
+function CalendarHeading(props) {
+	const text = createCalendarHeading(props, calendarState());
+	return createComponent(Heading, mergeProps(() => {
+		return omit(props, "offset", "format");
+	}, {
+		get "class"() {
+			return props.class ?? "solid2-aria-CalendarHeading";
+		},
+		get children() {
+			return text();
+		}
+	}));
+}
+delegateEvents(["click"]);
+export { Calendar, CalendarCell, CalendarContext, CalendarGrid, CalendarGridBody, CalendarGridHeader, CalendarHeaderCell, CalendarHeading, CalendarMonthPicker, CalendarStateContext, CalendarYearPicker, RangeCalendar, RangeCalendarContext, RangeCalendarStateContext };
+
+//# sourceMappingURL=calendar.js.map