@chassis-ui/react 0.1.2 → 0.2.0

package/dist/chunks/index-DR8sYtvd.d.ts

@@ -0,0 +1,296 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { i as MenuItemsDef } from "./MenuItemDef-D0VDtYIQ.js";
+import { a as Shapes, n as ContextColor, r as ContextStyle } from "./types-CS_40Txv.js";
+import { t as Button } from "./Button-Cptd4Yk7.js";
+import { n as LinkProps } from "./Link-B0Y1xgYi.js";
+import { t as Placement } from "./overlayPlacement-B7843a-Q.js";
+import React, { ButtonHTMLAttributes, ElementType, Fragment, HTMLAttributes, ReactElement, ReactNode } from "react";
+import "react-aria";
+//#region src/components/menu/Menu.d.ts
+type MenuFocusStrategy = 'first' | 'last';
+type MenuAutoClose = boolean | 'inside' | 'outside';
+type MenuOwnProps<C extends ElementType> = {
+  /**
+   * Controls which clicks close the menu. `true` closes on any click inside or outside.
+   * `false` requires a programmatic `visible` change. `'inside'` closes only on click inside
+   * the menu. `'outside'` closes only on click outside the menu.
+   */
+  autoClose?: MenuAutoClose;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   * Defaults to `Fragment` — `MenuToggle`/`MenuList` render with no wrapping element, so
+   * they land as direct children of whatever contains the `Menu`. This matters inside
+   * `ButtonGroup`/`InputGroup`, whose CSS expects the toggle button and menu panel as direct
+   * children rather than nested inside an intermediate node.
+   *
+   * Pass an actual element (e.g. `"div"`, or `"li"` for a navbar item) to opt back into a
+   * wrapper — needed if you want to apply `className`/`style`/other rest props to a container
+   * around the whole menu, for semantic wrapping like a nav `<li>`, or for `reference="parent"`,
+   * which positions off this wrapper and has nothing to measure against without one.
+   */
+  component?: C;
+  /**
+   * Teleports the menu panel to a container element on open. Accepts an element reference, or
+   * `true` to append to `document.body`.
+   */
+  container?: boolean | Element;
+  /**
+   * Distance between the menu and its reference element, as `[skidding, distance]` in pixels.
+   */
+  offset?: [number, number];
+  /**
+   * Callback fired when the menu requests to be hidden.
+   */
+  onHide?: () => void;
+  /**
+   * Callback fired after the menu finishes hiding.
+   */
+  onHidden?: () => void;
+  /**
+   * Callback fired when the menu requests to be shown.
+   */
+  onShow?: () => void;
+  /**
+   * Callback fired after the menu finishes showing.
+   */
+  onShown?: () => void;
+  /**
+   * Initial placement. Chassis will flip it to keep the menu in view.
+   *
+   * @type 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end'
+   */
+  placement?: Placement;
+  /**
+   * Reference element used for positioning. `'toggle'` uses the trigger. `'parent'` uses this
+   * component's own rendered element, useful for split buttons and button groups.
+   */
+  reference?: 'toggle' | 'parent';
+  /**
+   * Toggle the visibility of the menu component.
+   */
+  visible?: boolean;
+};
+type MenuProps<C extends ElementType = typeof Fragment> = PolymorphicComponentProps<C, MenuOwnProps<C>>;
+type MenuComponent = (<C extends ElementType = typeof Fragment>(props: MenuProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const Menu: MenuComponent;
+//#endregion
+//#region src/components/menu/MenuDivider.d.ts
+interface MenuDividerProps extends HTMLAttributes<HTMLHRElement> {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+}
+declare const MenuDivider: React.ForwardRefExoticComponent<MenuDividerProps & React.RefAttributes<HTMLHRElement>>;
+//#endregion
+//#region src/components/menu/MenuHeader.d.ts
+type MenuHeaderOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+  /**
+   * ARIA role applied to the root node. Defaults to `'presentation'` — see the render function
+   * for why.
+   */
+  role?: React.AriaRole;
+};
+type MenuHeaderProps<C extends ElementType = 'h4'> = PolymorphicComponentProps<C, MenuHeaderOwnProps<C>>;
+type MenuHeaderComponent = (<C extends ElementType = 'h4'>(props: MenuHeaderProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const MenuHeader: MenuHeaderComponent;
+//#endregion
+//#region src/components/menu/MenuItem.d.ts
+type MenuItemOwnProps = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Secondary line of text rendered below `children` (`.menu-item-description`).
+   */
+  description?: ReactNode;
+  /**
+   * Icon rendered at the item's leading edge (`.menu-item-icon`).
+   */
+  icon?: ReactNode;
+  /**
+   * Marks the item as the current selection in a choice list. Renders in a heavier font weight.
+   * Combine with a manually-composed `.menu-item-check` icon (in `children`, or via `icon` on a
+   * plain, non-selection item) to also show a checkmark — this prop alone doesn't add one, so
+   * existing font-weight-only usage keeps rendering unchanged.
+   */
+  selected?: boolean;
+};
+type MenuItemProps<C extends ElementType = 'a'> = LinkProps<C> & MenuItemOwnProps;
+type MenuItemComponent = (<C extends ElementType = 'a'>(props: MenuItemProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const MenuItem: MenuItemComponent;
+//#endregion
+//#region src/components/menu/MenuList.d.ts
+type MenuListOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+  /**
+   * Array of item/header/divider definitions for data-driven rendering. When provided, children
+   * are ignored. Covers flat items, headers, and dividers only — for nested submenus, compose
+   * with `children` and `MenuSubmenu` instead.
+   */
+  items?: MenuItemsDef;
+};
+type MenuListProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, MenuListOwnProps<C>>;
+type MenuListComponent = (<C extends ElementType = 'div'>(props: MenuListProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const MenuList: MenuListComponent;
+//#endregion
+//#region src/components/menu/MenuText.d.ts
+type MenuTextOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+};
+type MenuTextProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, MenuTextOwnProps<C>>;
+type MenuTextComponent = (<C extends ElementType = 'span'>(props: MenuTextProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const MenuText: MenuTextComponent;
+//#endregion
+//#region src/components/menu/MenuToggle.d.ts
+type MenuToggleOwnProps<C extends ElementType> = {
+  /**
+   * Toggle the active state for the component.
+   */
+  active?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Sets the color of the component to one of Chassis context colors. Only applies to the
+   * default `Button` root.
+   */
+  color?: ContextColor;
+  /**
+   * Component used for the root node — the trigger element the menu opens from. Defaults to
+   * `Button`; swap for e.g. `NavLink` to render a nav-item-style trigger (`.nav-link.caret`)
+   * instead of a `.button.caret`. Its own props are type-checked at the call site once passed
+   * here.
+   */
+  component?: C;
+  /**
+   * Toggle the disabled state for the component.
+   */
+  disabled?: boolean;
+  /**
+   * The href attribute specifies the URL of the page the link goes to.
+   */
+  href?: string;
+  /**
+   * Select the shape of the component. Only applies to the default `Button` root.
+   */
+  shape?: Shapes;
+  /**
+   * Size the component sm or lg. Only applies to the default `Button` root.
+   */
+  size?: 'sm' | 'lg';
+  /**
+   * Sets the context style of the component. Only applies to the default `Button` root.
+   */
+  variant?: ContextStyle;
+};
+type MenuToggleProps<C extends ElementType = typeof Button> = PolymorphicComponentProps<C, MenuToggleOwnProps<C>>;
+type MenuToggleComponent = (<C extends ElementType = typeof Button>(props: MenuToggleProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const MenuToggle: MenuToggleComponent;
+//#endregion
+//#region src/components/menu/MenuSubmenu.d.ts
+interface MenuSubmenuProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+  /**
+   * MenuSubmenu activation mode on hover-capable devices. `'click'` activates on click only.
+   * `'hover'` activates on hover only. `'both'` (the default) activates on both. Touch
+   * devices always use tap regardless of this setting.
+   */
+  activation?: 'click' | 'hover' | 'both';
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Prevents the submenu from opening.
+   */
+  disabled?: boolean;
+  /**
+   * Distance between the nested menu and the trigger, as `[skidding, distance]` in pixels.
+   */
+  offset?: [number, number];
+  /**
+   * Placement of the nested menu relative to the trigger. Defaults to cascading in the reading
+   * direction — `'right-start'` under LTR locales, `'left-start'` under RTL ones (see
+   * `useLocale`) — matching native OS/browser submenu behavior. An explicit value always wins
+   * over that locale-based default.
+   */
+  placement?: Placement;
+  /**
+   * Switches to a view-replacement pattern below the `sm` breakpoint. Pair with a
+   * `MenuSubmenuBack` as the first item of the nested menu.
+   */
+  stacked?: boolean;
+  /**
+   * Milliseconds before closing the submenu when the pointer leaves it.
+   */
+  submenuDelay?: number;
+  /**
+   * Content of the `.menu-item` trigger that opens the submenu.
+   */
+  trigger: ReactNode;
+}
+declare const MenuSubmenu: React.ForwardRefExoticComponent<MenuSubmenuProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/menu/MenuSubmenuBack.d.ts
+interface MenuSubmenuBackProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+}
+declare const MenuSubmenuBack: React.ForwardRefExoticComponent<MenuSubmenuBackProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+export { Menu as _, MenuToggle as a, MenuProps as b, MenuTextProps as c, MenuItem as d, MenuItemProps as f, MenuDividerProps as g, MenuDivider as h, MenuSubmenuProps as i, MenuList as l, MenuHeaderProps as m, MenuSubmenuBackProps as n, MenuToggleProps as o, MenuHeader as p, MenuSubmenu as r, MenuText as s, MenuSubmenuBack as t, MenuListProps as u, MenuAutoClose as v, MenuFocusStrategy as y };

package/dist/chunks/index-Dcc_W6Kv.d.ts

@@ -0,0 +1,146 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import React, { DetailsHTMLAttributes, ElementType, HTMLAttributes, ReactElement, ReactNode } from "react";
+//#region src/components/accordion/Accordion.d.ts
+interface AccordionItemDef {
+  /**
+   * Let this item stay open when another item opens, overriding the accordion's `alwaysOpen` setting.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * Body content, rendered inside a `AccordionBody`.
+   */
+  body: ReactNode;
+  /**
+   * A string of all className you want applied to this item.
+   */
+  className?: string;
+  /**
+   * Header content, rendered inside a `AccordionHeader`.
+   */
+  header: ReactNode;
+  /**
+   * React key for this item. Falls back to its index when omitted.
+   */
+  id?: number | string;
+  /**
+   * The group this item shares with other items so only one can be open at a time, overriding the
+   * accordion's shared `name`.
+   */
+  name?: string;
+  /**
+   * Callback fired when this item's open state changes. Chained after `Accordion`'s own handling
+   * of `expandedKeys`/`onExpandedChange`, so it fires regardless of whether those are used.
+   */
+  onToggle?: (event: React.SyntheticEvent<HTMLDetailsElement>) => void;
+  /**
+   * Start the item in the open state (uncontrolled). Ignored for items whose key is included in
+   * `expandedKeys`/`defaultExpandedKeys` on the parent `Accordion`.
+   */
+  open?: boolean;
+}
+interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * Make accordion items stay open when another item is opened.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * Move the caret icon to the end of the header.
+   */
+  caretEnd?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The keys of the initially expanded items (uncontrolled). Only applies to items rendered via
+   * the `items` prop — a composed `AccordionItem` already supports native controlled `open`/
+   * `onToggle` directly.
+   */
+  defaultExpandedKeys?: Array<number | string>;
+  /**
+   * The keys of the currently expanded items (controlled). Only applies to items rendered via the
+   * `items` prop — a composed `AccordionItem` already supports native controlled `open`/`onToggle`
+   * directly.
+   */
+  expandedKeys?: Array<number | string>;
+  /**
+   * Removes the default background-context, some borders, and some rounded corners to render accordions edge-to-edge with their parent container.
+   */
+  flush?: boolean;
+  /**
+   * Array of item definitions for data-driven rendering. When provided, children are ignored.
+   */
+  items?: AccordionItemDef[];
+  /**
+   * The shared group name used by items that don't set their own `name`. Defaults to an auto-generated id.
+   */
+  name?: string;
+  /**
+   * Callback fired with the updated set of expanded item keys, reflecting the native `<details>`
+   * elements' actual open state (including items the browser closed itself via a shared `name`
+   * group). Only fires for items rendered via the `items` prop.
+   */
+  onExpandedChange?: (keys: Array<number | string>) => void;
+  /**
+   * Size the component sm or lg.
+   */
+  size?: 'sm' | 'lg';
+}
+declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/accordion/AccordionBody.d.ts
+type AccordionBodyOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+};
+type AccordionBodyProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, AccordionBodyOwnProps<C>>;
+type AccordionBodyComponent = (<C extends ElementType = 'div'>(props: AccordionBodyProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AccordionBody: AccordionBodyComponent;
+//#endregion
+//#region src/components/accordion/AccordionHeader.d.ts
+interface AccordionHeaderProps extends HTMLAttributes<HTMLElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+}
+declare const AccordionHeader: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLElement>>;
+//#endregion
+//#region src/components/accordion/AccordionItem.d.ts
+interface AccordionItemProps extends DetailsHTMLAttributes<HTMLDetailsElement> {
+  /**
+   * Let this item stay open when another item opens, overriding the accordion's `alwaysOpen` setting.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The group this item shares with other items so only one can be open at a time, overriding the
+   * accordion's shared `name`.
+   */
+  name?: string;
+  /**
+   * Start the item in the open state.
+   */
+  open?: boolean;
+  /**
+   * @deprecated No longer used. The native details element manages its own state.
+   */
+  itemKey?: number | string;
+}
+declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDetailsElement>>;
+//#endregion
+export { AccordionBody as a, AccordionItemDef as c, AccordionHeaderProps as i, AccordionProps as l, AccordionItemProps as n, AccordionBodyProps as o, AccordionHeader as r, Accordion as s, AccordionItem as t };

package/dist/chunks/index-Dfg4Ftb8.d.ts

@@ -0,0 +1,68 @@
+import "./focus-ring-SR_LwaN7.js";
+import React, { ReactNode, TextareaHTMLAttributes } from "react";
+//#region src/components/textarea/Textarea.d.ts
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'defaultValue' | 'onChange' | 'value'> {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * The value of the textarea, uncontrolled.
+   */
+  defaultValue?: string;
+  /**
+   * Toggle the disabled state for the component.
+   */
+  disabled?: boolean;
+  /**
+   * A description for the field, rendered below the textarea.
+   */
+  help?: ReactNode;
+  /**
+   * Set component validation state to invalid.
+   */
+  invalid?: boolean;
+  /**
+   * An error message for the field, rendered below the textarea when `invalid` is set.
+   */
+  invalidFeedback?: ReactNode;
+  /**
+   * The field's caption, rendered as a `FormLabel` associated with this textarea.
+   */
+  label?: ReactNode;
+  /**
+   * Handler that is called when the value changes.
+   */
+  onChange?: (value: string) => void;
+  /**
+   * Render the component styled as plain text. Removes the default form field styling and preserve the correct margin and padding. Recommend to use only along side `readonly`.
+   */
+  plainText?: boolean;
+  /**
+   * Toggle the readonly state for the component.
+   */
+  readOnly?: boolean;
+  /**
+   * The number of visible text lines for the control.
+   */
+  rows?: number;
+  /**
+   * Size the component sm or lg.
+   */
+  size?: 'sm' | 'lg';
+  /**
+   * Set component validation state to valid.
+   */
+  valid?: boolean;
+  /**
+   * A success message for the field, rendered below the textarea when `valid` is set.
+   */
+  validFeedback?: ReactNode;
+  /**
+   * The value of the textarea, controlled.
+   */
+  value?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+//#endregion
+export { TextareaProps as n, Textarea as t };

package/dist/chunks/index-Dfy1YW5j.d.ts

@@ -0,0 +1,73 @@
+import { n as ContextColor, t as Breakpoint } from "./types-CS_40Txv.js";
+import React, { ReactNode, TableHTMLAttributes } from "react";
+//#region src/utils/tableClassName.d.ts
+interface TableStyleProps {
+  /**
+   * Set the vertical alignment of cell content.
+   */
+  align?: 'bottom' | 'middle' | 'top';
+  /**
+   * Add borders on all sides of the table and cells.
+   */
+  bordered?: boolean;
+  /**
+   * Remove borders on all sides of the table and cells.
+   */
+  borderless?: boolean;
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Sets the color of the component.
+   */
+  color?: ContextColor;
+  /**
+   * Enable a hover state on table rows.
+   */
+  hover?: boolean;
+  /**
+   * Make any table responsive across all viewports or pick a maximum breakpoint.
+   */
+  responsive?: boolean | Breakpoint;
+  /**
+   * Make table more compact by cutting all cell padding.
+   */
+  sm?: boolean;
+  /**
+   * Convert rows into stacked label/value blocks below a container width, for tables with too
+   * many columns to read comfortably even with horizontal scrolling. `true` always stacks; a
+   * breakpoint name stacks only below it. Implies `responsive` when `responsive` isn't set
+   * separately, since stacking needs the same `.table-responsive` container-query ancestor.
+   */
+  stacked?: boolean | Breakpoint;
+  /**
+   * Add zebra-striping to table rows.
+   */
+  striped?: boolean;
+}
+//#endregion
+//#region src/components/static-table/StaticTable.d.ts
+interface StaticTableProps extends TableStyleProps, Omit<TableHTMLAttributes<HTMLTableElement>, 'align' | 'color'> {
+  /**
+   * Content shown above the table, functioning as a heading for it.
+   */
+  caption?: ReactNode;
+  /**
+   * The table's own markup — plain `<thead>`/`<tbody>`/`<tfoot>`/`<tr>`/`<th>`/`<td>` elements,
+   * rendered as-is.
+   */
+  children?: ReactNode;
+  /**
+   * Convert rows into stacked label/value blocks below a container width, for tables with too
+   * many columns to read comfortably even with horizontal scrolling. `true` always stacks; a
+   * breakpoint name stacks only below it. Implies `responsive` when `responsive` isn't set
+   * separately. Unlike `Table`, which derives each cell's label from its column header, a static
+   * table has no collection to read labels from — give each `<td>` a `data-cell` attribute with
+   * the label to show before its value.
+   */
+  stacked?: TableStyleProps['stacked'];
+}
+declare const StaticTable: React.ForwardRefExoticComponent<StaticTableProps & React.RefAttributes<HTMLTableElement>>;
+//#endregion
+export { StaticTableProps as n, StaticTable as t };

package/dist/chunks/index-Dh5CaHTP.d.ts

@@ -0,0 +1,44 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { n as ContextColor, o as Sizing, r as ContextStyle } from "./types-CS_40Txv.js";
+import { ElementType, ReactElement } from "react";
+//#region src/components/badge/Badge.d.ts
+type BadgeOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Sets the color of the component to one of Chassis context colors.
+   */
+  color?: ContextColor;
+  /**
+   * Sets the context style of the component. `solid`/`basic` render the default look with no extra class.
+   */
+  variant?: ContextStyle;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+  /**
+   * Position badge in one of the corners of a link or button.
+   */
+  position?: 'top-start' | 'top-end' | 'bottom-end' | 'bottom-start';
+  /**
+   * Select the shape of the component.
+   */
+  circle?: boolean;
+  /**
+   * Sets the size of the component to one of Chassis component sizes.
+   */
+  size?: Sizing;
+};
+type BadgeProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, BadgeOwnProps<C>>;
+type BadgeComponent = (<C extends ElementType = 'span'>(props: BadgeProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const Badge: BadgeComponent;
+//#endregion
+export { BadgeProps as n, Badge as t };

package/dist/chunks/index-DtbUXxjz.d.ts

@@ -0,0 +1,53 @@
+import "./focus-ring-SR_LwaN7.js";
+import React, { HTMLAttributes } from "react";
+//#region src/components/breadcrumb/Breadcrumb.d.ts
+interface BreadcrumbItemDef {
+  /**
+   * Label for the breadcrumb item.
+   */
+  label: React.ReactNode;
+  /**
+   * URL for the breadcrumb link. The last item in the array is always rendered as active (no link needed).
+   */
+  href?: string;
+}
+interface BreadcrumbProps extends HTMLAttributes<HTMLOListElement> {
+  /**
+   * Accessible name of the wrapping `<nav>` landmark. Defaults to the English `'breadcrumb'`;
+   * override it to translate the landmark, or to tell two breadcrumb trails on the same page
+   * apart (landmarks of the same role need distinct names to be distinguishable in a screen
+   * reader's landmark list).
+   *
+   * @default 'breadcrumb'
+   */
+  'aria-label'?: string;
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Array of breadcrumb items for data-driven rendering. The last item is automatically marked active.
+   * When provided, children are ignored.
+   */
+  items?: BreadcrumbItemDef[];
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLOListElement>>;
+//#endregion
+//#region src/components/breadcrumb/BreadcrumbItem.d.ts
+interface BreadcrumbItemProps extends HTMLAttributes<HTMLLIElement> {
+  /**
+   * Toggle the active state for the component.
+   */
+  active?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The `href` attribute for the inner `<Link>` component.
+   */
+  href?: string;
+}
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<BreadcrumbItemProps & React.RefAttributes<HTMLLIElement>>;
+//#endregion
+export { BreadcrumbProps as a, BreadcrumbItemDef as i, BreadcrumbItemProps as n, Breadcrumb as r, BreadcrumbItem as t };