@chassis-ui/react 0.1.3 → 0.3.0

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

@@ -0,0 +1,208 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { n as ContextColor } from "./types-CS_40Txv.js";
+import { n as ButtonProps } from "./Button-Cptd4Yk7.js";
+import { n as IconProps } from "./Icon-CioraWLF.js";
+import React, { DialogHTMLAttributes, ElementType, ReactElement } from "react";
+//#region src/components/alert/Alert.d.ts
+interface AlertProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, 'onCancel' | 'onClose'> {
+  /**
+   * Whether a click on the backdrop closes the alert. By default it doesn't (`'static'`): the
+   * alert bounces, since an alert dialog waits for an explicit choice. Set `true` to let it close.
+   */
+  backdrop?: true | 'static';
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Adds a close button in the corner, for an alert that needs a way out besides its actions.
+   */
+  closeButton?: boolean;
+  /**
+   * The close button's accessible name. Defaults to `'Close'`; set it for non-English UIs.
+   */
+  closeLabel?: string;
+  /**
+   * Whether the alert is open when it first renders. Such an alert is uncontrolled: it closes
+   * itself on a close request. Use `visible` to open and close it from outside.
+   */
+  defaultVisible?: boolean;
+  /**
+   * Disable the open/close transition entirely.
+   */
+  instant?: boolean;
+  /**
+   * Whether the Escape key closes the alert. By default it doesn't: the alert bounces instead.
+   */
+  keyboard?: boolean;
+  /**
+   * Renders the alert open from its first paint, server HTML included, as a non-modal dialog: a
+   * static preview. It stays open until a close request. Use `visible` or `defaultVisible` to
+   * open it as a modal dialog.
+   */
+  open?: boolean;
+  /**
+   * Callback fired when the alert asks to be closed: `AlertCancel`, the close button, and, when
+   * allowed, Escape or a backdrop click.
+   */
+  onClose?: () => void;
+  /**
+   * Callback fired when a close attempt is blocked: a click on a static backdrop, or Escape
+   * while `keyboard` is off.
+   */
+  onClosePrevented?: () => void;
+  /**
+   * Callback fired after the exit transition completes and the alert is fully hidden.
+   */
+  onHidden?: () => void;
+  /**
+   * Callback fired when the alert starts to open.
+   */
+  onShow?: () => void;
+  /**
+   * Callback fired after the entry transition completes and the alert is fully visible.
+   */
+  onShown?: () => void;
+  /**
+   * Callback fired with `false` when the alert asks to be closed, at the same moments as
+   * `onClose`. It makes `visible` and `onVisibleChange` a pair that takes a state setter.
+   */
+  onVisibleChange?: (visible: boolean) => void;
+  /**
+   * Whether the alert is open. The alert is then controlled: a close request only fires `onClose`
+   * and `onVisibleChange`, and the alert closes when this becomes `false`.
+   */
+  visible?: boolean;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDialogElement>>;
+//#endregion
+//#region src/components/alert/AlertBody.d.ts
+type AlertBodyOwnProps<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 an HTML element or a component.
+   *
+   * @default 'div'
+   */
+  component?: C;
+};
+type AlertBodyProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, AlertBodyOwnProps<C>>;
+type AlertBodyComponent = (<C extends ElementType = 'div'>(props: AlertBodyProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AlertBody: AlertBodyComponent;
+//#endregion
+//#region src/components/alert/AlertCancel.d.ts
+type AlertCancelProps = Omit<ButtonProps<'button'>, 'asChild' | 'component' | 'href'>;
+declare const AlertCancel: React.ForwardRefExoticComponent<AlertCancelProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/alert/AlertCode.d.ts
+type AlertCodeOwnProps<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 an HTML element or a component.
+   *
+   * @default 'code'
+   */
+  component?: C;
+};
+type AlertCodeProps<C extends ElementType = 'code'> = PolymorphicComponentProps<C, AlertCodeOwnProps<C>>;
+type AlertCodeComponent = (<C extends ElementType = 'code'>(props: AlertCodeProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AlertCode: AlertCodeComponent;
+//#endregion
+//#region src/components/alert/AlertFooter.d.ts
+type AlertFooterOwnProps<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 an HTML element or a component.
+   *
+   * @default 'div'
+   */
+  component?: C;
+  /**
+   * Stacks the actions as full-width rows on small screens, instead of sharing one row.
+   */
+  stacked?: boolean;
+};
+type AlertFooterProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, AlertFooterOwnProps<C>>;
+type AlertFooterComponent = (<C extends ElementType = 'div'>(props: AlertFooterProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AlertFooter: AlertFooterComponent;
+//#endregion
+//#region src/components/alert/AlertIcon.d.ts
+type AlertIconProps = IconProps & {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Colors the icon with one of Chassis context colors, such as `danger` for a destructive
+   * confirmation.
+   */
+  color?: ContextColor;
+};
+declare const AlertIcon: React.ForwardRefExoticComponent<AlertIconProps & React.RefAttributes<HTMLSpanElement | SVGSVGElement>>;
+//#endregion
+//#region src/components/alert/AlertText.d.ts
+type AlertTextOwnProps<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 an HTML element or a component.
+   *
+   * @default 'p'
+   */
+  component?: C;
+};
+type AlertTextProps<C extends ElementType = 'p'> = PolymorphicComponentProps<C, AlertTextOwnProps<C>>;
+type AlertTextComponent = (<C extends ElementType = 'p'>(props: AlertTextProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AlertText: AlertTextComponent;
+//#endregion
+//#region src/components/alert/AlertTitle.d.ts
+type AlertTitleOwnProps<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 an HTML element or a component.
+   *
+   * @default 'h2'
+   */
+  component?: C;
+};
+type AlertTitleProps<C extends ElementType = 'h2'> = PolymorphicComponentProps<C, AlertTitleOwnProps<C>>;
+type AlertTitleComponent = (<C extends ElementType = 'h2'>(props: AlertTitleProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AlertTitle: AlertTitleComponent;
+//#endregion
+export { AlertIcon as a, AlertFooterProps as c, AlertCancel as d, AlertCancelProps as f, AlertProps as g, Alert as h, AlertTextProps as i, AlertCode as l, AlertBodyProps as m, AlertTitleProps as n, AlertIconProps as o, AlertBody as p, AlertText as r, AlertFooter as s, AlertTitle as t, AlertCodeProps as u };
+//# sourceMappingURL=index-DgHvXzVh.d.ts.map

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

@@ -0,0 +1,45 @@
+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 };
+//# sourceMappingURL=index-Dh5CaHTP.d.ts.map

package/dist/chunks/index-DjXRq-n3.d.ts

@@ -0,0 +1,98 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { n as ContextColor, t as Breakpoint } from "./types-CS_40Txv.js";
+import { r as WidthSpan } from "./breakpoints-CJ-498B7.js";
+import { ComponentPropsWithoutRef, ElementType, ReactElement, ReactNode } from "react";
+//#region src/components/skeleton/Skeleton.d.ts
+type SkeletonOwnProps<C extends ElementType> = {
+  /**
+   * Adds `skeleton-{animation}` alongside the base `skeleton` class, so the element animates
+   * itself as well as any nested `<Skeleton>` children. Nest plain `<Skeleton>` children inside
+   * it for the glow pulse to reach them too, or apply `wave` to a container of one or more
+   * `<Skeleton>` children for a directional sweep across the whole group.
+   */
+  animation?: 'glow' | 'wave';
+  /**
+   * 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;
+  /**
+   * Component used for the root node. Either a string to use an HTML element or a component —
+   * e.g. `Avatar` or `Button`. Its own props are type-checked at the call site once passed here.
+   *
+   * @default 'span'
+   */
+  component?: C;
+  /**
+   * Width of the skeleton in twelfths of its parent (`span={6}` is half, mapped to the
+   * `w-{n}/12` class; `span={12}` is `w-100`), `'auto'` for its natural width (`w-auto`), or
+   * `true` to fill the rest of a flex row (`flex-fill`). Unset by default, so the rendered
+   * element's own intrinsic width applies — set it explicitly (e.g. `span={12}`) for a
+   * full-width text line; leave it unset when `component` is something that sizes itself, like
+   * `Avatar` or `Button`.
+   *
+   * @type { 'auto' | number | string | boolean }
+   */
+  span?: WidthSpan;
+  /**
+   * Overrides `span` at a breakpoint and up.
+   *
+   * @type { Partial<Record<'sm' | 'md' | 'lg' | 'xl' | '2xl', 'auto' | number | string | boolean>> }
+   */
+  responsive?: Partial<Record<Breakpoint, WidthSpan>>;
+};
+type SkeletonProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, SkeletonOwnProps<C>>;
+type SkeletonComponent = (<C extends ElementType = 'span'>(props: SkeletonProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const Skeleton: SkeletonComponent;
+//#endregion
+//#region src/components/skeleton/SkeletonLoader.d.ts
+type SkeletonLoaderOwnProps<C extends ElementType> = {
+  /**
+   * The real content, rendered unchanged (no wrapping element) once `loading` is `false`.
+   */
+  children: ReactNode;
+  /**
+   * Sets the color of the generated skeleton lines to one of Chassis context colors.
+   */
+  color?: ContextColor;
+  /**
+   * Component used for the generated skeleton(s) — e.g. `Avatar` or `Button` — for swapping
+   * non-text content, not just text runs. Its own props are type-checked at the call site once
+   * passed here, same as `Skeleton`'s own `component` prop.
+   *
+   * @default 'span'
+   */
+  component?: C;
+  /**
+   * Swaps `children` for one `<Skeleton>` per entry in `spans` while `true`.
+   */
+  loading: boolean;
+  /**
+   * One skeleton line per entry, using the same values as `Skeleton`'s `span` prop — e.g.
+   * `[12, 6]` for a full-width line followed by a half-width one. A single value (e.g. `6`) is
+   * shorthand for a single line, equivalent to `[6]`. Leave unset for a single skeleton sized by
+   * `component`'s own intrinsic width instead — e.g. an `Avatar`'s `size` prop. Rendered instead
+   * of `children` while `loading` is `true`; ignored once `loading` is `false`.
+   *
+   * @type { 'auto' | number | string | boolean | Array<'auto' | number | string | boolean> }
+   */
+  spans?: WidthSpan | WidthSpan[];
+};
+type SkeletonLoaderProps<C extends ElementType = 'span'> = SkeletonLoaderOwnProps<C> & Omit<ComponentPropsWithoutRef<C>, keyof SkeletonLoaderOwnProps<C> | 'asChild'>;
+type SkeletonLoaderComponent = (<C extends ElementType = 'span'>(props: SkeletonLoaderProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const SkeletonLoader: SkeletonLoaderComponent;
+//#endregion
+export { SkeletonProps as i, SkeletonLoaderProps as n, Skeleton as r, SkeletonLoader as t };
+//# sourceMappingURL=index-DjXRq-n3.d.ts.map

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

@@ -0,0 +1,193 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { n as ContextColor } from "./types-CS_40Txv.js";
+import { n as IconProps } from "./Icon-CioraWLF.js";
+import React, { ElementType, HTMLAttributes, ReactElement, ReactNode } from "react";
+import { ToastQueue } from "react-stately";
+//#region src/components/notification/Notification.d.ts
+interface NotificationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+  /**
+   * Optional trailing content — e.g. a row of `Button`s — rendered after `text`/`children`.
+   */
+  actions?: ReactNode;
+  /**
+   * Automatically dismiss the notification after `delay`. The timer pauses while the pointer
+   * or focus is on the notification, and only starts once the notification is visible.
+   * Defaults to `false` — unlike `Toast`, notifications are persistent banners by default.
+   */
+  autohide?: boolean;
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Overrides the dismiss button's accessible name (defaults to `'Close'`). Set this for
+   * non-English UIs.
+   */
+  closeLabel?: string;
+  /**
+   * Sets the color of the component to one of Chassis context colors.
+   */
+  color?: ContextColor;
+  /**
+   * Whether the notification is shown when it first renders. Such a notification is
+   * uncontrolled: its close button and the `autohide` timer hide it. Use `visible` to show and
+   * hide it from outside.
+   *
+   * @default true
+   */
+  defaultVisible?: boolean;
+  /**
+   * Delay in ms before an `autohide` notification dismisses itself.
+   */
+  delay?: number;
+  /**
+   * Optionally add a close button to the notification and allow it to self dismiss.
+   */
+  dismissible?: boolean;
+  /**
+   * Leading icon. A string is an icon name, rendered like `<NotificationIcon name={icon} />` (or
+   * by `IconProvider`'s `component`); pass any other
+   * node for a fully custom icon. Automatically top-aligns with `title` when both are set —
+   * a custom icon node is responsible for its own alignment.
+   */
+  icon?: string | ReactNode;
+  /**
+   * Applies the solid context style to the notification.
+   */
+  solid?: boolean;
+  /**
+   * Message body, rendered via a single `<NotificationText>`. For multi-block content, compose
+   * `children` manually instead — `text` wraps everything in one element.
+   */
+  text?: ReactNode;
+  /**
+   * Heading, rendered via `<NotificationTitle>`.
+   */
+  title?: ReactNode;
+  /**
+   * Element or component used for the `title` heading. Passed through to `NotificationTitle`'s
+   * own `component` prop. Defaults to `'h4'`.
+   */
+  titleComponent?: ElementType;
+  /**
+   * Callback fired once the notification has hidden: after its exit transition.
+   */
+  onClose?: () => void;
+  /**
+   * Callback fired when the notification starts to show.
+   */
+  onShow?: () => void;
+  /**
+   * Callback fired with `false` when the notification asks to hide: its close button, `close`
+   * from `useNotification`, or the `autohide` timer. With `visible` set, the notification hides
+   * only when `visible` becomes `false`.
+   */
+  onVisibleChange?: (visible: boolean) => void;
+  /**
+   * ARIA live-region role. Use `status` (the default) for confirmation, progress, and
+   * informational messages, which announce politely. Use `alert` for messages that need
+   * immediate attention — validation errors, failed operations — which interrupt speech.
+   */
+  role?: 'status' | 'alert';
+  /**
+   * Whether the notification is shown. Setting it makes the notification controlled: it hides
+   * only when this becomes `false`, so pair it with `onVisibleChange`. Left unset, the
+   * notification is shown and hides itself (see `defaultVisible`).
+   */
+  visible?: boolean;
+}
+declare const Notification: React.ForwardRefExoticComponent<NotificationProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/notification/NotificationTitle.d.ts
+type NotificationTitleOwnProps<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 NotificationTitleProps<C extends ElementType = 'h4'> = PolymorphicComponentProps<C, NotificationTitleOwnProps<C>>;
+type NotificationTitleComponent = (<C extends ElementType = 'h4'>(props: NotificationTitleProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const NotificationTitle: NotificationTitleComponent;
+//#endregion
+//#region src/components/notification/NotificationIcon.d.ts
+type NotificationIconProps = IconProps & {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+};
+declare const NotificationIcon: React.ForwardRefExoticComponent<NotificationIconProps & React.RefAttributes<HTMLSpanElement | SVGSVGElement>>;
+//#endregion
+//#region src/components/notification/NotificationText.d.ts
+type NotificationTextOwnProps<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 NotificationTextProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, NotificationTextOwnProps<C>>;
+type NotificationTextComponent = (<C extends ElementType = 'div'>(props: NotificationTextProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const NotificationText: NotificationTextComponent;
+//#endregion
+//#region src/components/notification/NotificationStack.d.ts
+interface NotificationStackProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Queued notifications show newest-first by default — the typical toast pattern. Set
+   * `reverse` for a chronological transcript instead, oldest-first.
+   */
+  reverse?: boolean;
+}
+declare const NotificationStack: React.ForwardRefExoticComponent<NotificationStackProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/notification/notificationQueue.d.ts
+interface NotificationContent extends Pick<NotificationProps, 'actions' | 'autohide' | 'closeLabel' | 'color' | 'delay' | 'dismissible' | 'icon' | 'role' | 'solid' | 'text' | 'title' | 'titleComponent'> {
+  /**
+   * Content of the notification. Compose manually (typically a `NotificationIcon`/
+   * `NotificationTitle`/`NotificationText`), or leave empty and use the `icon`/`title`/`text`
+   * shorthand options instead.
+   */
+  children?: ReactNode;
+}
+declare const notificationQueue: ToastQueue<NotificationContent>;
+declare function addNotification(children?: ReactNode, options?: Omit<NotificationContent, 'children'>): string;
+declare function closeNotification(key: string): void;
+//#endregion
+//#region src/components/notification/context.d.ts
+interface NotificationContextProps {
+  /**
+   * Whether the notification is currently visible.
+   */
+  visible?: boolean;
+  /**
+   * Dismisses the notification. Wire this to any element's `onClick` — see `useNotification`.
+   */
+  close: () => void;
+}
+//#endregion
+//#region src/hooks/useNotification.d.ts
+type UseNotificationResult = NotificationContextProps;
+declare const useNotification: () => UseNotificationResult;
+//#endregion
+export { closeNotification as a, NotificationStackProps as c, NotificationIcon as d, NotificationIconProps as f, NotificationProps as g, Notification as h, addNotification as i, NotificationText as l, NotificationTitleProps as m, useNotification as n, notificationQueue as o, NotificationTitle as p, NotificationContent as r, NotificationStack as s, UseNotificationResult as t, NotificationTextProps as u };
+//# sourceMappingURL=index-DjrEvKd-.d.ts.map

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

@@ -0,0 +1,54 @@
+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 };
+//# sourceMappingURL=index-DtbUXxjz.d.ts.map

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

@@ -0,0 +1,56 @@
+import "./focus-ring-SR_LwaN7.js";
+import { t as Placement } from "./overlayPlacement-CIsLpycT.js";
+import React, { HTMLAttributes, ReactElement, ReactNode } from "react";
+//#region src/components/popover/Popover.d.ts
+interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'content' | 'title'> {
+  /**
+   * The trigger: a single element, which opens the popover on click.
+   */
+  children: ReactElement;
+  /**
+   * Content node for your component.
+   */
+  content: ReactNode | string;
+  /**
+   * Whether the popover is open when it first renders. Use it instead of `visible` when nothing
+   * outside needs to control the popover.
+   */
+  defaultVisible?: boolean;
+  /**
+   * Offset of the popover relative to its target, as `[crossAxis, mainAxis]`.
+   */
+  offset?: [number, number];
+  /**
+   * Callback fired when the popover hides.
+   */
+  onHide?: () => void;
+  /**
+   * Callback fired when the popover shows.
+   */
+  onShow?: () => void;
+  /**
+   * Callback fired when the popover asks to show or hide: a click on the trigger, a click
+   * outside, the Escape key, or the closing of the dialog it is in. Receives the state it asks
+   * for. With `visible` set, the popover changes only when `visible` does.
+   */
+  onVisibleChange?: (visible: boolean) => void;
+  /**
+   * Title node for your component.
+   */
+  title?: ReactNode | string;
+  /**
+   * Describes the preferred placement of your component. Chassis will flip it to keep it in
+   * view.
+   */
+  placement?: Placement;
+  /**
+   * Whether the popover is open. Setting it makes the popover controlled: it shows and hides
+   * only when this changes, so pair it with `onVisibleChange`. Leave it unset, or use
+   * `defaultVisible`, for a popover that opens and closes itself.
+   */
+  visible?: boolean;
+}
+declare const Popover: React.ForwardRefExoticComponent<PopoverProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+export { PopoverProps as n, Popover as t };
+//# sourceMappingURL=index-Du9fBqkT.d.ts.map