@cognitiv/components-web 1.0.4 → 1.1.0

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

@@ -0,0 +1,69 @@
+import type { ComponentProps } from "react";
+import { DrawerBackdrop, DrawerBody, DrawerCloseTrigger, DrawerContent, DrawerDialog, DrawerFooter, DrawerHandle, DrawerHeader, DrawerHeading, DrawerRoot, DrawerTrigger } from "./drawer";
+export declare const Drawer: {
+    ({ children, state, ...props }: import("./drawer").DrawerRootProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Backdrop: {
+        ({ children, className, isDismissable, variant, ...props }: import("./drawer").DrawerBackdropProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        ({ children, className, ...props }: import("./drawer").DrawerBodyProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    CloseTrigger: {
+        ({ className, ...rest }: import("./drawer").DrawerCloseTriggerProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ children, className, placement, ...props }: import("./drawer").DrawerContentProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Dialog: {
+        ({ children, className, ...props }: import("./drawer").DrawerDialogProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ children, className, ...props }: import("./drawer").DrawerFooterProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Handle: {
+        ({ className, ...props }: import("./drawer").DrawerHandleProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        ({ children, className, ...props }: import("./drawer").DrawerHeaderProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Heading: {
+        ({ children, className, ...props }: import("./drawer").DrawerHeadingProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Root: {
+        ({ children, state, ...props }: import("./drawer").DrawerRootProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        ({ children, className, ...props }: import("./drawer").DrawerTriggerProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export type Drawer = {
+    Props: ComponentProps<typeof DrawerRoot>;
+    RootProps: ComponentProps<typeof DrawerRoot>;
+    TriggerProps: ComponentProps<typeof DrawerTrigger>;
+    BackdropProps: ComponentProps<typeof DrawerBackdrop>;
+    ContentProps: ComponentProps<typeof DrawerContent>;
+    DialogProps: ComponentProps<typeof DrawerDialog>;
+    HeaderProps: ComponentProps<typeof DrawerHeader>;
+    HeadingProps: ComponentProps<typeof DrawerHeading>;
+    BodyProps: ComponentProps<typeof DrawerBody>;
+    FooterProps: ComponentProps<typeof DrawerFooter>;
+    HandleProps: ComponentProps<typeof DrawerHandle>;
+    CloseTriggerProps: ComponentProps<typeof DrawerCloseTrigger>;
+};
+export { DrawerRoot, DrawerTrigger, DrawerBackdrop, DrawerContent, DrawerDialog, DrawerHeader, DrawerHeading, DrawerBody, DrawerFooter, DrawerHandle, DrawerCloseTrigger, };
+export type { DrawerRootProps, DrawerRootProps as DrawerProps, DrawerTriggerProps, DrawerBackdropProps, DrawerContentProps, DrawerDialogProps, DrawerHeaderProps, DrawerHeadingProps, DrawerBodyProps, DrawerFooterProps, DrawerHandleProps, DrawerCloseTriggerProps, } from "./drawer";
+export { drawerVariants } from "./styles";
+export type { DrawerVariants } from "./styles";

package/dist/components/drawer/index.js

@@ -0,0 +1,22 @@
+"use strict";
+import { DrawerRoot, DrawerTrigger, DrawerHeading, DrawerHeader, DrawerHandle, DrawerFooter, DrawerDialog, DrawerContent, DrawerCloseTrigger, DrawerBody, DrawerBackdrop } from './drawer.js';
+export { drawerVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Drawer = Object.assign(DrawerRoot, {
+  Backdrop: DrawerBackdrop,
+  Body: DrawerBody,
+  CloseTrigger: DrawerCloseTrigger,
+  Content: DrawerContent,
+  Dialog: DrawerDialog,
+  Footer: DrawerFooter,
+  Handle: DrawerHandle,
+  Header: DrawerHeader,
+  Heading: DrawerHeading,
+  Root: DrawerRoot,
+  Trigger: DrawerTrigger
+});
+
+export { Drawer, DrawerBackdrop, DrawerBody, DrawerCloseTrigger, DrawerContent, DrawerDialog, DrawerFooter, DrawerHandle, DrawerHeader, DrawerHeading, DrawerRoot, DrawerTrigger };

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

@@ -0,0 +1,126 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const drawerVariants: import("tailwind-variants").TVReturnType<{
+    placement: {
+        bottom: {
+            content: string;
+            dialog: string;
+        };
+        left: {
+            content: string;
+            dialog: string;
+        };
+        right: {
+            content: string;
+            dialog: string;
+        };
+        top: {
+            content: string;
+            dialog: string;
+        };
+    };
+    variant: {
+        blur: {
+            backdrop: string;
+        };
+        opaque: {
+            backdrop: string;
+        };
+        transparent: {
+            backdrop: string;
+        };
+    };
+}, {
+    backdrop: string;
+    body: string;
+    closeTrigger: string;
+    content: string;
+    dialog: string;
+    footer: string;
+    handle: string;
+    header: string;
+    heading: string;
+    trigger: string;
+}, undefined, {
+    placement: {
+        bottom: {
+            content: string;
+            dialog: string;
+        };
+        left: {
+            content: string;
+            dialog: string;
+        };
+        right: {
+            content: string;
+            dialog: string;
+        };
+        top: {
+            content: string;
+            dialog: string;
+        };
+    };
+    variant: {
+        blur: {
+            backdrop: string;
+        };
+        opaque: {
+            backdrop: string;
+        };
+        transparent: {
+            backdrop: string;
+        };
+    };
+}, {
+    backdrop: string;
+    body: string;
+    closeTrigger: string;
+    content: string;
+    dialog: string;
+    footer: string;
+    handle: string;
+    header: string;
+    heading: string;
+    trigger: string;
+}, import("tailwind-variants").TVReturnType<{
+    placement: {
+        bottom: {
+            content: string;
+            dialog: string;
+        };
+        left: {
+            content: string;
+            dialog: string;
+        };
+        right: {
+            content: string;
+            dialog: string;
+        };
+        top: {
+            content: string;
+            dialog: string;
+        };
+    };
+    variant: {
+        blur: {
+            backdrop: string;
+        };
+        opaque: {
+            backdrop: string;
+        };
+        transparent: {
+            backdrop: string;
+        };
+    };
+}, {
+    backdrop: string;
+    body: string;
+    closeTrigger: string;
+    content: string;
+    dialog: string;
+    footer: string;
+    handle: string;
+    header: string;
+    heading: string;
+    trigger: string;
+}, undefined, unknown, unknown, undefined>>;
+export type DrawerVariants = VariantProps<typeof drawerVariants>;

package/dist/components/drawer/styles.js

@@ -0,0 +1,54 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const drawerVariants = tv({
+  defaultVariants: {
+    placement: "bottom",
+    variant: "opaque"
+  },
+  slots: {
+    backdrop: "drawer__backdrop",
+    body: "drawer__body",
+    closeTrigger: "drawer__close-trigger",
+    content: "drawer__content",
+    dialog: "drawer__dialog",
+    footer: "drawer__footer",
+    handle: "drawer__handle",
+    header: "drawer__header",
+    heading: "drawer__heading",
+    trigger: "drawer__trigger"
+  },
+  variants: {
+    placement: {
+      bottom: {
+        content: "drawer__content--bottom",
+        dialog: "drawer__dialog--bottom"
+      },
+      left: {
+        content: "drawer__content--left",
+        dialog: "drawer__dialog--left"
+      },
+      right: {
+        content: "drawer__content--right",
+        dialog: "drawer__dialog--right"
+      },
+      top: {
+        content: "drawer__content--top",
+        dialog: "drawer__dialog--top"
+      }
+    },
+    variant: {
+      blur: {
+        backdrop: "drawer__backdrop--blur"
+      },
+      opaque: {
+        backdrop: "drawer__backdrop--opaque"
+      },
+      transparent: {
+        backdrop: "drawer__backdrop--transparent"
+      }
+    }
+  }
+});
+
+export { drawerVariants };

package/dist/components/dropdown/dropdown.d.ts

@@ -0,0 +1,38 @@
+import type { DropdownVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import React from "react";
+import { Button, Menu as MenuPrimitive, MenuTrigger as MenuTriggerPrimitive, Popover as PopoverPrimitive, SubmenuTrigger as SubmenuTriggerPrimitive } from "react-aria-components";
+import { MenuItemIndicator, MenuItemRoot, MenuItemSubmenuIndicator } from "../menu-item";
+import { MenuSectionRoot } from "../menu-section";
+interface DropdownRootProps extends ComponentPropsWithRef<typeof MenuTriggerPrimitive>, DropdownVariants {
+    className?: string;
+}
+declare const DropdownRoot: ({ children, ...props }: DropdownRootProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownTriggerProps extends ComponentPropsWithRef<typeof Button> {
+}
+declare const DropdownTrigger: ({ children, className, ...props }: DropdownTriggerProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownPopoverProps extends Omit<ComponentPropsWithRef<typeof PopoverPrimitive>, "children">, DropdownVariants {
+    children: React.ReactNode;
+}
+declare const DropdownPopover: ({ children, className, placement, ...props }: DropdownPopoverProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownMenuProps<T extends object> extends ComponentPropsWithRef<typeof MenuPrimitive<T>>, DropdownVariants {
+    className?: string;
+}
+declare function DropdownMenu<T extends object>({ className, ...props }: DropdownMenuProps<T>): import("react/jsx-runtime").JSX.Element;
+interface DropdownItemProps extends ComponentPropsWithRef<typeof MenuItemRoot> {
+}
+declare const DropdownItem: (props: DropdownItemProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownSubmenuIndicatorProps extends ComponentPropsWithRef<typeof MenuItemSubmenuIndicator> {
+}
+declare const DropdownSubmenuIndicator: (props: DropdownSubmenuIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownSubmenuTriggerProps extends ComponentPropsWithRef<typeof SubmenuTriggerPrimitive> {
+}
+declare const DropdownSubmenuTrigger: ({ children, ...props }: DropdownSubmenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownItemIndicatorProps extends ComponentPropsWithRef<typeof MenuItemIndicator> {
+}
+declare const DropdownItemIndicator: (props: DropdownItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+interface DropdownSectionProps extends ComponentPropsWithRef<typeof MenuSectionRoot> {
+}
+declare const DropdownSection: (props: DropdownSectionProps) => import("react/jsx-runtime").JSX.Element;
+export { DropdownItem, DropdownItemIndicator, DropdownMenu, DropdownPopover, DropdownRoot, DropdownSection, DropdownSubmenuIndicator, DropdownSubmenuTrigger, DropdownTrigger, };
+export type { DropdownItemIndicatorProps, DropdownItemProps, DropdownMenuProps, DropdownPopoverProps, DropdownRootProps, DropdownSectionProps, DropdownSubmenuIndicatorProps, DropdownSubmenuTriggerProps, DropdownTriggerProps, };

package/dist/components/dropdown/dropdown.js

@@ -0,0 +1,156 @@
+"use client";
+import React__default, { useContext, createContext } from 'react';
+import { MenuTrigger, Button, SubmenuTrigger, Popover, Menu } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import '../menu-item/index.js';
+import { MenuSectionRoot } from '../menu-section/menu-section.js';
+import { dropdownVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { MenuItemSubmenuIndicator, MenuItemIndicator, MenuItemRoot } from '../menu-item/menu-item.js';
+import { SurfaceContext } from '../surface/surface.js';
+
+const DropdownContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Root (MenuTrigger wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownRoot = ({
+  children,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => dropdownVariants(), []);
+  return /*#__PURE__*/jsx(DropdownContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx(MenuTrigger, {
+      ...props,
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Trigger (Button wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownTrigger = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DropdownContext);
+  return /*#__PURE__*/jsx(Button, {
+    className: composeTwRenderProps(className, slots?.trigger()),
+    "data-slot": "dropdown-trigger",
+    ...props,
+    children: values => /*#__PURE__*/jsx(Fragment, {
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Popover (Popover wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownPopover = ({
+  children,
+  className,
+  placement,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(DropdownContext);
+  return /*#__PURE__*/jsx(SurfaceContext, {
+    value: {
+      variant: "default"
+    },
+    children: /*#__PURE__*/jsx(Popover, {
+      ...props,
+      className: composeTwRenderProps(className, slots?.popover()),
+      placement: placement,
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Menu (Menu wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+function DropdownMenu({
+  className,
+  ...props
+}) {
+  const {
+    slots
+  } = useContext(DropdownContext);
+  return /*#__PURE__*/jsx(Menu, {
+    className: composeTwRenderProps(className, slots?.menu()),
+    "data-selection-mode": props.selectionMode,
+    "data-slot": "dropdown-menu",
+    ...props
+  });
+}
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Item (MenuItem wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownItem = props => {
+  return /*#__PURE__*/jsx(MenuItemRoot, {
+    ...props
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Submenu Indicator (MenuItemSubmenuIndicator wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownSubmenuIndicator = props => {
+  return /*#__PURE__*/jsx(MenuItemSubmenuIndicator, {
+    ...props
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Submenu Trigger
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownSubmenuTrigger = ({
+  children,
+  ...props
+}) => {
+  return /*#__PURE__*/jsx(SubmenuTrigger, {
+    "data-slot": "dropdown-submenu-trigger",
+    ...props,
+    children: children
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Item Indicator (MenuItemIndicator wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownItemIndicator = props => {
+  return /*#__PURE__*/jsx(MenuItemIndicator, {
+    ...props
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Dropdown Section (MenuSection wrapper)
+ * -----------------------------------------------------------------------------------------------*/
+
+const DropdownSection = props => {
+  return /*#__PURE__*/jsx(MenuSectionRoot, {
+    ...props
+  });
+};
+
+export { DropdownItem, DropdownItemIndicator, DropdownMenu, DropdownPopover, DropdownRoot, DropdownSection, DropdownSubmenuIndicator, DropdownSubmenuTrigger, DropdownTrigger };

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

@@ -0,0 +1,29 @@
+import type { ComponentProps } from "react";
+import { DropdownItem, DropdownItemIndicator, DropdownMenu, DropdownPopover, DropdownRoot, DropdownSection, DropdownSubmenuIndicator, DropdownSubmenuTrigger, DropdownTrigger } from "./dropdown";
+export declare const Dropdown: (({ children, ...props }: import("./dropdown").DropdownRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Item: (props: import("./dropdown").DropdownItemProps) => import("react/jsx-runtime").JSX.Element;
+    ItemIndicator: (props: import("./dropdown").DropdownItemIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Menu: typeof DropdownMenu;
+    Popover: ({ children, className, placement, ...props }: import("./dropdown").DropdownPopoverProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, ...props }: import("./dropdown").DropdownRootProps) => import("react/jsx-runtime").JSX.Element;
+    Section: (props: import("./dropdown").DropdownSectionProps) => import("react/jsx-runtime").JSX.Element;
+    SubmenuIndicator: (props: import("./dropdown").DropdownSubmenuIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    SubmenuTrigger: ({ children, ...props }: import("./dropdown").DropdownSubmenuTriggerProps) => import("react/jsx-runtime").JSX.Element;
+    Trigger: ({ children, className, ...props }: import("./dropdown").DropdownTriggerProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Dropdown<T extends object = object> = {
+    Props: ComponentProps<typeof DropdownRoot>;
+    RootProps: ComponentProps<typeof DropdownRoot>;
+    TriggerProps: ComponentProps<typeof DropdownTrigger>;
+    PopoverProps: ComponentProps<typeof DropdownPopover>;
+    MenuProps: ComponentProps<typeof DropdownMenu<T>>;
+    SectionProps: ComponentProps<typeof DropdownSection>;
+    ItemProps: ComponentProps<typeof DropdownItem>;
+    ItemIndicatorProps: ComponentProps<typeof DropdownItemIndicator>;
+    SubmenuIndicatorProps: ComponentProps<typeof DropdownSubmenuIndicator>;
+    SubmenuTriggerProps: ComponentProps<typeof DropdownSubmenuTrigger>;
+};
+export { DropdownItem, DropdownItemIndicator, DropdownMenu, DropdownPopover, DropdownRoot, DropdownSection, DropdownSubmenuIndicator, DropdownSubmenuTrigger, DropdownTrigger, };
+export type { DropdownItemIndicatorProps, DropdownItemProps, DropdownMenuProps, DropdownPopoverProps, DropdownRootProps, DropdownRootProps as DropdownProps, DropdownSectionProps, DropdownSubmenuIndicatorProps, DropdownSubmenuTriggerProps, DropdownTriggerProps, } from "./dropdown";
+export { dropdownVariants } from "./styles";
+export type { DropdownVariants } from "./styles";

package/dist/components/dropdown/index.js

@@ -0,0 +1,20 @@
+"use strict";
+import { DropdownRoot, DropdownTrigger, DropdownSubmenuTrigger, DropdownSubmenuIndicator, DropdownSection, DropdownPopover, DropdownMenu, DropdownItemIndicator, DropdownItem } from './dropdown.js';
+export { dropdownVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Dropdown = Object.assign(DropdownRoot, {
+  Item: DropdownItem,
+  ItemIndicator: DropdownItemIndicator,
+  Menu: DropdownMenu,
+  Popover: DropdownPopover,
+  Root: DropdownRoot,
+  Section: DropdownSection,
+  SubmenuIndicator: DropdownSubmenuIndicator,
+  SubmenuTrigger: DropdownSubmenuTrigger,
+  Trigger: DropdownTrigger
+});
+
+export { Dropdown, DropdownItem, DropdownItemIndicator, DropdownMenu, DropdownPopover, DropdownRoot, DropdownSection, DropdownSubmenuIndicator, DropdownSubmenuTrigger, DropdownTrigger };

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

@@ -0,0 +1,45 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const dropdownVariants: import("tailwind-variants").TVReturnType<{
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            trigger?: import("tailwind-merge").ClassNameValue;
+            menu?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import("tailwind-merge").ClassNameValue | {
+            trigger?: import("tailwind-merge").ClassNameValue;
+            menu?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    menu: string;
+    popover: string;
+    root: string;
+    trigger: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import("tailwind-merge").ClassNameValue | {
+            trigger?: import("tailwind-merge").ClassNameValue;
+            menu?: import("tailwind-merge").ClassNameValue;
+            popover?: import("tailwind-merge").ClassNameValue;
+            root?: import("tailwind-merge").ClassNameValue;
+        };
+    };
+} | {}, {
+    menu: string;
+    popover: string;
+    root: string;
+    trigger: string;
+}, import("tailwind-variants").TVReturnType<unknown, {
+    menu: string;
+    popover: string;
+    root: string;
+    trigger: string;
+}, undefined, unknown, unknown, undefined>>;
+export type DropdownVariants = VariantProps<typeof dropdownVariants>;

package/dist/components/dropdown/styles.js

@@ -0,0 +1,13 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const dropdownVariants = tv({
+  slots: {
+    menu: "dropdown__menu",
+    popover: "dropdown__popover",
+    root: "dropdown",
+    trigger: "dropdown__trigger"
+  }
+});
+
+export { dropdownVariants };

package/dist/components/empty-state/empty-state.d.ts

@@ -0,0 +1,7 @@
+import type { EmptyStateVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+interface EmptyStateRootProps extends ComponentPropsWithRef<"div">, EmptyStateVariants {
+}
+declare const EmptyStateRoot: ({ children, className, ...rest }: EmptyStateRootProps) => import("react/jsx-runtime").JSX.Element;
+export { EmptyStateRoot };
+export type { EmptyStateRootProps };

package/dist/components/empty-state/empty-state.js

@@ -0,0 +1,20 @@
+"use client";
+import { emptyStateVariants } from './styles.js';
+import { jsx } from 'react/jsx-runtime';
+
+const EmptyStateRoot = ({
+  children,
+  className,
+  ...rest
+}) => {
+  return /*#__PURE__*/jsx("div", {
+    className: emptyStateVariants({
+      className
+    }),
+    "data-slot": "empty-state",
+    ...rest,
+    children: children || "No results found"
+  });
+};
+
+export { EmptyStateRoot };

package/dist/components/empty-state/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { EmptyStateRoot } from "./empty-state";
+export declare const EmptyState: (({ children, className, ...rest }: import("./empty-state").EmptyStateRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, ...rest }: import("./empty-state").EmptyStateRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type EmptyState = {
+    Props: ComponentProps<typeof EmptyStateRoot>;
+    RootProps: ComponentProps<typeof EmptyStateRoot>;
+};
+export { EmptyStateRoot };
+export type { EmptyStateRootProps, EmptyStateRootProps as EmptyStateProps } from "./empty-state";
+export { emptyStateVariants } from "./styles";
+export type { EmptyStateVariants } from "./styles";

package/dist/components/empty-state/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { EmptyStateRoot } from './empty-state.js';
+export { emptyStateVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const EmptyState = Object.assign(EmptyStateRoot, {
+  Root: EmptyStateRoot
+});
+
+export { EmptyState, EmptyStateRoot };

package/dist/components/empty-state/styles.d.ts

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

package/dist/components/empty-state/styles.js

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

package/dist/components/error-message/error-message.d.ts

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