@cognitiv/components-web 1.0.4 → 1.1.0

package/dist/components/label/label.js

@@ -0,0 +1,27 @@
+"use client";
+import { Label } from 'react-aria-components';
+import { labelVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const LabelRoot = ({
+  children,
+  className,
+  isDisabled,
+  isInvalid,
+  isRequired,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx(Label, {
+    className: labelVariants({
+      className,
+      isDisabled,
+      isInvalid,
+      isRequired
+    }),
+    "data-slot": "label",
+    ...rest,
+    children: children
+  });
+};
+
+export { LabelRoot };

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

@@ -0,0 +1,33 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const labelVariants: import("tailwind-variants").TVReturnType<{
+    isDisabled: {
+        true: string;
+    };
+    isInvalid: {
+        true: string;
+    };
+    isRequired: {
+        true: string;
+    };
+}, undefined, "label", {
+    isDisabled: {
+        true: string;
+    };
+    isInvalid: {
+        true: string;
+    };
+    isRequired: {
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    isDisabled: {
+        true: string;
+    };
+    isInvalid: {
+        true: string;
+    };
+    isRequired: {
+        true: string;
+    };
+}, undefined, "label", unknown, unknown, undefined>>;
+export type LabelVariants = VariantProps<typeof labelVariants>;

package/dist/components/label/styles.js

@@ -0,0 +1,24 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const labelVariants = tv({
+  base: "label",
+  defaultVariants: {
+    isDisabled: false,
+    isInvalid: false,
+    isRequired: false
+  },
+  variants: {
+    isDisabled: {
+      true: "label--disabled"
+    },
+    isInvalid: {
+      true: "label--invalid"
+    },
+    isRequired: {
+      true: "label--required"
+    }
+  }
+});
+
+export { labelVariants };

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

@@ -0,0 +1,15 @@
+import type { ComponentProps } from "react";
+import { LinkIcon, LinkRoot } from "./link";
+export declare const Link: (({ children, className, ...props }: import("./link").LinkRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Icon: ({ children, className, ...rest }: import("./link").LinkIconProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, className, ...props }: import("./link").LinkRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Link = {
+    Props: ComponentProps<typeof LinkRoot>;
+    RootProps: ComponentProps<typeof LinkRoot>;
+    IconProps: ComponentProps<typeof LinkIcon>;
+};
+export { LinkRoot, LinkIcon };
+export type { LinkRootProps, LinkIconProps, LinkRootProps as LinkProps } from "./link";
+export { linkVariants } from "./styles";
+export type { LinkVariants } from "./styles";

package/dist/components/link/index.js

@@ -0,0 +1,13 @@
+"use strict";
+import { LinkRoot, LinkIcon } from './link.js';
+export { linkVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Link = Object.assign(LinkRoot, {
+  Icon: LinkIcon,
+  Root: LinkRoot
+});
+
+export { Link, LinkIcon, LinkRoot };

package/dist/components/link/link.d.ts

@@ -0,0 +1,10 @@
+import type { LinkVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import { Link as LinkPrimitive } from "react-aria-components";
+interface LinkRootProps extends ComponentPropsWithRef<typeof LinkPrimitive>, LinkVariants {
+}
+declare const LinkRoot: ({ children, className, ...props }: LinkRootProps) => import("react/jsx-runtime").JSX.Element;
+type LinkIconProps = ComponentPropsWithRef<"span">;
+declare const LinkIcon: ({ children, className, ...rest }: LinkIconProps) => import("react/jsx-runtime").JSX.Element;
+export { LinkRoot, LinkIcon };
+export type { LinkRootProps, LinkIconProps };

package/dist/components/link/link.js

@@ -0,0 +1,59 @@
+"use client";
+import React__default, { useContext, createContext } from 'react';
+import { Link } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { ExternalLinkIcon } from '../icons.js';
+import { linkVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+const LinkContext = /*#__PURE__*/createContext({});
+
+/* ------------------------------------------------------------------------------------------------
+ * Link Root
+ * --------------------------------------------------------------------------------------------- */
+
+const LinkRoot = ({
+  children,
+  className,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => linkVariants(), []);
+  return /*#__PURE__*/jsx(LinkContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx(Link, {
+      ...props,
+      className: composeTwRenderProps(className, slots?.base()),
+      children: values => /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * Link Icon
+ * --------------------------------------------------------------------------------------------- */
+
+const LinkIcon = ({
+  children,
+  className,
+  ...rest
+}) => {
+  const {
+    slots
+  } = useContext(LinkContext);
+  return /*#__PURE__*/jsx("span", {
+    className: composeSlotClassName(slots?.icon, className),
+    "data-default-icon": dataAttr(!children),
+    "data-slot": "link-icon",
+    ...rest,
+    children: children ?? /*#__PURE__*/jsx(ExternalLinkIcon, {
+      "data-slot": "link-default-icon"
+    })
+  });
+};
+
+export { LinkIcon, LinkRoot };

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

@@ -0,0 +1,35 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const linkVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            icon?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            icon?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    base: string;
+    icon: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            base?: import("tailwind-merge").ClassNameValue;
+            icon?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    base: string;
+    icon: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    base: string;
+    icon: string;
+}, undefined, unknown, unknown, undefined>>;
+type LinkRenderPropsKeys = "isCurrent" | "isHovered" | "isPressed" | "isFocused" | "isFocusVisible" | "isDisabled";
+export type LinkVariants = Omit<VariantProps<typeof linkVariants>, LinkRenderPropsKeys>;
+export {};

package/dist/components/link/styles.js

@@ -0,0 +1,13 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const linkVariants = tv({
+  slots: {
+    base: "link",
+    icon: "link__icon"
+  }
+});
+
+// Render props that should be excluded from LinkVariants (framework-specific)
+
+export { linkVariants };

package/dist/components/list-box/index.d.ts

@@ -0,0 +1,23 @@
+import type { ComponentProps } from "react";
+import { ListBoxItem } from "../list-box-item";
+import { ListBoxSection } from "../list-box-section";
+import { ListBoxRoot } from "./list-box";
+export declare const ListBox: typeof ListBoxRoot & {
+    Item: (({ children, className, variant, ...props }: import("..").ListBoxItemRootProps) => import("react/jsx-runtime").JSX.Element) & {
+        Indicator: ({ children, className, ...props }: import("..").ListBoxItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+        Root: ({ children, className, variant, ...props }: import("..").ListBoxItemRootProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    ItemIndicator: ({ children, className, ...props }: import("..").ListBoxItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Root: typeof ListBoxRoot;
+    Section: ({ children, className, ...props }: import("..").ListBoxSectionRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ListBox = {
+    Props: ComponentProps<typeof ListBoxRoot>;
+    RootProps: ComponentProps<typeof ListBoxRoot>;
+    ItemProps: ComponentProps<typeof ListBoxItem>;
+    SectionProps: ComponentProps<typeof ListBoxSection>;
+};
+export { ListBoxRoot };
+export type { ListBoxRootProps, ListBoxRootProps as ListBoxProps } from "./list-box";
+export { listboxVariants } from "./styles";
+export type { ListBoxVariants } from "./styles";

package/dist/components/list-box/index.js

@@ -0,0 +1,18 @@
+"use strict";
+import { ListBoxItem } from '../list-box-item/index.js';
+import { ListBoxSection } from '../list-box-section/index.js';
+import { ListBoxRoot } from './list-box.js';
+export { listboxVariants } from './styles.js';
+import { ListBoxItemIndicator } from '../list-box-item/list-box-item.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ListBox = Object.assign(ListBoxRoot, {
+  Item: ListBoxItem,
+  ItemIndicator: ListBoxItemIndicator,
+  Root: ListBoxRoot,
+  Section: ListBoxSection
+});
+
+export { ListBox, ListBoxRoot };

package/dist/components/list-box/list-box.d.ts

@@ -0,0 +1,9 @@
+import type { ListBoxVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import { ListBox as ListBoxPrimitive } from "react-aria-components";
+interface ListBoxRootProps<T extends object> extends ComponentPropsWithRef<typeof ListBoxPrimitive<T>>, ListBoxVariants {
+    className?: string;
+}
+declare function ListBoxRoot<T extends object>({ className, variant, ...props }: ListBoxRootProps<T>): import("react/jsx-runtime").JSX.Element;
+export { ListBoxRoot };
+export type { ListBoxRootProps };

package/dist/components/list-box/list-box.js

@@ -0,0 +1,23 @@
+"use client";
+import React__default from 'react';
+import { ListBox } from 'react-aria-components';
+import { listboxVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+import { composeTwRenderProps } from '../../utils/compose.js';
+
+function ListBoxRoot({
+  className,
+  variant,
+  ...props
+}) {
+  const styles = React__default.useMemo(() => listboxVariants({
+    variant
+  }), [variant]);
+  return /*#__PURE__*/jsx(ListBox, {
+    className: composeTwRenderProps(className, styles),
+    "data-slot": "list-box",
+    ...props
+  });
+}
+
+export { ListBoxRoot };

package/dist/components/list-box/styles.d.ts

@@ -0,0 +1,18 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const listboxVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        danger: string;
+        default: string;
+    };
+}, undefined, "list-box", {
+    variant: {
+        danger: string;
+        default: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    variant: {
+        danger: string;
+        default: string;
+    };
+}, undefined, "list-box", unknown, unknown, undefined>>;
+export type ListBoxVariants = VariantProps<typeof listboxVariants>;

package/dist/components/list-box/styles.js

@@ -0,0 +1,17 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const listboxVariants = tv({
+  base: "list-box",
+  defaultVariants: {
+    variant: "default"
+  },
+  variants: {
+    variant: {
+      danger: "list-box--danger",
+      default: "list-box--default"
+    }
+  }
+});
+
+export { listboxVariants };

package/dist/components/list-box-item/index.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentProps } from "react";
+import { ListBoxItemIndicator, ListBoxItemRoot } from "./list-box-item";
+export declare const ListBoxItem: (({ children, className, variant, ...props }: import("./list-box-item").ListBoxItemRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Indicator: ({ children, className, ...props }: import("./list-box-item").ListBoxItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, className, variant, ...props }: import("./list-box-item").ListBoxItemRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ListBoxItem = {
+    Props: ComponentProps<typeof ListBoxItemRoot>;
+    RootProps: ComponentProps<typeof ListBoxItemRoot>;
+    IndicatorProps: ComponentProps<typeof ListBoxItemIndicator>;
+};
+export { ListBoxItemRoot, ListBoxItemIndicator };
+export type { ListBoxItemRootProps, ListBoxItemRootProps as ListBoxItemProps, ListBoxItemIndicatorProps, } from "./list-box-item";
+export { listboxItemVariants } from "./styles";
+export type { ListBoxItemVariants } from "./styles";

package/dist/components/list-box-item/index.js

@@ -0,0 +1,13 @@
+"use strict";
+import { ListBoxItemRoot, ListBoxItemIndicator } from './list-box-item.js';
+export { listboxItemVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ListBoxItem = Object.assign(ListBoxItemRoot, {
+  Indicator: ListBoxItemIndicator,
+  Root: ListBoxItemRoot
+});
+
+export { ListBoxItem, ListBoxItemIndicator, ListBoxItemRoot };

package/dist/components/list-box-item/list-box-item.d.ts

@@ -0,0 +1,15 @@
+import type { ListBoxItemVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { ListBoxItemRenderProps } from "react-aria-components";
+import React from "react";
+import { ListBoxItem as ListBoxItemPrimitive } from "react-aria-components";
+interface ListBoxItemRootProps extends ComponentPropsWithRef<typeof ListBoxItemPrimitive>, ListBoxItemVariants {
+    className?: string;
+}
+declare const ListBoxItemRoot: ({ children, className, variant, ...props }: ListBoxItemRootProps) => import("react/jsx-runtime").JSX.Element;
+interface ListBoxItemIndicatorProps extends Omit<ComponentPropsWithRef<"span">, "children"> {
+    children?: React.ReactNode | ((props: ListBoxItemRenderProps) => React.ReactNode);
+}
+declare const ListBoxItemIndicator: ({ children, className, ...props }: ListBoxItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export { ListBoxItemRoot, ListBoxItemIndicator };
+export type { ListBoxItemRootProps, ListBoxItemIndicatorProps };

package/dist/components/list-box-item/list-box-item.js

@@ -0,0 +1,77 @@
+"use client";
+import React__default, { useContext, createContext } from 'react';
+import { ListBoxItem } from 'react-aria-components';
+import { listboxItemVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+
+const ListBoxItemContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * ListBox Item Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const ListBoxItemRoot = ({
+  children,
+  className,
+  variant,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => listboxItemVariants({
+    variant
+  }), [variant]);
+  return /*#__PURE__*/jsx(ListBoxItem, {
+    className: composeTwRenderProps(className, slots.item()),
+    "data-slot": "list-box-item",
+    ...props,
+    children: values => /*#__PURE__*/jsx(ListBoxItemContext, {
+      value: {
+        slots,
+        state: values
+      },
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ListBox Item Indicator
+ * -----------------------------------------------------------------------------------------------*/
+
+const ListBoxItemIndicator = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots,
+    state
+  } = useContext(ListBoxItemContext);
+  const isSelected = state?.isSelected;
+  const content = typeof children === "function" ? children(state ?? {}) : children ? children : /*#__PURE__*/jsx("svg", {
+    "aria-hidden": "true",
+    "data-slot": "list-box-item-indicator--checkmark",
+    fill: "none",
+    role: "presentation",
+    stroke: "currentColor",
+    strokeDasharray: 22,
+    strokeDashoffset: isSelected ? 44 : 66,
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: 2,
+    viewBox: "0 0 17 18",
+    children: /*#__PURE__*/jsx("polyline", {
+      points: "1 9 7 14 15 4"
+    })
+  });
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.indicator, className),
+    "data-slot": "list-box-item-indicator",
+    "data-visible": isSelected || undefined,
+    ...props,
+    children: content
+  });
+};
+
+export { ListBoxItemIndicator, ListBoxItemRoot };

package/dist/components/list-box-item/styles.d.ts

@@ -0,0 +1,39 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const listboxItemVariants: import("tailwind-variants").TVReturnType<{
+    variant: {
+        danger: {
+            item: string;
+        };
+        default: {
+            item: string;
+        };
+    };
+}, {
+    indicator: string;
+    item: string;
+}, undefined, {
+    variant: {
+        danger: {
+            item: string;
+        };
+        default: {
+            item: string;
+        };
+    };
+}, {
+    indicator: string;
+    item: string;
+}, import("tailwind-variants").TVReturnType<{
+    variant: {
+        danger: {
+            item: string;
+        };
+        default: {
+            item: string;
+        };
+    };
+}, {
+    indicator: string;
+    item: string;
+}, undefined, unknown, unknown, undefined>>;
+export type ListBoxItemVariants = VariantProps<typeof listboxItemVariants>;

package/dist/components/list-box-item/styles.js

@@ -0,0 +1,24 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const listboxItemVariants = tv({
+  defaultVariants: {
+    variant: "default"
+  },
+  slots: {
+    indicator: "list-box-item__indicator",
+    item: "list-box-item"
+  },
+  variants: {
+    variant: {
+      danger: {
+        item: "list-box-item--danger"
+      },
+      default: {
+        item: "list-box-item--default"
+      }
+    }
+  }
+});
+
+export { listboxItemVariants };

package/dist/components/list-box-section/index.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentProps } from "react";
+import { ListBoxSectionRoot } from "./list-box-section";
+export declare const ListBoxSection: ({ children, className, ...props }: import("./list-box-section").ListBoxSectionRootProps) => import("react/jsx-runtime").JSX.Element;
+export type ListBoxSection = {
+    Props: ComponentProps<typeof ListBoxSectionRoot>;
+};
+export { ListBoxSectionRoot };
+export type { ListBoxSectionRootProps, ListBoxSectionRootProps as ListBoxSectionProps, } from "./list-box-section";
+export { listboxSectionVariants } from "./styles";
+export type { ListBoxSectionVariants } from "./styles";

package/dist/components/list-box-section/index.js

@@ -0,0 +1,10 @@
+"use strict";
+import { ListBoxSectionRoot } from './list-box-section.js';
+export { listboxSectionVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ListBoxSection = ListBoxSectionRoot;
+
+export { ListBoxSection, ListBoxSectionRoot };

package/dist/components/list-box-section/list-box-section.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithRef } from "react";
+import { ListBoxSection as ListBoxSectionPrimitive } from "react-aria-components";
+interface ListBoxSectionRootProps extends ComponentPropsWithRef<typeof ListBoxSectionPrimitive> {
+    className?: string;
+}
+declare const ListBoxSectionRoot: ({ children, className, ...props }: ListBoxSectionRootProps) => import("react/jsx-runtime").JSX.Element;
+export { ListBoxSectionRoot };
+export type { ListBoxSectionRootProps };

package/dist/components/list-box-section/list-box-section.js

@@ -0,0 +1,22 @@
+"use client";
+import React__default from 'react';
+import { ListBoxSection } from 'react-aria-components';
+import { listboxSectionVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const ListBoxSectionRoot = ({
+  children,
+  className,
+  ...props
+}) => {
+  const styles = React__default.useMemo(() => listboxSectionVariants({
+    class: typeof className === "string" ? className : undefined
+  }), [className]);
+  return /*#__PURE__*/jsx(ListBoxSection, {
+    className: styles,
+    ...props,
+    children: children
+  });
+};
+
+export { ListBoxSectionRoot };

package/dist/components/list-box-section/styles.d.ts

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

package/dist/components/list-box-section/styles.js

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

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

@@ -0,0 +1,24 @@
+import type { MenuItemRoot } from "../menu-item";
+import type { MenuSectionRoot } from "../menu-section";
+import type { ComponentProps } from "react";
+import { MenuRoot } from "./menu";
+export declare const Menu: typeof MenuRoot & {
+    Item: (({ children, className, variant, ...props }: import("..").MenuItemRootProps) => import("react/jsx-runtime").JSX.Element) & {
+        Indicator: ({ children, className, type, ...props }: import("..").MenuItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+        Root: ({ children, className, variant, ...props }: import("..").MenuItemRootProps) => import("react/jsx-runtime").JSX.Element;
+        SubmenuIndicator: ({ children, className, ...props }: import("..").MenuItemSubmenuIndicatorProps) => import("react/jsx-runtime").JSX.Element | null;
+    };
+    ItemIndicator: ({ children, className, type, ...props }: import("..").MenuItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Root: typeof MenuRoot;
+    Section: ({ children, className, ...props }: import("..").MenuSectionRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Menu<T extends object = object> = {
+    Props: ComponentProps<typeof MenuRoot<T>>;
+    RootProps: ComponentProps<typeof MenuRoot<T>>;
+    ItemProps: ComponentProps<typeof MenuItemRoot>;
+    SectionProps: ComponentProps<typeof MenuSectionRoot>;
+};
+export { MenuRoot };
+export type { MenuRootProps, MenuRootProps as MenuProps } from "./menu";
+export { menuVariants } from "./styles";
+export type { MenuVariants } from "./styles";