@cognitiv/components-web 1.0.4 → 1.1.0

package/dist/components/date-range-picker/date-range-picker.js

@@ -0,0 +1,173 @@
+"use client";
+import { mergeRefs } from '@react-aria/utils';
+import React__default, { useRef, useEffect, useContext, createContext } from 'react';
+import { DateRangePicker, Button, Popover } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { IconCalendar } from '../icons.js';
+import { dateRangePickerVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { SurfaceContext } from '../surface/surface.js';
+
+const DateRangePickerContext = /*#__PURE__*/createContext({
+  triggerRef: {
+    current: null
+  }
+});
+
+/* -------------------------------------------------------------------------------------------------
+ * DateRangePicker Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const DateRangePickerRoot = ({
+  children,
+  className,
+  onOpenChange,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => dateRangePickerVariants(), []);
+  const triggerRef = useRef(null);
+  const [isOpen, setIsOpen] = React__default.useState(false);
+  const shouldRestoreFocusToTriggerRef = useRef(false);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleGlobalKeyDown = event => {
+      if (!event.metaKey && !event.ctrlKey && !event.altKey) {
+        shouldRestoreFocusToTriggerRef.current = true;
+      }
+    };
+    window.addEventListener("keydown", handleGlobalKeyDown, true);
+    return () => {
+      window.removeEventListener("keydown", handleGlobalKeyDown, true);
+    };
+  }, [isOpen]);
+  const handleOpenChange = nextIsOpen => {
+    setIsOpen(nextIsOpen);
+    if (!nextIsOpen && shouldRestoreFocusToTriggerRef.current) {
+      window.requestAnimationFrame(() => {
+        triggerRef.current?.focus();
+      });
+    }
+    shouldRestoreFocusToTriggerRef.current = false;
+    onOpenChange?.(nextIsOpen);
+  };
+  return /*#__PURE__*/jsx(DateRangePickerContext, {
+    value: {
+      slots,
+      triggerRef
+    },
+    children: /*#__PURE__*/jsx(DateRangePicker, {
+      "data-required": dataAttr(props.isRequired),
+      "data-slot": "date-range-picker",
+      ...props,
+      className: composeTwRenderProps(className, slots?.base()),
+      onOpenChange: handleOpenChange,
+      children: values => /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+DateRangePickerRoot.displayName = "Cognitiv.DateRangePicker";
+
+/* -------------------------------------------------------------------------------------------------
+ * DateRangePicker Trigger
+ * -----------------------------------------------------------------------------------------------*/
+
+const DateRangePickerTrigger = /*#__PURE__*/React__default.forwardRef(({
+  children,
+  className,
+  ...props
+}, ref) => {
+  const {
+    slots,
+    triggerRef
+  } = useContext(DateRangePickerContext);
+  const contextRefCallback = React__default.useCallback(node => {
+    triggerRef.current = node;
+  }, [triggerRef]);
+  const mergedRef = mergeRefs(contextRefCallback, ref);
+  return /*#__PURE__*/jsx(Button, {
+    ref: mergedRef,
+    className: composeTwRenderProps(className, slots?.trigger()),
+    "data-slot": "date-range-picker-trigger",
+    ...props,
+    children: values => /*#__PURE__*/jsx(Fragment, {
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+});
+DateRangePickerTrigger.displayName = "Cognitiv.DateRangePicker.Trigger";
+
+/* -------------------------------------------------------------------------------------------------
+ * DateRangePicker Trigger Indicator
+ * -----------------------------------------------------------------------------------------------*/
+
+const DateRangePickerTriggerIndicator = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DateRangePickerContext);
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.triggerIndicator, className),
+    "data-slot": "date-range-picker-trigger-indicator",
+    ...props,
+    children: children || /*#__PURE__*/jsx(IconCalendar, {})
+  });
+};
+DateRangePickerTriggerIndicator.displayName = "Cognitiv.DateRangePicker.TriggerIndicator";
+
+/* -------------------------------------------------------------------------------------------------
+ * DateRangePicker Range Separator
+ * -----------------------------------------------------------------------------------------------*/
+
+const DateRangePickerRangeSeparator = ({
+  children = " - ",
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DateRangePickerContext);
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.rangeSeparator, className),
+    "data-slot": "date-range-picker-range-separator",
+    ...props,
+    children: children
+  });
+};
+DateRangePickerRangeSeparator.displayName = "Cognitiv.DateRangePicker.RangeSeparator";
+
+/* -------------------------------------------------------------------------------------------------
+ * DateRangePicker Popover
+ * -----------------------------------------------------------------------------------------------*/
+
+const DateRangePickerPopover = ({
+  children,
+  className,
+  placement = "bottom",
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DateRangePickerContext);
+  return /*#__PURE__*/jsx(SurfaceContext, {
+    value: {
+      variant: "default"
+    },
+    children: /*#__PURE__*/jsx(Popover, {
+      ...props,
+      className: composeTwRenderProps(className, slots?.popover()),
+      placement: placement,
+      children: children
+    })
+  });
+};
+DateRangePickerPopover.displayName = "Cognitiv.DateRangePicker.Popover";
+
+export { DateRangePickerPopover, DateRangePickerRangeSeparator, DateRangePickerRoot, DateRangePickerTrigger, DateRangePickerTriggerIndicator };

package/dist/components/date-range-picker/index.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentProps } from "react";
+import { DateRangePickerPopover, DateRangePickerRangeSeparator, DateRangePickerRoot, DateRangePickerTrigger, DateRangePickerTriggerIndicator } from "./date-range-picker";
+export declare const DateRangePicker: {
+    <T extends import("react-aria").DateValue>({ children, className, onOpenChange, ...props }: import("./date-range-picker").DateRangePickerRootProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Popover: {
+        ({ children, className, placement, ...props }: import("./date-range-picker").DateRangePickerPopoverProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    RangeSeparator: {
+        ({ children, className, ...props }: import("./date-range-picker").DateRangePickerRangeSeparatorProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Root: {
+        <T extends import("react-aria").DateValue>({ children, className, onOpenChange, ...props }: import("./date-range-picker").DateRangePickerRootProps<T>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("./date-range-picker").DateRangePickerTriggerProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    TriggerIndicator: {
+        ({ children, className, ...props }: import("./date-range-picker").DateRangePickerTriggerIndicatorProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export type DateRangePicker = {
+    Props: ComponentProps<typeof DateRangePickerRoot>;
+    RootProps: ComponentProps<typeof DateRangePickerRoot>;
+    TriggerProps: ComponentProps<typeof DateRangePickerTrigger>;
+    TriggerIndicatorProps: ComponentProps<typeof DateRangePickerTriggerIndicator>;
+    RangeSeparatorProps: ComponentProps<typeof DateRangePickerRangeSeparator>;
+    PopoverProps: ComponentProps<typeof DateRangePickerPopover>;
+};
+export { DateRangePickerRoot, DateRangePickerTrigger, DateRangePickerTriggerIndicator, DateRangePickerRangeSeparator, DateRangePickerPopover, };
+export type { DateRangePickerRootProps, DateRangePickerRootProps as DateRangePickerProps, DateRangePickerTriggerProps, DateRangePickerTriggerIndicatorProps, DateRangePickerRangeSeparatorProps, DateRangePickerPopoverProps, } from "./date-range-picker";
+export { dateRangePickerVariants } from "./styles";
+export type { DateRangePickerVariants } from "./styles";

package/dist/components/date-range-picker/index.js

@@ -0,0 +1,16 @@
+"use strict";
+import { DateRangePickerRoot, DateRangePickerTriggerIndicator, DateRangePickerTrigger, DateRangePickerRangeSeparator, DateRangePickerPopover } from './date-range-picker.js';
+export { dateRangePickerVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const DateRangePicker = Object.assign(DateRangePickerRoot, {
+  Popover: DateRangePickerPopover,
+  RangeSeparator: DateRangePickerRangeSeparator,
+  Root: DateRangePickerRoot,
+  Trigger: DateRangePickerTrigger,
+  TriggerIndicator: DateRangePickerTriggerIndicator
+});
+
+export { DateRangePicker, DateRangePickerPopover, DateRangePickerRangeSeparator, DateRangePickerRoot, DateRangePickerTrigger, DateRangePickerTriggerIndicator };

package/dist/components/date-range-picker/styles.d.ts

@@ -0,0 +1,51 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const dateRangePickerVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            triggerIndicator?: import("tailwind-merge").ClassNameValue;
+            rangeSeparator?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            triggerIndicator?: import("tailwind-merge").ClassNameValue;
+            rangeSeparator?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    base: string;
+    popover: string;
+    rangeSeparator: string;
+    trigger: string;
+    triggerIndicator: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            trigger?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            triggerIndicator?: import("tailwind-merge").ClassNameValue;
+            rangeSeparator?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    base: string;
+    popover: string;
+    rangeSeparator: string;
+    trigger: string;
+    triggerIndicator: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    base: string;
+    popover: string;
+    rangeSeparator: string;
+    trigger: string;
+    triggerIndicator: string;
+}, undefined, unknown, unknown, undefined>>;
+export type DateRangePickerVariants = VariantProps<typeof dateRangePickerVariants>;

package/dist/components/date-range-picker/styles.js

@@ -0,0 +1,14 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const dateRangePickerVariants = tv({
+  slots: {
+    base: "date-range-picker",
+    popover: "date-range-picker__popover",
+    rangeSeparator: "date-range-picker__range-separator",
+    trigger: "date-range-picker__trigger",
+    triggerIndicator: "date-range-picker__trigger-indicator"
+  }
+});
+
+export { dateRangePickerVariants };

package/dist/components/description/description.d.ts

@@ -0,0 +1,9 @@
+import type { DescriptionVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { TextProps } from "react-aria-components";
+import { Text } from "react-aria-components";
+interface DescriptionRootProps extends ComponentPropsWithRef<typeof Text>, TextProps, DescriptionVariants {
+}
+declare const DescriptionRoot: ({ children, className, ...rest }: DescriptionRootProps) => import("react/jsx-runtime").JSX.Element;
+export { DescriptionRoot };
+export type { DescriptionRootProps };

package/dist/components/description/description.js

@@ -0,0 +1,22 @@
+"use client";
+import { Text } from 'react-aria-components';
+import { descriptionVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const DescriptionRoot = ({
+  children,
+  className,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx(Text, {
+    className: descriptionVariants({
+      className
+    }),
+    "data-slot": "description",
+    slot: "description",
+    ...rest,
+    children: children
+  });
+};
+
+export { DescriptionRoot };

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

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { DescriptionRoot } from "./description";
+export declare const Description: (({ children, className, ...rest }: import("./description").DescriptionRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, ...rest }: import("./description").DescriptionRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Description = {
+    Props: ComponentProps<typeof DescriptionRoot>;
+    RootProps: ComponentProps<typeof DescriptionRoot>;
+};
+export { DescriptionRoot };
+export type { DescriptionRootProps, DescriptionRootProps as DescriptionProps } from "./description";
+export { descriptionVariants } from "./styles";
+export type { DescriptionVariants } from "./styles";

package/dist/components/description/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { DescriptionRoot } from './description.js';
+export { descriptionVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Description = Object.assign(DescriptionRoot, {
+  Root: DescriptionRoot
+});
+
+export { Description, DescriptionRoot };

package/dist/components/description/styles.d.ts

@@ -0,0 +1,3 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const descriptionVariants: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "description", {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, "description", unknown, unknown, undefined>>;
+export type DescriptionVariants = VariantProps<typeof descriptionVariants>;

package/dist/components/description/styles.js

@@ -0,0 +1,8 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const descriptionVariants = tv({
+  base: "description"
+});
+
+export { descriptionVariants };

package/dist/components/disclosure/disclosure.d.ts

@@ -0,0 +1,27 @@
+import type { DisclosureVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { ButtonProps } from "react-aria-components";
+import { Heading as DisclosureHeadingPrimitive, DisclosurePanel, Disclosure as DisclosurePrimitive } from "react-aria-components";
+interface DisclosureRootProps extends ComponentPropsWithRef<typeof DisclosurePrimitive>, DisclosureVariants {
+}
+declare const DisclosureRoot: ({ children, className, ...props }: DisclosureRootProps) => import("react/jsx-runtime").JSX.Element;
+interface DisclosureHeadingProps extends ComponentPropsWithRef<typeof DisclosureHeadingPrimitive> {
+    className?: string;
+}
+declare const DisclosureHeading: ({ className, ...props }: DisclosureHeadingProps) => import("react/jsx-runtime").JSX.Element;
+interface DisclosureTriggerProps extends ButtonProps {
+}
+declare const DisclosureTrigger: ({ className, ...props }: DisclosureTriggerProps) => import("react/jsx-runtime").JSX.Element;
+interface DisclosureContentProps extends ComponentPropsWithRef<typeof DisclosurePanel> {
+}
+declare const DisclosureContent: ({ children, className, ...props }: DisclosureContentProps) => import("react/jsx-runtime").JSX.Element;
+interface DisclosureBodyContentProps extends ComponentPropsWithRef<"div"> {
+    className?: string;
+}
+declare const DisclosureBody: ({ children, className, ...props }: DisclosureBodyContentProps) => import("react/jsx-runtime").JSX.Element;
+interface DisclosureIndicatorProps extends ComponentPropsWithRef<"svg"> {
+    className?: string;
+}
+declare const DisclosureIndicator: ({ children, className, ...props }: DisclosureIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export { DisclosureRoot, DisclosureHeading, DisclosureTrigger, DisclosureContent, DisclosureBody, DisclosureIndicator, };
+export type { DisclosureRootProps, DisclosureContentProps, DisclosureHeadingProps, DisclosureTriggerProps, DisclosureIndicatorProps, DisclosureBodyContentProps, };

package/dist/components/disclosure/disclosure.js

@@ -0,0 +1,157 @@
+"use client";
+import React__default, { useContext, useRef, createContext } from 'react';
+import { Disclosure, Button, DisclosureStateContext, Heading, DisclosurePanel } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { IconChevronDown } from '../icons.js';
+import { disclosureVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+const DisclosureContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureRoot = ({
+  children,
+  className,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => disclosureVariants({}), []);
+  return /*#__PURE__*/jsx(DisclosureContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx(Disclosure, {
+      "data-slot": "disclosure",
+      ...props,
+      className: composeTwRenderProps(className, slots.base()),
+      children: values => /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Heading
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureHeading = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DisclosureContext);
+  return /*#__PURE__*/jsx(Heading, {
+    className: composeSlotClassName(slots?.heading, className),
+    "data-slot": "disclosure-heading",
+    ...props
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Trigger
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureTrigger = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DisclosureContext);
+  return /*#__PURE__*/jsx(Button, {
+    className: composeTwRenderProps(className, slots?.trigger()),
+    "data-slot": "disclosure-trigger",
+    slot: "trigger",
+    ...props,
+    children: values => /*#__PURE__*/jsx(Fragment, {
+      children: typeof props.children === "function" ? props.children(values) : props.children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Content
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureContent = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DisclosureContext);
+  const contentRef = useRef(null);
+  const {
+    isExpanded
+  } = useContext(DisclosureStateContext);
+  return /*#__PURE__*/jsx(DisclosurePanel, {
+    ref: contentRef,
+    className: composeTwRenderProps(className, slots?.content()),
+    "data-expanded": dataAttr(isExpanded),
+    "data-slot": "disclosure-content",
+    ...props,
+    children: children
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Body
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureBody = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DisclosureContext);
+  return /*#__PURE__*/jsx("div", {
+    className: slots?.body({}),
+    "data-slot": "disclosure-body",
+    ...props,
+    children: /*#__PURE__*/jsx("div", {
+      className: composeSlotClassName(slots?.bodyInner, className),
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Disclosure Indicator
+ * -----------------------------------------------------------------------------------------------*/
+
+const DisclosureIndicator = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    isExpanded
+  } = useContext(DisclosureStateContext);
+  const {
+    slots
+  } = useContext(DisclosureContext);
+  if (children && /*#__PURE__*/React__default.isValidElement(children)) {
+    return /*#__PURE__*/React__default.cloneElement(children, {
+      ...props,
+      className: composeSlotClassName(slots?.indicator, className),
+      "data-expanded": dataAttr(isExpanded),
+      "data-slot": "disclosure-indicator"
+    });
+  }
+  return /*#__PURE__*/jsx(IconChevronDown, {
+    className: composeSlotClassName(slots?.indicator, className),
+    "data-expanded": dataAttr(isExpanded),
+    "data-slot": "disclosure-indicator",
+    ...props
+  });
+};
+
+export { DisclosureBody, DisclosureContent, DisclosureHeading, DisclosureIndicator, DisclosureRoot, DisclosureTrigger };

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

@@ -0,0 +1,23 @@
+import type { ComponentProps } from "react";
+import { DisclosureBody, DisclosureContent, DisclosureHeading, DisclosureIndicator, DisclosureRoot, DisclosureTrigger } from "./disclosure";
+export declare const Disclosure: (({ children, className, ...props }: import("./disclosure").DisclosureRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Body: ({ children, className, ...props }: import("./disclosure").DisclosureBodyContentProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children, className, ...props }: import("./disclosure").DisclosureContentProps) => import("react/jsx-runtime").JSX.Element;
+    Heading: ({ className, ...props }: import("./disclosure").DisclosureHeadingProps) => import("react/jsx-runtime").JSX.Element;
+    Indicator: ({ children, className, ...props }: import("./disclosure").DisclosureIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, className, ...props }: import("./disclosure").DisclosureRootProps) => import("react/jsx-runtime").JSX.Element;
+    Trigger: ({ className, ...props }: import("./disclosure").DisclosureTriggerProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Disclosure = {
+    Props: ComponentProps<typeof DisclosureRoot>;
+    RootProps: ComponentProps<typeof DisclosureRoot>;
+    HeadingProps: ComponentProps<typeof DisclosureHeading>;
+    TriggerProps: ComponentProps<typeof DisclosureTrigger>;
+    ContentProps: ComponentProps<typeof DisclosureContent>;
+    BodyProps: ComponentProps<typeof DisclosureBody>;
+    IndicatorProps: ComponentProps<typeof DisclosureIndicator>;
+};
+export { DisclosureRoot, DisclosureHeading, DisclosureTrigger, DisclosureContent, DisclosureBody, DisclosureIndicator, };
+export type { DisclosureRootProps, DisclosureRootProps as DisclosureProps, DisclosureContentProps, DisclosureHeadingProps, DisclosureTriggerProps, DisclosureIndicatorProps, DisclosureBodyContentProps, } from "./disclosure";
+export { disclosureVariants } from "./styles";
+export type { DisclosureVariants } from "./styles";

package/dist/components/disclosure/index.js

@@ -0,0 +1,17 @@
+"use strict";
+import { DisclosureRoot, DisclosureTrigger, DisclosureIndicator, DisclosureHeading, DisclosureContent, DisclosureBody } from './disclosure.js';
+export { disclosureVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Disclosure = Object.assign(DisclosureRoot, {
+  Body: DisclosureBody,
+  Content: DisclosureContent,
+  Heading: DisclosureHeading,
+  Indicator: DisclosureIndicator,
+  Root: DisclosureRoot,
+  Trigger: DisclosureTrigger
+});
+
+export { Disclosure, DisclosureBody, DisclosureContent, DisclosureHeading, DisclosureIndicator, DisclosureRoot, DisclosureTrigger };

package/dist/components/disclosure/styles.d.ts

@@ -0,0 +1,29 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const disclosureVariants: import("tailwind-variants").TVReturnType<{}, {
+    base: string;
+    body: string;
+    bodyInner: string;
+    content: string;
+    heading: string;
+    indicator: string;
+    trigger: string;
+}, undefined, {}, {
+    base: string;
+    body: string;
+    bodyInner: string;
+    content: string;
+    heading: string;
+    indicator: string;
+    trigger: string;
+}, import("tailwind-variants").TVReturnType<{}, {
+    base: string;
+    body: string;
+    bodyInner: string;
+    content: string;
+    heading: string;
+    indicator: string;
+    trigger: string;
+}, undefined, unknown, unknown, undefined>>;
+type DisclosureRenderPropsKeys = "isExpanded" | "isDisabled" | "state";
+export type DisclosureVariants = Omit<VariantProps<typeof disclosureVariants>, DisclosureRenderPropsKeys>;
+export {};

package/dist/components/disclosure/styles.js

@@ -0,0 +1,20 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const disclosureVariants = tv({
+  defaultVariants: {},
+  slots: {
+    base: "disclosure",
+    body: "disclosure__body",
+    bodyInner: "disclosure__body-inner",
+    content: "disclosure__content",
+    heading: "disclosure__heading",
+    indicator: "disclosure__indicator",
+    trigger: "disclosure__trigger"
+  },
+  variants: {}
+});
+
+// Render props that should be excluded from DisclosureVariants (framework-specific)
+
+export { disclosureVariants };

package/dist/components/disclosure-group/disclosure-group.d.ts

@@ -0,0 +1,8 @@
+import type { DisclosureGroupVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import { DisclosureGroup as DisclosureGroupPrimitive } from "react-aria-components";
+interface DisclosureGroupRootProps extends ComponentPropsWithRef<typeof DisclosureGroupPrimitive>, DisclosureGroupVariants {
+}
+declare const DisclosureGroupRoot: ({ children, className, ...props }: DisclosureGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+export { DisclosureGroupRoot };
+export type { DisclosureGroupRootProps };