@pathscale/ui 1.3.0 → 1.4.0

package/dist/components/calendar/Calendar.generated.js

@@ -0,0 +1,425 @@
+import { createComponent, insert, mergeProps, setAttribute, spread, template, use } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./Calendar.css";
+import { For, Show, createEffect, createMemo, createUniqueId, splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { DAYS_PER_WEEK, addDays, compareDates, getToday, normalizeDate, parseDate, shiftDateByMonths, toISODate, useCalendarNavigation, useCalendarState, useDateSelection } from "../../hooks/date/index.js";
+import { CLASSES, componentRecipe } from "./Calendar.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template('<div><div><div><button type=button><svg><path d="m15 18-6-6 6-6"></path></svg></button></div><div></div><div><button type=button><svg><path d="m9 18 6-6-6-6"></path></svg></button></div></div><div><div><div></div></div><div>'), _tmpl$2 = /*#__PURE__*/ template("<span>"), _tmpl$3 = /*#__PURE__*/ template("<div>"), _tmpl$4 = /*#__PURE__*/ template("<button type=button><span>");
+const __solidLayoutCalendar = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "ref",
+        "selectionMode",
+        "value",
+        "defaultValue",
+        "onChange",
+        "rangeStart",
+        "rangeEnd",
+        "rangePreview",
+        "onDaySelect",
+        "onDayHover",
+        "minValue",
+        "maxValue",
+        "isDateUnavailable",
+        "locale",
+        "weekdayFormat",
+        "showOutsideDays",
+        "isDisabled",
+        "disabled"
+    ]);
+    const selectionMode = createMemo(()=>local.selectionMode ?? "single");
+    const dateSelection = useDateSelection({
+        value: ()=>local.value,
+        defaultValue: ()=>local.defaultValue,
+        onChange: ()=>local.onChange
+    });
+    const selectedDate = createMemo(()=>"single" === selectionMode() ? dateSelection.selectedDate() : null);
+    const rangeStart = createMemo(()=>normalizeDate(local.rangeStart));
+    const rangeEnd = createMemo(()=>normalizeDate(local.rangeEnd));
+    const rangePreview = createMemo(()=>normalizeDate(local.rangePreview));
+    const defaultReferenceDate = createMemo(()=>normalizeDate(local.defaultValue) ?? getToday());
+    const focusReferenceDate = createMemo(()=>selectedDate() ?? rangeEnd() ?? rangeStart() ?? normalizeDate(local.value) ?? defaultReferenceDate());
+    const minDate = createMemo(()=>normalizeDate(local.minValue));
+    const maxDate = createMemo(()=>normalizeDate(local.maxValue));
+    const locale = createMemo(()=>local.locale ?? "en-US");
+    const weekdayFormat = createMemo(()=>local.weekdayFormat ?? "short");
+    const showOutsideDays = createMemo(()=>local.showOutsideDays ?? true);
+    const isCalendarDisabled = createMemo(()=>Boolean(local.isDisabled) || Boolean(local.disabled));
+    const isDateUnavailable = (date)=>Boolean(local.isDateUnavailable?.(date));
+    const isDateDisabled = (date)=>{
+        if (isCalendarDisabled()) return true;
+        const min = minDate();
+        if (min && compareDates(date, min) < 0) return true;
+        const max = maxDate();
+        if (max && compareDates(date, max) > 0) return true;
+        return isDateUnavailable(date);
+    };
+    const navigation = useCalendarNavigation({
+        initialFocusedDate: ()=>focusReferenceDate(),
+        minDate,
+        maxDate,
+        isDateDisabled
+    });
+    createEffect(()=>{
+        navigation.syncFocusedDate(focusReferenceDate());
+    });
+    const calendarState = useCalendarState({
+        selectionMode: ()=>selectionMode(),
+        locale,
+        weekdayFormat,
+        visibleMonth: navigation.visibleMonth,
+        focusedDate: navigation.focusedDate,
+        selectedDate,
+        rangeStart,
+        rangeEnd,
+        rangePreview,
+        isDateDisabled,
+        isDateUnavailable
+    });
+    let rootRef;
+    const focusDateButton = (date)=>{
+        const dateValue = toISODate(date);
+        queueMicrotask(()=>{
+            const target = rootRef?.querySelector(`[data-slot=\"calendar-cell\"][data-date=\"${dateValue}\"]`);
+            target?.focus();
+        });
+    };
+    const selectDate = (date)=>{
+        if (isDateDisabled(date)) return;
+        if ("function" == typeof local.onDaySelect) local.onDaySelect(date);
+        else if ("single" === selectionMode()) dateSelection.setSelectedDate(date);
+        navigation.setFocusedDate(date);
+        navigation.setVisibleMonthFromDate(date);
+    };
+    const navigateMonth = (direction)=>{
+        if (isCalendarDisabled()) return;
+        const nextFocus = navigation.navigateMonth(direction);
+        if (nextFocus) focusDateButton(nextFocus);
+    };
+    const handleCellKeyDown = (event)=>{
+        if (isCalendarDisabled()) return;
+        const dateValue = parseDate(event.currentTarget.dataset.date);
+        if (!dateValue) return;
+        if ("Enter" === event.key || " " === event.key) {
+            event.preventDefault();
+            selectDate(dateValue);
+            return;
+        }
+        let nextDate = null;
+        let direction = 1;
+        switch(event.key){
+            case "ArrowLeft":
+                nextDate = addDays(dateValue, -1);
+                direction = -1;
+                break;
+            case "ArrowRight":
+                nextDate = addDays(dateValue, 1);
+                direction = 1;
+                break;
+            case "ArrowUp":
+                nextDate = addDays(dateValue, -DAYS_PER_WEEK);
+                direction = -1;
+                break;
+            case "ArrowDown":
+                nextDate = addDays(dateValue, DAYS_PER_WEEK);
+                direction = 1;
+                break;
+            case "Home":
+                nextDate = addDays(dateValue, -dateValue.getDay());
+                direction = -1;
+                break;
+            case "End":
+                nextDate = addDays(dateValue, DAYS_PER_WEEK - 1 - dateValue.getDay());
+                direction = 1;
+                break;
+            case "PageUp":
+                nextDate = shiftDateByMonths(dateValue, -1);
+                direction = -1;
+                break;
+            case "PageDown":
+                nextDate = shiftDateByMonths(dateValue, 1);
+                direction = 1;
+                break;
+            default:
+                return;
+        }
+        if (!nextDate) return;
+        event.preventDefault();
+        const nextFocus = navigation.moveFocusToDate(nextDate, direction);
+        focusDateButton(nextFocus);
+    };
+    const uniqueId = createUniqueId();
+    const headingId = `calendar-heading-${uniqueId}`;
+    return (()=>{
+        var _el$ = _tmpl$(), _el$2 = _el$.firstChild, _el$3 = _el$2.firstChild, _el$4 = _el$3.firstChild, _el$5 = _el$4.firstChild, _el$6 = _el$3.nextSibling, _el$7 = _el$6.nextSibling, _el$8 = _el$7.firstChild, _el$9 = _el$8.firstChild, _el$0 = _el$2.nextSibling, _el$1 = _el$0.firstChild, _el$10 = _el$1.firstChild, _el$11 = _el$1.nextSibling;
+        use((node)=>{
+            rootRef = node;
+            if ("function" == typeof local.ref) local.ref(node);
+        }, _el$);
+        spread(_el$, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Root.base, isCalendarDisabled() && CLASSES.Root.flag.disabled, local.class, local.className)
+            }), {
+            "data-slot": "calendar",
+            get ["data-selection-mode"] () {
+                return selectionMode();
+            },
+            get ["data-disabled"] () {
+                return isCalendarDisabled() ? "true" : "false";
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            },
+            get ["aria-disabled"] () {
+                return isCalendarDisabled() ? "true" : void 0;
+            }
+        }), false, true);
+        spread(_el$2, mergeProps(()=>({
+                class: CLASSES.Header.base
+            }), {
+            "data-slot": "calendar-header"
+        }), false, true);
+        spread(_el$3, mergeProps(()=>({
+                class: CLASSES.Nav.base
+            }), {
+            "data-slot": "calendar-nav"
+        }), false, true);
+        spread(_el$4, mergeProps(()=>({
+                class: CLASSES.NavButton.base
+            }), {
+            "data-slot": "calendar-nav-button",
+            "aria-label": "Previous month",
+            onClick: ()=>navigateMonth(-1),
+            get disabled () {
+                return isCalendarDisabled() || !navigation.canNavigatePrevious();
+            },
+            get ["data-disabled"] () {
+                return isCalendarDisabled() || !navigation.canNavigatePrevious() ? "true" : void 0;
+            }
+        }), false, true);
+        spread(_el$5, mergeProps(()=>({
+                class: CLASSES.NavButtonIcon.base
+            }), {
+            "data-slot": "calendar-nav-button-icon",
+            viewBox: "0 0 24 24",
+            "aria-hidden": "true",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round"
+        }), true, true);
+        setAttribute(_el$6, "id", headingId);
+        spread(_el$6, mergeProps(()=>({
+                class: CLASSES.Heading.base
+            }), {
+            "data-slot": "calendar-heading",
+            "aria-live": "polite"
+        }), false, true);
+        insert(_el$6, ()=>calendarState.monthFormatter().format(navigation.visibleMonth()));
+        spread(_el$7, mergeProps(()=>({
+                class: CLASSES.Nav.base
+            }), {
+            "data-slot": "calendar-nav"
+        }), false, true);
+        spread(_el$8, mergeProps(()=>({
+                class: CLASSES.NavButton.base
+            }), {
+            "data-slot": "calendar-nav-button",
+            "aria-label": "Next month",
+            onClick: ()=>navigateMonth(1),
+            get disabled () {
+                return isCalendarDisabled() || !navigation.canNavigateNext();
+            },
+            get ["data-disabled"] () {
+                return isCalendarDisabled() || !navigation.canNavigateNext() ? "true" : void 0;
+            }
+        }), false, true);
+        spread(_el$9, mergeProps(()=>({
+                class: CLASSES.NavButtonIcon.base
+            }), {
+            "data-slot": "calendar-nav-button-icon",
+            viewBox: "0 0 24 24",
+            "aria-hidden": "true",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round"
+        }), true, true);
+        spread(_el$0, mergeProps(()=>({
+                class: CLASSES.Grid.base
+            }), {
+            "data-slot": "calendar-grid",
+            role: "grid",
+            "aria-labelledby": headingId,
+            get ["aria-readonly"] () {
+                return isCalendarDisabled() ? "true" : void 0;
+            }
+        }), false, true);
+        spread(_el$1, mergeProps(()=>({
+                class: CLASSES.GridHeader.base
+            }), {
+            "data-slot": "calendar-grid-header",
+            role: "rowgroup"
+        }), false, true);
+        spread(_el$10, mergeProps(()=>({
+                class: CLASSES.GridRow.base
+            }), {
+            "data-slot": "calendar-grid-row",
+            role: "row"
+        }), false, true);
+        insert(_el$10, createComponent(For, {
+            get each () {
+                return calendarState.weekdayLabels();
+            },
+            children: (label)=>(()=>{
+                    var _el$12 = _tmpl$2();
+                    spread(_el$12, mergeProps(()=>({
+                            class: CLASSES.HeaderCell.base
+                        }), {
+                        "data-slot": "calendar-header-cell",
+                        role: "columnheader"
+                    }), false, true);
+                    insert(_el$12, label);
+                    return _el$12;
+                })()
+        }));
+        spread(_el$11, mergeProps(()=>({
+                class: CLASSES.GridBody.base
+            }), {
+            "data-slot": "calendar-grid-body",
+            role: "rowgroup",
+            onMouseLeave: ()=>local.onDayHover?.(void 0)
+        }), false, true);
+        insert(_el$11, createComponent(For, {
+            get each () {
+                return calendarState.calendarWeeks();
+            },
+            children: (week)=>(()=>{
+                    var _el$13 = _tmpl$3();
+                    spread(_el$13, mergeProps(()=>({
+                            class: CLASSES.GridRow.base
+                        }), {
+                        "data-slot": "calendar-grid-row",
+                        role: "row"
+                    }), false, true);
+                    insert(_el$13, createComponent(For, {
+                        each: week,
+                        children: (date)=>{
+                            const cellState = calendarState.getCellState(date);
+                            const isoDate = toISODate(date);
+                            return (()=>{
+                                var _el$14 = _tmpl$3();
+                                spread(_el$14, mergeProps(()=>({
+                                        class: CLASSES.DayWrapper.base
+                                    }), {
+                                    "data-slot": "calendar-day-wrapper",
+                                    role: "presentation"
+                                }), false, true);
+                                insert(_el$14, createComponent(Show, {
+                                    get when () {
+                                        return showOutsideDays() || !cellState.isOutsideMonth;
+                                    },
+                                    get fallback () {
+                                        return (()=>{
+                                            var _el$17 = _tmpl$2();
+                                            spread(_el$17, mergeProps(()=>({
+                                                    class: CLASSES.DayPlaceholder.base
+                                                }), {
+                                                "data-slot": "calendar-day-placeholder",
+                                                "aria-hidden": "true"
+                                            }), false, false);
+                                            return _el$17;
+                                        })();
+                                    },
+                                    get children () {
+                                        var _el$15 = _tmpl$4(), _el$16 = _el$15.firstChild;
+                                        spread(_el$15, mergeProps(()=>({
+                                                class: twMerge(CLASSES.Cell.base, cellState.isSelected && CLASSES.Cell.flag.selected, cellState.isRangeStart && CLASSES.Cell.flag.rangeStart, cellState.isRangeEnd && CLASSES.Cell.flag.rangeEnd, cellState.isInCommittedRange && CLASSES.Cell.flag.inRange, cellState.isInPreviewRange && !cellState.isInCommittedRange && CLASSES.Cell.flag.inPreviewRange, cellState.isToday && CLASSES.Cell.flag.today, cellState.isOutsideMonth && CLASSES.Cell.flag.outsideMonth, cellState.isDisabled && CLASSES.Cell.flag.disabled, cellState.isUnavailable && CLASSES.Cell.flag.unavailable, cellState.isFocused && CLASSES.Cell.flag.focused)
+                                            }), {
+                                            "data-slot": "calendar-cell",
+                                            "data-date": isoDate,
+                                            get ["data-selected"] () {
+                                                return cellState.isSelected ? "true" : "false";
+                                            },
+                                            get ["data-range-start"] () {
+                                                return cellState.isRangeStart ? "true" : "false";
+                                            },
+                                            get ["data-range-end"] () {
+                                                return cellState.isRangeEnd ? "true" : "false";
+                                            },
+                                            get ["data-in-range"] () {
+                                                return cellState.isInCommittedRange ? "true" : "false";
+                                            },
+                                            get ["data-in-preview-range"] () {
+                                                return cellState.isInPreviewRange ? "true" : "false";
+                                            },
+                                            get ["data-today"] () {
+                                                return cellState.isToday ? "true" : "false";
+                                            },
+                                            get ["data-outside-month"] () {
+                                                return cellState.isOutsideMonth ? "true" : "false";
+                                            },
+                                            get ["data-disabled"] () {
+                                                return cellState.isDisabled ? "true" : "false";
+                                            },
+                                            get ["data-unavailable"] () {
+                                                return cellState.isUnavailable ? "true" : "false";
+                                            },
+                                            role: "gridcell",
+                                            get ["aria-label"] () {
+                                                return calendarState.dayLabelFormatter().format(date);
+                                            },
+                                            get ["aria-selected"] () {
+                                                return cellState.isAriaSelected ? "true" : "false";
+                                            },
+                                            get ["aria-disabled"] () {
+                                                return cellState.isDisabled ? "true" : "false";
+                                            },
+                                            get disabled () {
+                                                return cellState.isDisabled;
+                                            },
+                                            get tabIndex () {
+                                                return cellState.isFocused ? 0 : -1;
+                                            },
+                                            onClick: ()=>selectDate(date),
+                                            onFocus: ()=>navigation.setFocusedDate(date),
+                                            onMouseEnter: ()=>{
+                                                if (cellState.isDisabled) return;
+                                                local.onDayHover?.(date);
+                                            },
+                                            onKeyDown: handleCellKeyDown
+                                        }), false, true);
+                                        spread(_el$16, mergeProps(()=>({
+                                                class: CLASSES.Day.base
+                                            }), {
+                                            "data-slot": "calendar-day"
+                                        }), false, true);
+                                        insert(_el$16, ()=>date.getDate());
+                                        return _el$15;
+                                    }
+                                }));
+                                return _el$14;
+                            })();
+                        }
+                    }));
+                    return _el$13;
+                })()
+        }));
+        return _el$;
+    })();
+};
+const Calendar = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutCalendar,
+    embedded: true
+});
+const Calendar_generated = Calendar;
+export default Calendar_generated;

package/dist/components/calendar/Calendar.recipe.d.ts

@@ -0,0 +1,83 @@
+export declare const CLASSES: {
+    readonly Root: {
+        readonly base: "calendar";
+        readonly flag: {
+            readonly disabled: "calendar--disabled";
+        };
+    };
+    readonly Header: {
+        readonly base: "calendar__header";
+    };
+    readonly Heading: {
+        readonly base: "calendar__heading";
+    };
+    readonly Nav: {
+        readonly base: "calendar__nav";
+    };
+    readonly NavButton: {
+        readonly base: "calendar__nav-button";
+    };
+    readonly NavButtonIcon: {
+        readonly base: "calendar__nav-button-icon";
+    };
+    readonly Grid: {
+        readonly base: "calendar__grid";
+    };
+    readonly GridHeader: {
+        readonly base: "calendar__grid-header";
+    };
+    readonly GridBody: {
+        readonly base: "calendar__grid-body";
+    };
+    readonly GridRow: {
+        readonly base: "calendar__grid-row";
+    };
+    readonly HeaderCell: {
+        readonly base: "calendar__header-cell";
+    };
+    readonly DayWrapper: {
+        readonly base: "calendar__day-wrapper";
+    };
+    readonly DayPlaceholder: {
+        readonly base: "calendar__day-placeholder";
+    };
+    readonly Cell: {
+        readonly base: "calendar__cell";
+        readonly flag: {
+            readonly selected: "calendar__cell--selected";
+            readonly rangeStart: "calendar__cell--range-start";
+            readonly rangeEnd: "calendar__cell--range-end";
+            readonly inRange: "calendar__cell--in-range";
+            readonly inPreviewRange: "calendar__cell--in-preview-range";
+            readonly today: "calendar__cell--today";
+            readonly outsideMonth: "calendar__cell--outside-month";
+            readonly disabled: "calendar__cell--disabled";
+            readonly unavailable: "calendar__cell--unavailable";
+            readonly focused: "calendar__cell--focused";
+        };
+    };
+    readonly Day: {
+        readonly base: "calendar__day";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "calendar";
+    readonly slots: {
+        readonly calendar: {};
+        readonly "calendar-cell": {};
+        readonly "calendar-day": {};
+        readonly "calendar-day-placeholder": {};
+        readonly "calendar-day-wrapper": {};
+        readonly "calendar-grid": {};
+        readonly "calendar-grid-body": {};
+        readonly "calendar-grid-header": {};
+        readonly "calendar-grid-row": {};
+        readonly "calendar-header": {};
+        readonly "calendar-header-cell": {};
+        readonly "calendar-heading": {};
+        readonly "calendar-nav": {};
+        readonly "calendar-nav-button": {};
+        readonly "calendar-nav-button-icon": {};
+        readonly root: {};
+    };
+}>;

package/dist/components/calendar/Calendar.recipe.js

@@ -0,0 +1,172 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    Root: {
+        base: "calendar",
+        flag: {
+            disabled: "calendar--disabled"
+        }
+    },
+    Header: {
+        base: "calendar__header"
+    },
+    Heading: {
+        base: "calendar__heading"
+    },
+    Nav: {
+        base: "calendar__nav"
+    },
+    NavButton: {
+        base: "calendar__nav-button"
+    },
+    NavButtonIcon: {
+        base: "calendar__nav-button-icon"
+    },
+    Grid: {
+        base: "calendar__grid"
+    },
+    GridHeader: {
+        base: "calendar__grid-header"
+    },
+    GridBody: {
+        base: "calendar__grid-body"
+    },
+    GridRow: {
+        base: "calendar__grid-row"
+    },
+    HeaderCell: {
+        base: "calendar__header-cell"
+    },
+    DayWrapper: {
+        base: "calendar__day-wrapper"
+    },
+    DayPlaceholder: {
+        base: "calendar__day-placeholder"
+    },
+    Cell: {
+        base: "calendar__cell",
+        flag: {
+            selected: "calendar__cell--selected",
+            rangeStart: "calendar__cell--range-start",
+            rangeEnd: "calendar__cell--range-end",
+            inRange: "calendar__cell--in-range",
+            inPreviewRange: "calendar__cell--in-preview-range",
+            today: "calendar__cell--today",
+            outsideMonth: "calendar__cell--outside-month",
+            disabled: "calendar__cell--disabled",
+            unavailable: "calendar__cell--unavailable",
+            focused: "calendar__cell--focused"
+        }
+    },
+    Day: {
+        base: "calendar__day"
+    }
+};
+const componentRecipe = recipe({
+    component: "calendar",
+    slots: {
+        calendar: {},
+        "calendar-cell": {},
+        "calendar-day": {},
+        "calendar-day-placeholder": {},
+        "calendar-day-wrapper": {},
+        "calendar-grid": {},
+        "calendar-grid-body": {},
+        "calendar-grid-header": {},
+        "calendar-grid-row": {},
+        "calendar-header": {},
+        "calendar-header-cell": {},
+        "calendar-heading": {},
+        "calendar-nav": {},
+        "calendar-nav-button": {},
+        "calendar-nav-button-icon": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            calendar: {
+                base: "",
+                axes: {}
+            },
+            "calendar-cell": {
+                base: "",
+                axes: {}
+            },
+            "calendar-day": {
+                base: "",
+                axes: {}
+            },
+            "calendar-day-placeholder": {
+                base: "",
+                axes: {}
+            },
+            "calendar-day-wrapper": {
+                base: "",
+                axes: {}
+            },
+            "calendar-grid": {
+                base: "",
+                axes: {}
+            },
+            "calendar-grid-body": {
+                base: "",
+                axes: {}
+            },
+            "calendar-grid-header": {
+                base: "",
+                axes: {}
+            },
+            "calendar-grid-row": {
+                base: "",
+                axes: {}
+            },
+            "calendar-header": {
+                base: "",
+                axes: {}
+            },
+            "calendar-header-cell": {
+                base: "",
+                axes: {}
+            },
+            "calendar-heading": {
+                base: "",
+                axes: {}
+            },
+            "calendar-nav": {
+                base: "",
+                axes: {}
+            },
+            "calendar-nav-button": {
+                base: "",
+                axes: {}
+            },
+            "calendar-nav-button-icon": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            calendar: 0,
+            "calendar-cell": 1,
+            "calendar-day": 2,
+            "calendar-day-placeholder": 3,
+            "calendar-day-wrapper": 4,
+            "calendar-grid": 5,
+            "calendar-grid-body": 6,
+            "calendar-grid-header": 7,
+            "calendar-grid-row": 8,
+            "calendar-header": 9,
+            "calendar-header-cell": 10,
+            "calendar-heading": 11,
+            "calendar-nav": 12,
+            "calendar-nav-button": 13,
+            "calendar-nav-button-icon": 14,
+            root: 15
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/calendar/index.d.ts

@@ -1 +1 @@
-export { default, type CalendarProps, type CalendarWeekdayFormat, type CalendarSelectionMode, type CalendarDaySelectHandler, type CalendarDayHoverHandler, } from "./Calendar";
+export { default, type CalendarProps, type CalendarWeekdayFormat, type CalendarSelectionMode, type CalendarDaySelectHandler, type CalendarDayHoverHandler, } from "./Calendar.generated";

package/dist/components/calendar/index.js

@@ -1 +1 @@
-export { default } from "./Calendar.js";
+export { default } from "./Calendar.generated.js";