@corvu-next/calendar 0.1.0

package/dist/index.jsx

@@ -0,0 +1,825 @@
+// src/context.ts
+import {
+  createContext,
+  useContext
+} from "solid-js";
+import {
+  createKeyedContext,
+  useKeyedContext
+} from "@corvu-next/utils/create/keyedContext";
+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;
+};
+
+// src/Cell.tsx
+import { Dynamic } from "@corvu-next/utils/dynamic";
+var CalendarCell = (props) => {
+  return <Dynamic
+    as="td"
+    role="presentation"
+    data-corvu-calendar-cell=""
+    {...props}
+  />;
+};
+var Cell_default = CalendarCell;
+
+// src/CellTrigger.tsx
+import {
+  createEffect,
+  createMemo,
+  createSignal,
+  omit,
+  untrack
+} from "solid-js";
+import { callEventHandler } from "@corvu-next/utils/dom";
+import { Dynamic as Dynamic2 } from "@corvu-next/utils/dynamic";
+
+// 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;
+};
+
+// src/CellTrigger.tsx
+import { dataIf } from "@corvu-next/utils";
+import { mergeRefs } from "@corvu-next/utils/reactivity";
+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 <Dynamic2
+    as="button"
+    ref={mergeRefs(setRef, p.ref)}
+    onClick={onClick}
+    onKeyDown={onKeyDown}
+    disabled={p.disabled === true || context().isDisabled(p.day, p.month) || void 0}
+    role="gridcell"
+    tabIndex={isSameDay(context().focusedDay(), p.day) ? 0 : -1}
+    aria-selected={context().isSelected(p.day) ? "true" : !context().isDisabled(p.day, p.month) ? "false" : void 0}
+    aria-disabled={context().isDisabled(p.day, p.month) ? "true" : void 0}
+    data-selected={dataIf(context().isSelected(p.day))}
+    data-disabled={dataIf(
+      context().isDisabled(p.day, p.month)
+    )}
+    data-today={dataIf(isToday())}
+    data-range-start={dataIf(
+      context().mode() === "range" && isSameDay(
+        p.day,
+        context().value().from
+      )
+    )}
+    data-range-end={dataIf(
+      context().mode() === "range" && isSameDay(
+        p.day,
+        context().value().to
+      )
+    )}
+    data-in-range={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;
+
+// src/HeadCell.tsx
+import { Dynamic as Dynamic3 } from "@corvu-next/utils/dynamic";
+var CalendarHeadCell = (props) => {
+  return <Dynamic3
+    as="th"
+    scope="col"
+    data-corvu-calendar-headcell=""
+    {...props}
+  />;
+};
+var HeadCell_default = CalendarHeadCell;
+
+// src/Label.tsx
+import {
+  createEffect as createEffect2,
+  createMemo as createMemo2,
+  omit as omit2
+} from "solid-js";
+import { Dynamic as Dynamic4 } from "@corvu-next/utils/dynamic";
+var CalendarLabel = (props) => {
+  const p = props;
+  const otherProps = omit2(p, "index", "contextId");
+  const context = createMemo2(
+    () => useInternalCalendarContext(p.contextId)
+  );
+  createEffect2(() => {
+    const _context = context();
+    _context.registerLabelId(p.index ?? 0);
+    return () => _context.unregisterLabelId(p.index ?? 0);
+  });
+  return <Dynamic4
+    as="h2"
+    id={context().labelIds()[p.index ?? 0]?.()}
+    aria-live="polite"
+    data-corvu-calendar-label=""
+    {...otherProps}
+  />;
+};
+var Label_default = CalendarLabel;
+
+// src/Nav.tsx
+import { callEventHandler as callEventHandler2 } from "@corvu-next/utils/dom";
+import {
+  createMemo as createMemo3,
+  omit as omit3
+} from "solid-js";
+import {
+  DynamicButton
+} from "@corvu-next/utils/dynamic";
+var CalendarNav = (props) => {
+  const otherProps = omit3(props, "action", "contextId", "onClick");
+  const context = createMemo3(
+    () => useInternalCalendarContext(props.contextId)
+  );
+  const onClick = (e) => {
+    !callEventHandler2(props.onClick, e) && context().navigate(props.action);
+  };
+  return <DynamicButton
+    as="button"
+    onClick={onClick}
+    data-corvu-calendar-nav=""
+    {...otherProps}
+  />;
+};
+var Nav_default = CalendarNav;
+
+// src/Root.tsx
+import {
+  createMemo as createMemo4,
+  createSignal as createSignal2,
+  createUniqueId,
+  merge,
+  untrack as untrack2
+} from "solid-js";
+import createControllableSignal from "@corvu-next/utils/create/controllableSignal";
+import createOnce from "@corvu-next/utils/create/once";
+import createRegister from "@corvu-next/utils/create/register";
+import { isFunction } from "@corvu-next/utils";
+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 = createMemo4(() => {
+    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] = createSignal2(
+    null
+  );
+  const [isFocusing, setIsFocusing] = createSignal2(false);
+  const setMonth = (next) => {
+    return untrack2(() => {
+      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 untrack2(() => {
+      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 = createMemo4(() => {
+    const CalendarContext2 = createCalendarContext(defaultedProps.contextId);
+    const InternalCalendarContext2 = createInternalCalendarContext(
+      defaultedProps.contextId
+    );
+    return <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]
+      }}
+    >
+        <InternalCalendarContext2
+      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],
+        registerLabelId: (index) => registerMemo()[1](index),
+        unregisterLabelId: (index) => registerMemo()[2](index),
+        onDaySelect,
+        isSelected,
+        isDisabled,
+        isFocusing,
+        setIsFocusing,
+        disabled: defaultedProps.disabled,
+        setFocusedDayRef
+      }}
+    >
+          {untrack2(() => resolveChildren())}
+        </InternalCalendarContext2>
+      </CalendarContext2>;
+  });
+  return memoizedCalendarRoot;
+};
+var Root_default = CalendarRoot;
+
+// src/Table.tsx
+import { createMemo as createMemo5, omit as omit4 } from "solid-js";
+import { Dynamic as Dynamic5 } from "@corvu-next/utils/dynamic";
+var CalendarTable = (props) => {
+  const p = props;
+  const otherProps = omit4(p, "index", "contextId");
+  const context = createMemo5(
+    () => useInternalCalendarContext(p.contextId)
+  );
+  return <Dynamic5
+    as="table"
+    role="grid"
+    aria-labelledby={context().labelIds()[p.index ?? 0]?.()}
+    aria-multiselectable={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
+};