@corvu-next/calendar 0.1.0

package/dist/index.js

@@ -0,0 +1,739 @@
+import { createContext, merge, createMemo, createUniqueId, createSignal, untrack, useContext, omit, createEffect } from 'solid-js';
+import { useKeyedContext, createKeyedContext } from '@corvu-next/utils/create/keyedContext';
+import { createComponent, mergeProps, memo } from 'solid-js/web';
+import { Dynamic, DynamicButton } from '@corvu-next/utils/dynamic';
+import { callEventHandler } from '@corvu-next/utils/dom';
+import { dataIf, isFunction } from '@corvu-next/utils';
+import { mergeRefs } from '@corvu-next/utils/reactivity';
+import createControllableSignal from '@corvu-next/utils/create/controllableSignal';
+import createOnce from '@corvu-next/utils/create/once';
+import createRegister from '@corvu-next/utils/create/register';
+
+// src/context.ts
+var CalendarContext = createContext(null);
+var createCalendarContext = (contextId) => {
+  if (contextId === void 0) return CalendarContext;
+  const context = createKeyedContext(
+    `calendar-${contextId}`
+  );
+  return context;
+};
+var useCalendarContext = (contextId) => {
+  if (contextId === void 0) {
+    const context2 = useContext(CalendarContext);
+    if (!context2) {
+      throw new Error(
+        "[corvu]: Calendar context not found. Make sure to wrap Calendar components in <Calendar.Root>"
+      );
+    }
+    return context2;
+  }
+  const context = useKeyedContext(
+    `calendar-${contextId}`
+  );
+  if (!context) {
+    throw new Error(
+      `[corvu]: Calendar context with id "${contextId}" not found. Make sure to wrap Calendar components in <Calendar.Root contextId="${contextId}">`
+    );
+  }
+  return context;
+};
+var InternalCalendarContext = createContext(null);
+var createInternalCalendarContext = (contextId) => {
+  if (contextId === void 0) return InternalCalendarContext;
+  const context = createKeyedContext(
+    `calendar-internal-${contextId}`
+  );
+  return context;
+};
+var useInternalCalendarContext = (contextId) => {
+  if (contextId === void 0) {
+    const context2 = useContext(InternalCalendarContext);
+    if (!context2) {
+      throw new Error(
+        "[corvu]: Calendar context not found. Make sure to wrap Calendar components in <Calendar.Root>"
+      );
+    }
+    return context2;
+  }
+  const context = useKeyedContext(
+    `calendar-internal-${contextId}`
+  );
+  if (!context) {
+    throw new Error(
+      `[corvu]: Calendar context with id "${contextId}" not found. Make sure to wrap Calendar components in <Calendar.Root contextId="${contextId}">`
+    );
+  }
+  return context;
+};
+var CalendarCell = (props) => {
+  return createComponent(Dynamic, mergeProps({
+    as: "td",
+    role: "presentation",
+    "data-corvu-calendar-cell": ""
+  }, props));
+};
+var Cell_default = CalendarCell;
+
+// src/utils.ts
+var isSameDay = (a, b) => {
+  if (!a || !b) return false;
+  if (a.getDate() !== b.getDate()) return false;
+  if (a.getMonth() !== b.getMonth()) return false;
+  if (a.getFullYear() !== b.getFullYear()) return false;
+  return true;
+};
+var isSameDayOrBefore = (a, b) => {
+  if (!a || !b) return false;
+  if (isSameDay(a, b)) return true;
+  if (a.getTime() < b.getTime()) return true;
+  return false;
+};
+var isSameDayOrAfter = (a, b) => {
+  if (!a || !b) return false;
+  if (isSameDay(a, b)) return true;
+  if (a.getTime() > b.getTime()) return true;
+  return false;
+};
+var modifyDate = (date, modify) => {
+  const newYear = date.getFullYear() + (modify.year ?? 0);
+  const newMonth = date.getMonth() + (modify.month ?? 0);
+  let newDay = date.getDate() + (modify.day ?? 0);
+  if (modify.month !== void 0 && modify.month !== 0) {
+    newDay = Math.min(new Date(newYear, newMonth + 1, 0).getDate(), newDay);
+  }
+  return new Date(newYear, newMonth, newDay);
+};
+var modifyFocusedDay = (date, modify, disabled, retry = true, iteration = 0) => {
+  if (iteration > 365) return null;
+  const newDate = modifyDate(date, modify);
+  if (!disabled(newDate)) return newDate;
+  if (!retry) return null;
+  return modifyFocusedDay(newDate, modify, disabled, retry, iteration + 1);
+};
+var dayIsInMonth = (focusedDay, month, numberOfMonths) => {
+  const firstDay = new Date(month.getFullYear(), month.getMonth(), 1);
+  const lastDay = new Date(
+    month.getFullYear(),
+    month.getMonth() + numberOfMonths,
+    0
+  );
+  return focusedDay.getTime() >= firstDay.getTime() && focusedDay.getTime() <= lastDay.getTime();
+};
+var findAvailableDayInMonth = (start, disabled) => {
+  const lastDayOfMonth = new Date(start.getFullYear(), start.getMonth() + 1, 0);
+  const month = start.getMonth();
+  let shift = 0;
+  const maxShift = Math.max(
+    start.getDate() - 1,
+    lastDayOfMonth.getDate() - start.getDate()
+  );
+  while (shift <= maxShift) {
+    start.setDate(start.getDate() + shift);
+    if (start.getMonth() === month && !disabled(start)) return start;
+    start.setDate(start.getDate() - shift);
+    if (start.getMonth() === month && !disabled(start)) return start;
+    shift++;
+  }
+  return start;
+};
+var CalendarCellTrigger = (props) => {
+  const p = props;
+  const otherProps = omit(p, "day", "month", "contextId", "ref", "onClick", "onKeyDown", "disabled");
+  const [ref, setRef] = createSignal(null);
+  const [isToday, setIsToday] = createSignal(false);
+  createEffect(() => {
+    setIsToday(isSameDay(p.day, /* @__PURE__ */ new Date()));
+  });
+  const context = createMemo(() => useInternalCalendarContext(p.contextId));
+  createEffect(() => {
+    const focusedDay = context().focusedDay();
+    const day = p.day;
+    const month = p.month;
+    if (!untrack(() => context().isFocusing())) return;
+    if (context().isDisabled(day, month)) return;
+    if (isSameDay(focusedDay, day)) {
+      untrack(() => {
+        ref()?.focus();
+        context().setIsFocusing(false);
+      });
+    }
+  });
+  createEffect(() => {
+    if (context().isDisabled(p.day, p.month)) return;
+    if (isSameDay(p.day, context().focusedDay())) {
+      context().setFocusedDayRef(ref());
+      return () => {
+        context().setFocusedDayRef(null);
+      };
+    }
+  });
+  const onClick = (e) => {
+    !callEventHandler(p.onClick, e) && context().onDaySelect(p.day);
+  };
+  const onKeyDown = (event) => {
+    if (callEventHandler(p.onKeyDown, event)) return;
+    let focusedDay = null;
+    if (event.key === "ArrowLeft" && context().textDirection() === "ltr" || event.key === "ArrowRight" && context().textDirection() === "rtl") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: -1
+      }, context().disabled);
+    } else if (event.key === "ArrowRight" && context().textDirection() === "ltr" || event.key === "ArrowLeft" && context().textDirection() === "rtl") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: 1
+      }, context().disabled);
+    } else if (event.key === "ArrowUp") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: -7
+      }, context().disabled);
+    } else if (event.key === "ArrowDown") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: 7
+      }, context().disabled);
+    } else if (event.key === "Home" && context().textDirection() === "ltr" || event.key === "End" && context().textDirection() === "rtl") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: -((p.day.getDay() - context().startOfWeek() + 7) % 7)
+      }, context().disabled, false);
+    } else if (event.key === "End" && context().textDirection() === "ltr" || event.key === "Home" && context().textDirection() === "rtl") {
+      event.preventDefault();
+      focusedDay = modifyFocusedDay(p.day, {
+        day: (context().startOfWeek() + 6 - p.day.getDay() + 7) % 7
+      }, context().disabled, false);
+    } else if (event.key === "PageUp") {
+      event.preventDefault();
+      if (event.shiftKey) {
+        focusedDay = modifyFocusedDay(p.day, {
+          year: -1
+        }, context().disabled);
+      } else {
+        focusedDay = modifyFocusedDay(p.day, {
+          month: -1
+        }, context().disabled);
+      }
+    } else if (event.key === "PageDown") {
+      event.preventDefault();
+      if (event.shiftKey) {
+        focusedDay = modifyFocusedDay(p.day, {
+          year: 1
+        }, context().disabled);
+      } else {
+        focusedDay = modifyFocusedDay(p.day, {
+          month: 1
+        }, context().disabled);
+      }
+    }
+    if (focusedDay === null) return;
+    context().setIsFocusing(true);
+    context().setFocusedDay(focusedDay);
+  };
+  return createComponent(Dynamic, mergeProps({
+    as: "button",
+    ref(r$) {
+      var _ref$ = mergeRefs(setRef, p.ref);
+      typeof _ref$ === "function" && _ref$(r$);
+    },
+    onClick,
+    onKeyDown,
+    get disabled() {
+      return p.disabled === true || context().isDisabled(p.day, p.month) || void 0;
+    },
+    role: "gridcell",
+    get tabIndex() {
+      return isSameDay(context().focusedDay(), p.day) ? 0 : -1;
+    },
+    get ["aria-selected"]() {
+      return memo(() => !!context().isSelected(p.day))() ? "true" : !context().isDisabled(p.day, p.month) ? "false" : void 0;
+    },
+    get ["aria-disabled"]() {
+      return context().isDisabled(p.day, p.month) ? "true" : void 0;
+    },
+    get ["data-selected"]() {
+      return dataIf(context().isSelected(p.day));
+    },
+    get ["data-disabled"]() {
+      return dataIf(context().isDisabled(p.day, p.month));
+    },
+    get ["data-today"]() {
+      return dataIf(isToday());
+    },
+    get ["data-range-start"]() {
+      return dataIf(context().mode() === "range" && isSameDay(p.day, context().value().from));
+    },
+    get ["data-range-end"]() {
+      return dataIf(context().mode() === "range" && isSameDay(p.day, context().value().to));
+    },
+    get ["data-in-range"]() {
+      return dataIf(context().mode() === "range" && isSameDayOrAfter(p.day, context().value().from) && isSameDayOrBefore(p.day, context().value().to));
+    },
+    "data-corvu-calendar-celltrigger": ""
+  }, otherProps));
+};
+var CellTrigger_default = CalendarCellTrigger;
+var CalendarHeadCell = (props) => {
+  return createComponent(Dynamic, mergeProps({
+    as: "th",
+    scope: "col",
+    "data-corvu-calendar-headcell": ""
+  }, props));
+};
+var HeadCell_default = CalendarHeadCell;
+var CalendarLabel = (props) => {
+  const p = props;
+  const otherProps = omit(p, "index", "contextId");
+  const context = createMemo(() => useInternalCalendarContext(p.contextId));
+  createEffect(() => {
+    const _context = context();
+    _context.registerLabelId(p.index ?? 0);
+    return () => _context.unregisterLabelId(p.index ?? 0);
+  });
+  return createComponent(Dynamic, mergeProps({
+    as: "h2",
+    get id() {
+      return context().labelIds()[p.index ?? 0]?.();
+    },
+    "aria-live": "polite",
+    "data-corvu-calendar-label": ""
+  }, otherProps));
+};
+var Label_default = CalendarLabel;
+var CalendarNav = (props) => {
+  const otherProps = omit(props, "action", "contextId", "onClick");
+  const context = createMemo(() => useInternalCalendarContext(props.contextId));
+  const onClick = (e) => {
+    !callEventHandler(props.onClick, e) && context().navigate(props.action);
+  };
+  return createComponent(DynamicButton, mergeProps({
+    as: "button",
+    onClick,
+    "data-corvu-calendar-nav": ""
+  }, otherProps));
+};
+var Nav_default = CalendarNav;
+var CalendarRoot = (props) => {
+  const defaultedProps = merge({
+    initialValue: props.mode === "single" ? null : props.mode === "multiple" ? [] : {
+      from: null,
+      to: null
+    },
+    initialMonth: props.initialFocusedDay ?? /* @__PURE__ */ new Date(),
+    initialFocusedDay: findAvailableDayInMonth(props.initialMonth ?? /* @__PURE__ */ new Date(), props.disabled ?? (() => true)),
+    startOfWeek: 1,
+    required: false,
+    disabled: () => false,
+    numberOfMonths: 1,
+    disableOutsideDays: true,
+    fixedWeeks: false,
+    textDirection: "ltr",
+    labelIds: [],
+    min: null,
+    max: null,
+    excludeDisabled: false
+  }, props);
+  const [value, setValue] = createControllableSignal({
+    value: () => defaultedProps.value,
+    initialValue: defaultedProps.initialValue,
+    onChange: props.onValueChange
+  });
+  const [month, setMonthInternal] = createControllableSignal({
+    value: () => defaultedProps.month,
+    initialValue: defaultedProps.initialMonth,
+    onChange: defaultedProps.onMonthChange
+  });
+  const [focusedDay, setFocusedDayInternal] = createControllableSignal({
+    value: () => defaultedProps.focusedDay,
+    initialValue: defaultedProps.initialFocusedDay,
+    onChange: defaultedProps.onFocusedDayChange
+  });
+  const registerMemo = createMemo(() => {
+    const registers = Array.from({
+      length: defaultedProps.numberOfMonths
+    }, (_, index) => createRegister({
+      value: () => defaultedProps.labelIds[index] ?? createUniqueId()
+    }));
+    const labelIds = registers.map((register) => register[0]);
+    const registerLabelId = (index) => {
+      registers[index]?.[1]();
+    };
+    const unregisterLabelId = (index) => {
+      registers[index]?.[2]();
+    };
+    return [labelIds, registerLabelId, unregisterLabelId];
+  });
+  const [focusedDayRef, setFocusedDayRef] = createSignal(null);
+  const [isFocusing, setIsFocusing] = createSignal(false);
+  const setMonth = (next) => {
+    return untrack(() => {
+      let nextValue;
+      if (typeof next === "function") {
+        nextValue = next(month());
+      } else {
+        nextValue = next;
+      }
+      setMonthInternal(nextValue);
+      if (!dayIsInMonth(focusedDay(), nextValue, defaultedProps.numberOfMonths)) {
+        setFocusedDayInternal((focusedDay2) => findAvailableDayInMonth(new Date(nextValue.getFullYear(), nextValue.getMonth(), focusedDay2.getDate()), defaultedProps.disabled));
+      }
+      return nextValue;
+    });
+  };
+  const setFocusedDay = (next) => {
+    return untrack(() => {
+      let nextValue;
+      if (typeof next === "function") {
+        nextValue = next(focusedDay());
+      } else {
+        nextValue = next;
+      }
+      if (defaultedProps.disabled(nextValue)) return;
+      setFocusedDayInternal(nextValue);
+      if (!dayIsInMonth(nextValue, month(), defaultedProps.numberOfMonths)) {
+        const delta = (nextValue.getFullYear() - month().getFullYear()) * 12 + (nextValue.getMonth() - month().getMonth());
+        const newMonth = new Date(month().getFullYear(), month().getMonth() + Math.sign(delta) * Math.max(defaultedProps.numberOfMonths, Math.abs(delta)));
+        setMonthInternal(newMonth);
+      }
+      return nextValue;
+    });
+  };
+  const weekdays = () => {
+    const startOfWeek = defaultedProps.startOfWeek;
+    return Array.from({
+      length: 7
+    }, (_, i) => {
+      const day = (i + startOfWeek) % 7 + 4;
+      return new Date(1970, 0, day);
+    });
+  };
+  const months = () => {
+    const months2 = [];
+    for (let i = 0; i < defaultedProps.numberOfMonths; i++) {
+      months2.push({
+        month: modifyDate(month(), {
+          month: i
+        }),
+        weeks: weeks(i)
+      });
+    }
+    return months2;
+  };
+  const weeks = (monthOffset = 0) => {
+    const adjustedMonth = new Date(month().getFullYear(), month().getMonth() + monthOffset);
+    const calendar = [];
+    const firstDayOfMonth = new Date(adjustedMonth.getFullYear(), adjustedMonth.getMonth(), 1);
+    const lastDayOfMonth = new Date(adjustedMonth.getFullYear(), adjustedMonth.getMonth() + 1, 0);
+    const prefixedDays = (firstDayOfMonth.getDay() - defaultedProps.startOfWeek + 7) % 7;
+    const weekCount = defaultedProps.fixedWeeks ? 6 : Math.ceil((lastDayOfMonth.getDate() + prefixedDays) / 7);
+    const currentDay = new Date(adjustedMonth.getFullYear(), adjustedMonth.getMonth(), 1 - prefixedDays);
+    for (let i = 0; i < weekCount; i++) {
+      const week = [];
+      for (let i2 = 0; i2 < 7; i2++) {
+        week.push(new Date(currentDay));
+        currentDay.setDate(currentDay.getDate() + 1);
+      }
+      calendar.push(week);
+    }
+    return calendar;
+  };
+  const navigate = (action) => {
+    if (typeof action === "function") {
+      const newDate = action(month());
+      setMonth(newDate);
+      return;
+    }
+    switch (action) {
+      case "prev-month":
+        setMonth((month2) => modifyDate(month2, {
+          month: -1
+        }));
+        break;
+      case "next-month":
+        setMonth((month2) => modifyDate(month2, {
+          month: 1
+        }));
+        break;
+      case "prev-year":
+        setMonth((month2) => modifyDate(month2, {
+          year: -1
+        }));
+        break;
+      case "next-year":
+        setMonth((month2) => modifyDate(month2, {
+          year: 1
+        }));
+        break;
+    }
+  };
+  const onDaySelect = (day) => {
+    setFocusedDay(day);
+    switch (defaultedProps.mode) {
+      case "single":
+        setValue((value2) => {
+          if (isSameDay(day, value2) && !defaultedProps.required) {
+            return null;
+          } else {
+            return day;
+          }
+        });
+        break;
+      case "multiple":
+        setValue((value2) => {
+          value2 = value2;
+          const isSelected2 = value2.some((d) => isSameDay(day, d));
+          if (isSelected2 && value2.length !== defaultedProps.min && !(value2.length === 1 && defaultedProps.required)) {
+            return value2.filter((d) => !isSameDay(day, d));
+          }
+          if (!isSelected2 && value2.length !== defaultedProps.max) {
+            return [...value2, day];
+          }
+          return value2;
+        });
+        break;
+      case "range":
+        setValue((value2) => {
+          value2 = value2;
+          if (value2.from === null) {
+            return {
+              from: day,
+              to: null
+            };
+          }
+          if (value2.to === null) {
+            let from = value2.from;
+            let to = day;
+            if (day < from) {
+              to = from;
+              from = day;
+            }
+            if (defaultedProps.excludeDisabled) {
+              for (let day2 = new Date(from); day2 < to; day2.setDate(day2.getDate() + 1)) {
+                if (defaultedProps.disabled(day2)) {
+                  return {
+                    from: day2,
+                    to: null
+                  };
+                }
+              }
+            }
+            return {
+              from,
+              to
+            };
+          }
+          if (isSameDay(day, value2.from) && !defaultedProps.required) {
+            return {
+              from: null,
+              to: null
+            };
+          }
+          return {
+            from: day,
+            to: null
+          };
+        });
+        break;
+    }
+  };
+  const isSelected = (day) => {
+    let _value = value();
+    switch (defaultedProps.mode) {
+      case "single":
+        return isSameDay(day, _value);
+      case "multiple":
+        return _value.some((value2) => isSameDay(day, value2));
+      case "range":
+        _value = _value;
+        return isSameDay(day, _value.from) || isSameDayOrAfter(day, _value.from) && isSameDayOrBefore(day, _value.to);
+    }
+  };
+  const isDisabled = (day, _month) => {
+    _month = _month ?? month();
+    if (defaultedProps.disableOutsideDays && day.getMonth() !== _month.getMonth()) {
+      return true;
+    }
+    return defaultedProps.disabled(day);
+  };
+  const childrenProps = {
+    get mode() {
+      return defaultedProps.mode;
+    },
+    get value() {
+      return value();
+    },
+    // @ts-expect-error: Union type shenanigans
+    setValue,
+    get month() {
+      return month();
+    },
+    setMonth,
+    get focusedDay() {
+      return focusedDay();
+    },
+    setFocusedDay,
+    get startOfWeek() {
+      return defaultedProps.startOfWeek;
+    },
+    get required() {
+      return defaultedProps.required;
+    },
+    get numberOfMonths() {
+      return defaultedProps.numberOfMonths;
+    },
+    get disableOutsideDays() {
+      return defaultedProps.disableOutsideDays;
+    },
+    get fixedWeeks() {
+      return defaultedProps.fixedWeeks;
+    },
+    get textDirection() {
+      return defaultedProps.textDirection;
+    },
+    get weekdays() {
+      return weekdays();
+    },
+    get months() {
+      return months();
+    },
+    get weeks() {
+      return weeks();
+    },
+    navigate,
+    get focusedDayRef() {
+      return focusedDayRef();
+    },
+    get min() {
+      return defaultedProps.min;
+    },
+    get max() {
+      return defaultedProps.max;
+    },
+    get excludeDisabled() {
+      return defaultedProps.excludeDisabled;
+    },
+    get labelIds() {
+      return registerMemo()[0].map((labelId) => labelId());
+    }
+  };
+  const memoizedChildren = createOnce(() => defaultedProps.children);
+  const resolveChildren = () => {
+    const children = memoizedChildren()();
+    if (isFunction(children)) {
+      return children(childrenProps);
+    }
+    return children;
+  };
+  const memoizedCalendarRoot = createMemo(() => {
+    const CalendarContext2 = createCalendarContext(defaultedProps.contextId);
+    const InternalCalendarContext2 = createInternalCalendarContext(defaultedProps.contextId);
+    return createComponent(CalendarContext2, {
+      value: {
+        // @ts-expect-error: Union type shenanigans
+        mode: () => defaultedProps.mode,
+        // @ts-expect-error: Union type shenanigans
+        value,
+        // @ts-expect-error: Union type shenanigans
+        setValue,
+        month,
+        setMonth,
+        focusedDay,
+        setFocusedDay,
+        startOfWeek: () => defaultedProps.startOfWeek,
+        required: () => defaultedProps.required,
+        numberOfMonths: () => defaultedProps.numberOfMonths,
+        disableOutsideDays: () => defaultedProps.disableOutsideDays,
+        fixedWeeks: () => defaultedProps.fixedWeeks,
+        textDirection: () => defaultedProps.textDirection,
+        weekdays,
+        months,
+        weeks,
+        navigate,
+        focusedDayRef,
+        min: () => defaultedProps.min,
+        max: () => defaultedProps.max,
+        excludeDisabled: () => defaultedProps.excludeDisabled,
+        labelIds: () => registerMemo()[0]
+      },
+      get children() {
+        return createComponent(InternalCalendarContext2, {
+          get value() {
+            return {
+              // @ts-expect-error: Union type shenanigans
+              mode: () => defaultedProps.mode,
+              // @ts-expect-error: Union type shenanigans
+              value,
+              // @ts-expect-error: Union type shenanigans
+              setValue,
+              month,
+              setMonth,
+              focusedDay,
+              setFocusedDay,
+              startOfWeek: () => defaultedProps.startOfWeek,
+              required: () => defaultedProps.required,
+              numberOfMonths: () => defaultedProps.numberOfMonths,
+              disableOutsideDays: () => defaultedProps.disableOutsideDays,
+              fixedWeeks: () => defaultedProps.fixedWeeks,
+              textDirection: () => defaultedProps.textDirection,
+              weekdays,
+              months,
+              weeks,
+              navigate,
+              focusedDayRef,
+              min: () => defaultedProps.min,
+              max: () => defaultedProps.max,
+              excludeDisabled: () => defaultedProps.excludeDisabled,
+              labelIds: () => registerMemo()[0],
+              registerLabelId: (index) => registerMemo()[1](index),
+              unregisterLabelId: (index) => registerMemo()[2](index),
+              onDaySelect,
+              isSelected,
+              isDisabled,
+              isFocusing,
+              setIsFocusing,
+              disabled: defaultedProps.disabled,
+              setFocusedDayRef
+            };
+          },
+          get children() {
+            return untrack(() => resolveChildren());
+          }
+        });
+      }
+    });
+  });
+  return memoizedCalendarRoot;
+};
+var Root_default = CalendarRoot;
+var CalendarTable = (props) => {
+  const p = props;
+  const otherProps = omit(p, "index", "contextId");
+  const context = createMemo(() => useInternalCalendarContext(p.contextId));
+  return createComponent(Dynamic, mergeProps({
+    as: "table",
+    role: "grid",
+    get ["aria-labelledby"]() {
+      return context().labelIds()[p.index ?? 0]?.();
+    },
+    get ["aria-multiselectable"]() {
+      return context().mode() === "multiple" || context().mode() === "range" ? "true" : void 0;
+    },
+    "data-corvu-calendar-table": ""
+  }, otherProps));
+};
+var Table_default = CalendarTable;
+
+// src/index.ts
+var Calendar = Object.assign(Root_default, {
+  Label: Label_default,
+  Nav: Nav_default,
+  Table: Table_default,
+  HeadCell: HeadCell_default,
+  Cell: Cell_default,
+  CellTrigger: CellTrigger_default,
+  useContext: useCalendarContext
+});
+var index_default = Calendar;
+
+export { index_default as default };