@cognitiv/components-web 1.0.5 → 1.1.0

package/dist/components/button-group/button-group.js

@@ -0,0 +1,82 @@
+"use client";
+import React__default, { Children, isValidElement, useContext, createContext } from 'react';
+import { useSlottedContext, ToggleButtonGroupContext, Group } from 'react-aria-components';
+import { buttonGroupVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+
+const ButtonGroupContext = /*#__PURE__*/createContext({});
+
+// Property name to mark direct children of ButtonGroup
+const BUTTON_GROUP_CHILD = "__button_group_child";
+
+/* -------------------------------------------------------------------------------------------------
+ * ButtonGroup Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const ButtonGroupRoot = ({
+  children,
+  className,
+  fullWidth,
+  isDisabled,
+  orientation: orientationProp,
+  size,
+  variant,
+  ...rest
+}) => {
+  const racContext = useSlottedContext(ToggleButtonGroupContext);
+  const orientation = orientationProp ?? racContext?.orientation ?? "horizontal";
+  const slots = React__default.useMemo(() => buttonGroupVariants({
+    fullWidth,
+    orientation
+  }), [fullWidth, orientation]);
+
+  // Wrap only direct children with context provider
+  const wrappedChildren = Children.map(children, child => {
+    if (! /*#__PURE__*/isValidElement(child)) {
+      return child;
+    }
+
+    // Clone the child and add the special prop
+    return /*#__PURE__*/React__default.cloneElement(child, {
+      [BUTTON_GROUP_CHILD]: true
+    });
+  });
+  return /*#__PURE__*/jsx(ButtonGroupContext, {
+    value: {
+      fullWidth,
+      isDisabled,
+      size,
+      slots,
+      variant
+    },
+    children: /*#__PURE__*/jsx(Group, {
+      className: composeTwRenderProps(className, slots.base()),
+      "data-slot": "button-group",
+      isDisabled: isDisabled,
+      ...rest,
+      children: wrappedChildren
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ButtonGroup Separator
+ * -----------------------------------------------------------------------------------------------*/
+
+const ButtonGroupSeparator = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(ButtonGroupContext);
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.separator, className),
+    "data-slot": "button-group-separator",
+    ...props
+  });
+};
+
+export { BUTTON_GROUP_CHILD, ButtonGroupContext, ButtonGroupRoot, ButtonGroupSeparator };

package/dist/components/button-group/index.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentProps } from "react";
+import { ButtonGroupRoot, ButtonGroupSeparator } from "./button-group";
+export declare const ButtonGroup: (({ children, className, fullWidth, isDisabled, orientation: orientationProp, size, variant, ...rest }: import("./button-group").ButtonGroupRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, fullWidth, isDisabled, orientation: orientationProp, size, variant, ...rest }: import("./button-group").ButtonGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+    Separator: ({ className, ...props }: import("./button-group").ButtonGroupSeparatorProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ButtonGroup = {
+    Props: ComponentProps<typeof ButtonGroupRoot>;
+    RootProps: ComponentProps<typeof ButtonGroupRoot>;
+    SeparatorProps: ComponentProps<typeof ButtonGroupSeparator>;
+};
+export { ButtonGroupRoot, ButtonGroupSeparator };
+export type { ButtonGroupRootProps, ButtonGroupRootProps as ButtonGroupProps, ButtonGroupSeparatorProps, } from "./button-group";
+export { ButtonGroupContext, BUTTON_GROUP_CHILD } from "./button-group";
+export { buttonGroupVariants } from "./styles";
+export type { ButtonGroupVariants } from "./styles";

package/dist/components/button-group/index.js

@@ -0,0 +1,14 @@
+"use strict";
+import { ButtonGroupRoot, ButtonGroupSeparator } from './button-group.js';
+export { BUTTON_GROUP_CHILD, ButtonGroupContext } from './button-group.js';
+export { buttonGroupVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ButtonGroup = Object.assign(ButtonGroupRoot, {
+  Root: ButtonGroupRoot,
+  Separator: ButtonGroupSeparator
+});
+
+export { ButtonGroup, ButtonGroupRoot, ButtonGroupSeparator };

package/dist/components/button-group/styles.d.ts

@@ -0,0 +1,57 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const buttonGroupVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            base: string;
+        };
+        vertical: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    separator: string;
+}, undefined, {
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            base: string;
+        };
+        vertical: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    separator: string;
+}, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+        };
+    };
+    orientation: {
+        horizontal: {
+            base: string;
+        };
+        vertical: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    separator: string;
+}, undefined, unknown, unknown, undefined>>;
+export type ButtonGroupVariants = VariantProps<typeof buttonGroupVariants>;

package/dist/components/button-group/styles.js

@@ -0,0 +1,31 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const buttonGroupVariants = tv({
+  defaultVariants: {
+    fullWidth: false,
+    orientation: "horizontal"
+  },
+  slots: {
+    base: "button-group",
+    separator: "button-group__separator"
+  },
+  variants: {
+    fullWidth: {
+      false: {},
+      true: {
+        base: "button-group--full-width"
+      }
+    },
+    orientation: {
+      horizontal: {
+        base: "button-group--horizontal"
+      },
+      vertical: {
+        base: "button-group--vertical"
+      }
+    }
+  }
+});
+
+export { buttonGroupVariants };

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

@@ -0,0 +1,71 @@
+import type { CalendarVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { DateValue } from "react-aria-components";
+import { Button as ButtonPrimitive, CalendarCell as CalendarCellPrimitive, CalendarGridBody as CalendarGridBodyPrimitive, CalendarGridHeader as CalendarGridHeaderPrimitive, CalendarGrid as CalendarGridPrimitive, CalendarHeaderCell as CalendarHeaderCellPrimitive, Calendar as CalendarPrimitive, Heading as HeadingPrimitive } from "react-aria-components";
+interface CalendarRootProps<T extends DateValue = DateValue> extends ComponentPropsWithRef<typeof CalendarPrimitive<T>>, CalendarVariants {
+    isYearPickerOpen?: boolean;
+    onYearPickerOpenChange?: (isYearPickerOpen: boolean) => void;
+    defaultYearPickerOpen?: boolean;
+}
+declare function CalendarRoot<T extends DateValue = DateValue>({ children, className, defaultYearPickerOpen: defaultYearPickerOpenProp, isYearPickerOpen: isYearPickerOpenProp, maxValue: maxValueProp, minValue: minValueProp, onYearPickerOpenChange: onYearPickerOpenChangeProp, ...rest }: CalendarRootProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace CalendarRoot {
+    var displayName: string;
+}
+interface CalendarHeaderProps extends ComponentPropsWithRef<"header"> {
+    className?: string;
+}
+declare const CalendarHeader: {
+    ({ children, className, ...props }: CalendarHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarHeadingProps extends ComponentPropsWithRef<typeof HeadingPrimitive> {
+}
+declare const CalendarHeading: {
+    ({ className, ...props }: CalendarHeadingProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarNavButtonProps extends ComponentPropsWithRef<typeof ButtonPrimitive> {
+    slot?: "previous" | "next";
+}
+declare const CalendarNavButton: {
+    ({ children, className, slot, ...props }: CalendarNavButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarGridProps extends ComponentPropsWithRef<typeof CalendarGridPrimitive> {
+}
+declare const CalendarGrid: {
+    ({ children, className, weekdayStyle, ...props }: CalendarGridProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarGridHeaderProps extends ComponentPropsWithRef<typeof CalendarGridHeaderPrimitive> {
+}
+declare const CalendarGridHeader: {
+    ({ className, ...props }: CalendarGridHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarGridBodyProps extends ComponentPropsWithRef<typeof CalendarGridBodyPrimitive> {
+}
+declare const CalendarGridBody: {
+    ({ className, ...props }: CalendarGridBodyProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarHeaderCellProps extends ComponentPropsWithRef<typeof CalendarHeaderCellPrimitive> {
+}
+declare const CalendarHeaderCell: {
+    ({ className, ...props }: CalendarHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarCellProps extends ComponentPropsWithRef<typeof CalendarCellPrimitive> {
+}
+declare const CalendarCell: {
+    ({ children, className, ...props }: CalendarCellProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface CalendarCellIndicatorProps extends ComponentPropsWithRef<"span"> {
+}
+declare const CalendarCellIndicator: {
+    ({ className, ...props }: CalendarCellIndicatorProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { CalendarRoot, CalendarHeader, CalendarHeading, CalendarNavButton, CalendarGrid, CalendarGridHeader, CalendarGridBody, CalendarHeaderCell, CalendarCell, CalendarCellIndicator, };
+export type { CalendarRootProps, CalendarHeaderProps, CalendarHeadingProps, CalendarNavButtonProps, CalendarGridProps, CalendarGridHeaderProps, CalendarGridBodyProps, CalendarHeaderCellProps, CalendarCellProps, CalendarCellIndicatorProps, };

package/dist/components/calendar/calendar.js

@@ -0,0 +1,274 @@
+"use client";
+import { CalendarDate } from '@internationalized/date';
+import { useControlledState } from '@react-stately/utils';
+import React__default, { useContext, createContext } from 'react';
+import { Calendar, Button, Heading, CalendarHeaderCell as CalendarHeaderCell$1, CalendarGridHeader as CalendarGridHeader$1, CalendarGridBody as CalendarGridBody$1, CalendarGrid as CalendarGrid$1, CalendarCell as CalendarCell$1, CalendarStateContext } from 'react-aria-components';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { YearPickerContext, YearPickerStateContext } from '../calendar-year-picker/year-picker-context.js';
+import { IconChevronLeft, IconChevronRight } from '../icons.js';
+import { calendarVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const CalendarContext = /*#__PURE__*/createContext({});
+const CalendarYearPickerStateBridge = ({
+  children
+}) => {
+  const state = React__default.useContext(CalendarStateContext);
+  if (!state) {
+    throw new Error("Calendar year picker state must be used within <Calendar>.");
+  }
+  const yearPickerStateValue = {
+    focusedDate: state.focusedDate,
+    maxValue: state.maxValue,
+    minValue: state.minValue,
+    setFocusedDate: value => state.setFocusedDate(value),
+    timeZone: state.timeZone
+  };
+  return /*#__PURE__*/jsx(YearPickerStateContext, {
+    value: yearPickerStateValue,
+    children: children
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Root
+| * -----------------------------------------------------------------------------------------------*/
+
+function CalendarRoot({
+  children,
+  className,
+  defaultYearPickerOpen: defaultYearPickerOpenProp = false,
+  isYearPickerOpen: isYearPickerOpenProp,
+  maxValue: maxValueProp,
+  minValue: minValueProp,
+  onYearPickerOpenChange: onYearPickerOpenChangeProp,
+  ...rest
+}) {
+  const slots = React__default.useMemo(() => calendarVariants(), []);
+  const calendarRef = React__default.useRef(null);
+  const [isYearPickerOpen, setIsYearPickerOpen] = useControlledState(isYearPickerOpenProp, defaultYearPickerOpenProp, onYearPickerOpenChangeProp);
+  const minValue = minValueProp ?? new CalendarDate(1900, 1, 1);
+  const maxValue = maxValueProp ?? new CalendarDate(2099, 12, 31);
+  return /*#__PURE__*/jsx(YearPickerContext, {
+    value: {
+      calendarGridSlot: "calendar-grid",
+      calendarRef,
+      isYearPickerOpen,
+      setIsYearPickerOpen
+    },
+    children: /*#__PURE__*/jsx(CalendarContext, {
+      value: {
+        slots
+      },
+      children: /*#__PURE__*/jsx(Calendar, {
+        ref: calendarRef,
+        "data-slot": "calendar",
+        maxValue: maxValue,
+        minValue: minValue,
+        ...rest,
+        className: composeTwRenderProps(className, slots.base()),
+        children: values => /*#__PURE__*/jsx(CalendarYearPickerStateBridge, {
+          children: typeof children === "function" ? children(values) : children
+        })
+      })
+    })
+  });
+}
+CalendarRoot.displayName = "Cognitiv.Calendar";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Header
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarHeader = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx("header", {
+    className: composeSlotClassName(slots?.header, className),
+    "data-slot": "calendar-header",
+    ...props,
+    children: children
+  });
+};
+CalendarHeader.displayName = "Cognitiv.Calendar.Header";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Heading
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarHeading = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(Heading, {
+    "data-slot": "calendar-heading",
+    ...props,
+    className: composeSlotClassName(slots?.heading, className)
+  });
+};
+CalendarHeading.displayName = "Cognitiv.Calendar.Heading";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Nav Button
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarNavButton = ({
+  children,
+  className,
+  slot,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(Button, {
+    "data-slot": "calendar-nav-button",
+    slot: slot,
+    ...props,
+    className: composeTwRenderProps(className, slots?.navButton()),
+    children: children || (slot === "previous" ? /*#__PURE__*/jsx(IconChevronLeft, {
+      className: slots?.navButtonIcon(),
+      "data-slot": "calendar-nav-button-icon"
+    }) : /*#__PURE__*/jsx(IconChevronRight, {
+      className: slots?.navButtonIcon(),
+      "data-slot": "calendar-nav-button-icon"
+    }))
+  });
+};
+CalendarNavButton.displayName = "Cognitiv.Calendar.NavButton";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Grid
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarGrid = ({
+  children,
+  className,
+  weekdayStyle = "short",
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(CalendarGrid$1, {
+    "data-slot": "calendar-grid",
+    weekdayStyle: weekdayStyle,
+    ...props,
+    className: composeSlotClassName(slots?.grid, className),
+    children: children
+  });
+};
+CalendarGrid.displayName = "Cognitiv.Calendar.Grid";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Grid Header
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarGridHeader = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(CalendarGridHeader$1, {
+    "data-slot": "calendar-grid-header",
+    ...props,
+    className: composeSlotClassName(slots?.gridHeader, className)
+  });
+};
+CalendarGridHeader.displayName = "Cognitiv.Calendar.GridHeader";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Grid Body
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarGridBody = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(CalendarGridBody$1, {
+    "data-slot": "calendar-grid-body",
+    ...props,
+    className: composeSlotClassName(slots?.gridBody, className)
+  });
+};
+CalendarGridBody.displayName = "Cognitiv.Calendar.GridBody";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Header Cell
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarHeaderCell = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(CalendarHeaderCell$1, {
+    "data-slot": "calendar-header-cell",
+    ...props,
+    className: composeSlotClassName(slots?.headerCell, className)
+  });
+};
+CalendarHeaderCell.displayName = "Cognitiv.Calendar.HeaderCell";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Cell
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarCell = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx(CalendarCell$1, {
+    "data-slot": "calendar-cell",
+    ...props,
+    className: composeTwRenderProps(className, slots?.cell()),
+    children: values => {
+      const {
+        formattedDate
+      } = values;
+      return typeof children === "function" ? children(values) : children || formattedDate;
+    }
+  });
+};
+CalendarCell.displayName = "Cognitiv.Calendar.Cell";
+
+/* -------------------------------------------------------------------------------------------------
+| * Calendar Cell Indicator
+| * -----------------------------------------------------------------------------------------------*/
+
+const CalendarCellIndicator = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CalendarContext);
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.cellIndicator, className),
+    "data-slot": "calendar-cell-indicator",
+    ...props
+  });
+};
+CalendarCellIndicator.displayName = "Cognitiv.Calendar.CellIndicator";
+
+export { CalendarCell, CalendarCellIndicator, CalendarGrid, CalendarGridBody, CalendarGridHeader, CalendarHeader, CalendarHeaderCell, CalendarHeading, CalendarNavButton, CalendarRoot };

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

@@ -0,0 +1,91 @@
+import type { ComponentProps } from "react";
+import { CalendarYearPickerCell, CalendarYearPickerGrid, CalendarYearPickerGridBody, CalendarYearPickerTrigger, CalendarYearPickerTriggerHeading, CalendarYearPickerTriggerIndicator } from "../calendar-year-picker";
+import { CalendarCell, CalendarCellIndicator, CalendarGrid, CalendarGridBody, CalendarGridHeader, CalendarHeader, CalendarHeaderCell, CalendarHeading, CalendarNavButton, CalendarRoot } from "./calendar";
+export declare const Calendar: typeof CalendarRoot & {
+    Cell: {
+        ({ children, className, ...props }: import("./calendar").CalendarCellProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    CellIndicator: {
+        ({ className, ...props }: import("./calendar").CalendarCellIndicatorProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Grid: {
+        ({ children, className, weekdayStyle, ...props }: import("./calendar").CalendarGridProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    GridBody: {
+        ({ className, ...props }: import("./calendar").CalendarGridBodyProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    GridHeader: {
+        ({ className, ...props }: import("./calendar").CalendarGridHeaderProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        ({ children, className, ...props }: import("./calendar").CalendarHeaderProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    HeaderCell: {
+        ({ className, ...props }: import("./calendar").CalendarHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Heading: {
+        ({ className, ...props }: import("./calendar").CalendarHeadingProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    NavButton: {
+        ({ children, className, slot, ...props }: import("./calendar").CalendarNavButtonProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Root: typeof CalendarRoot;
+    YearPickerCell: {
+        ({ children, className, excludeFromTabOrder, onFocus, onPress, year, ...props }: import("..").CalendarYearPickerCellProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    YearPickerGrid: {
+        ({ children, className, onKeyDown, ...props }: import("..").CalendarYearPickerGridProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    YearPickerGridBody: {
+        ({ children }: import("..").CalendarYearPickerGridBodyProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    YearPickerTrigger: {
+        ({ children, className, onKeyDown, onPress, ...props }: import("..").CalendarYearPickerTriggerProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    YearPickerTriggerHeading: {
+        ({ children, className, ...props }: import("..").CalendarYearPickerTriggerHeadingProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    YearPickerTriggerIndicator: {
+        ({ children, className, ...props }: import("..").CalendarYearPickerTriggerIndicatorProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export type Calendar = {
+    Props: ComponentProps<typeof CalendarRoot>;
+    RootProps: ComponentProps<typeof CalendarRoot>;
+    HeaderProps: ComponentProps<typeof CalendarHeader>;
+    HeadingProps: ComponentProps<typeof CalendarHeading>;
+    NavButtonProps: ComponentProps<typeof CalendarNavButton>;
+    GridProps: ComponentProps<typeof CalendarGrid>;
+    GridHeaderProps: ComponentProps<typeof CalendarGridHeader>;
+    GridBodyProps: ComponentProps<typeof CalendarGridBody>;
+    HeaderCellProps: ComponentProps<typeof CalendarHeaderCell>;
+    CellProps: ComponentProps<typeof CalendarCell>;
+    CellIndicatorProps: ComponentProps<typeof CalendarCellIndicator>;
+    YearPickerTriggerProps: ComponentProps<typeof CalendarYearPickerTrigger>;
+    YearPickerTriggerHeadingProps: ComponentProps<typeof CalendarYearPickerTriggerHeading>;
+    YearPickerTriggerIndicatorProps: ComponentProps<typeof CalendarYearPickerTriggerIndicator>;
+    YearPickerGridProps: ComponentProps<typeof CalendarYearPickerGrid>;
+    YearPickerGridBodyProps: ComponentProps<typeof CalendarYearPickerGridBody>;
+    YearPickerCellProps: ComponentProps<typeof CalendarYearPickerCell>;
+};
+export { CalendarRoot, CalendarHeader, CalendarHeading, CalendarNavButton, CalendarGrid, CalendarGridHeader, CalendarGridBody, CalendarHeaderCell, CalendarCell, CalendarCellIndicator, };
+export type { CalendarRootProps, CalendarRootProps as CalendarProps, CalendarHeaderProps, CalendarHeadingProps, CalendarNavButtonProps, CalendarGridProps, CalendarGridHeaderProps, CalendarGridBodyProps, CalendarHeaderCellProps, CalendarCellProps, CalendarCellIndicatorProps, } from "./calendar";
+export { YearPickerContext, YearPickerStateContext, useYearPicker, useYearPickerState, } from "../calendar-year-picker";
+export type { YearPickerContextValue, YearPickerStateContextValue } from "../calendar-year-picker";
+export { calendarVariants } from "./styles";
+export type { CalendarVariants } from "./styles";

package/dist/components/calendar/index.js

@@ -0,0 +1,29 @@
+"use strict";
+import { CalendarYearPickerTriggerIndicator, CalendarYearPickerTriggerHeading, CalendarYearPickerTrigger, CalendarYearPickerGridBody, CalendarYearPickerGrid, CalendarYearPickerCell } from '../calendar-year-picker/calendar-year-picker.js';
+export { YearPickerContext, YearPickerStateContext, useYearPicker, useYearPickerState } from '../calendar-year-picker/year-picker-context.js';
+import { CalendarRoot, CalendarNavButton, CalendarHeading, CalendarHeaderCell, CalendarHeader, CalendarGridHeader, CalendarGridBody, CalendarGrid, CalendarCellIndicator, CalendarCell } from './calendar.js';
+export { calendarVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+| * Compound Component
+| * -----------------------------------------------------------------------------------------------*/
+const Calendar = Object.assign(CalendarRoot, {
+  Cell: CalendarCell,
+  CellIndicator: CalendarCellIndicator,
+  Grid: CalendarGrid,
+  GridBody: CalendarGridBody,
+  GridHeader: CalendarGridHeader,
+  Header: CalendarHeader,
+  HeaderCell: CalendarHeaderCell,
+  Heading: CalendarHeading,
+  NavButton: CalendarNavButton,
+  Root: CalendarRoot,
+  YearPickerCell: CalendarYearPickerCell,
+  YearPickerGrid: CalendarYearPickerGrid,
+  YearPickerGridBody: CalendarYearPickerGridBody,
+  YearPickerTrigger: CalendarYearPickerTrigger,
+  YearPickerTriggerHeading: CalendarYearPickerTriggerHeading,
+  YearPickerTriggerIndicator: CalendarYearPickerTriggerIndicator
+});
+
+export { Calendar, CalendarCell, CalendarCellIndicator, CalendarGrid, CalendarGridBody, CalendarGridHeader, CalendarHeader, CalendarHeaderCell, CalendarHeading, CalendarNavButton, CalendarRoot };