haze-ui 1.26.0 → 1.28.0

package/dist/types/components/Chart/chart-elements.d.ts

@@ -0,0 +1,104 @@
+import type { ReactElement, ReactNode } from 'react';
+/** One plotted series: `key` picks the datum field to plot, `label` names
+ * the series in the legend and tooltip (defaults to `key`), and `color`
+ * opts out of the semantic token cycle. */
+export type ChartSeries = {
+    key: string;
+    label?: string;
+    color?: string;
+};
+/** A series after Chart's label default is applied — what reaches
+ * recharts. `color` is only present when the consumer set it; the plot
+ * elements apply the semantic cycle themselves (cartesian: per series
+ * index, pie: per datum index). */
+export type ResolvedChartSeries = {
+    key: string;
+    label: string;
+    color?: string;
+};
+/** Cartesian chart shapes; each maps onto a recharts chart container and
+ * its matching series element (see `chartElement` / `seriesElement`). */
+export type CartesianChartType = 'line' | 'area' | 'bar';
+/** Supported chart shapes — the cartesian families plus `pie`, where each
+ * datum is one sector named by the chart's `xKey`. */
+export type ChartType = CartesianChartType | 'pie';
+/** One hovered entry as handed to Chart's `renderTooltip` slot. */
+export type ChartTooltipEntry<T = unknown> = {
+    /** Series label (cartesian) or sector name (pie). */
+    name: string;
+    /** The plotted value. */
+    value: number | string;
+    /** The series/sector color as passed to recharts (any CSS color). */
+    color: string;
+    /** The source datum the entry was plotted from. */
+    dataEntry: T;
+};
+/** Payload handed to Chart's `renderTooltip` slot. */
+export type ChartTooltipPayload<T = unknown> = {
+    /** The hovered X value (cartesian) or sector name (pie). */
+    label?: unknown;
+    /** One entry per series (cartesian) or per sector (pie). */
+    entries: ChartTooltipEntry<T>[];
+};
+export declare const AXIS_STROKE = "var(--haze-color-border)";
+export declare const AXIS_TICK: {
+    readonly fontSize: "var(--haze-text-sm)";
+    readonly fill: "var(--haze-color-text-secondary)";
+};
+export declare const TOOLTIP_STYLE: {
+    readonly fontSize: "var(--haze-text-sm)";
+    readonly color: "var(--haze-color-text)";
+};
+export declare const LEGEND_STYLE: {
+    readonly fontSize: "var(--haze-text-sm)";
+};
+/** Applies the per-series default: `label` falls back to `key`. An
+ * explicit `color` passes through untouched — the plot elements cycle
+ * `SERIES_COLOR_CYCLE` when it is omitted. */
+export declare function resolveChartSeries(series: readonly ChartSeries[]): ResolvedChartSeries[];
+/** The recharts series element for one resolved entry. Line and Area carry
+ * the token color as `stroke` (Area also fills with it — recharts applies
+ * its default 0.6 fill opacity), Bar carries it as `fill`. */
+export declare function seriesElement(type: CartesianChartType, entry: ResolvedChartSeries, index?: number): ReactElement;
+/** Radial band for pie ring `index` of `ringCount`: a single ring spans
+ * [innerRadius, 80%]; multiple rings band the radial space evenly with
+ * series 0 innermost. A percentage `innerRadius` offsets the innermost
+ * ring — a pixel value only applies to single-ring charts. */
+export declare function pieRingRadii(index: number, ringCount: number, innerRadius: number | string): {
+    innerRadius: number | string;
+    outerRadius: string;
+};
+/** The recharts Pie for one resolved series: every datum is one sector
+ * named by `nameKey` and valued by the series `key`. Sector fills cycle
+ * the semantic tokens per datum unless the series pins an explicit
+ * `color`, which monochromes the whole ring. */
+export declare function pieElement(options: {
+    entry: ResolvedChartSeries;
+    data: readonly unknown[];
+    nameKey: string;
+    ringIndex: number;
+    ringCount: number;
+    innerRadius: number | string;
+}): ReactElement;
+/** The recharts chart container for `type` (line → LineChart, area →
+ * AreaChart, bar → BarChart, pie → PieChart) plotting `data` with the
+ * given series children; cartesian containers carry `layout`. */
+export declare function chartElement(type: ChartType, data: readonly unknown[], children: ReactNode, layout?: 'horizontal' | 'vertical'): ReactElement;
+/** Wraps a `renderTooltip` slot into a recharts Tooltip `content`
+ * function, mapping recharts' payload items onto ChartTooltipEntry
+ * (name falling back to the dataKey, missing colors to ''). */
+export declare function buildTooltipContent(render: (payload: ChartTooltipPayload) => ReactNode): (props: unknown) => ReactNode;
+/** The full token-styled chart tree Chart renders — kept beside the pure
+ * helpers so the component module stays a single component export. */
+export declare function chartTree(options: {
+    type: ChartType;
+    data: readonly unknown[];
+    xKey: string;
+    showGrid: boolean;
+    showTooltip: boolean;
+    showLegend: boolean;
+    series: readonly ResolvedChartSeries[];
+    layout?: 'horizontal' | 'vertical';
+    innerRadius?: number | string;
+    renderTooltip?: (payload: ChartTooltipPayload) => ReactNode;
+}): ReactElement;

package/dist/types/components/Chart/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Chart } from './Chart';
+export type { ChartProps, ChartSeries, ChartTooltipEntry, ChartTooltipPayload, ChartType, } from './Chart';

package/dist/types/components/ChatContainer/ChatContainer.d.ts

@@ -1,8 +1,23 @@
-import type { ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 type ChatContainerProps = {
     children: ReactNode;
+    /**
+     * Follow content changes (defaults to `true`): while the reader is
+     * parked at the bottom — within ~40px — new content keeps the view
+     * glued to the newest message. Scrolling up pauses the follow (the
+     * reading position stays put), and content arriving while paused
+     * surfaces the jump pill; clicking it returns to the bottom.
+     * `false` disables all scroll management (e.g. when an inner
+     * VirtualList owns the scrollport).
+     */
     autoScroll?: boolean;
+    /**
+     * Label of the jump pill shown when new content arrives while the
+     * reader is scrolled up. Defaults to the `chat.newMessages` string
+     * (`"New messages"` in the English pack).
+     */
+    unreadLabel?: ReactNode;
     className?: string;
-};
-export default function ChatContainer({ children, autoScroll, className, }: ChatContainerProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function ChatContainer({ children, autoScroll, unreadLabel, className, ...rest }: ChatContainerProps): import("react").JSX.Element;
 export type { ChatContainerProps };

package/dist/types/components/ChatInput/ChatInput.d.ts

@@ -2,10 +2,20 @@ import type { ControlOrValue } from 'react-use-control';
 type ChatInputProps = {
     value?: ControlOrValue<string>;
     onSend?: (message: string) => void;
+    /**
+     * While `true` the send button becomes a stop control: it shows the
+     * stop glyph with the `chat.stopGeneration` label, stays enabled
+     * regardless of the draft, and activating it — by click or by Enter —
+     * calls `onStop` instead of `onSend` (Enter never sends mid-generation;
+     * Shift+Enter still inserts a newline).
+     */
+    generating?: boolean;
+    /** Called when the user requests the running generation to stop. */
+    onStop?: () => void;
     placeholder?: string;
     disabled?: boolean;
     maxLength?: number;
     className?: string;
 };
-export default function ChatInput({ value: valueControl, onSend, placeholder, disabled, maxLength, className, }: ChatInputProps): import("react").JSX.Element;
+export default function ChatInput({ value: valueControl, onSend, generating, onStop, placeholder, disabled, maxLength, className, }: ChatInputProps): import("react").JSX.Element;
 export type { ChatInputProps };

package/dist/types/components/ChatMessage/ChatMessage.d.ts

@@ -6,8 +6,20 @@ type ChatMessageProps = {
     name?: ReactNode;
     timestamp?: ReactNode;
     status?: 'sending' | 'sent' | 'error';
+    /**
+     * Opt in to the built-in copy action: a button in the hover/focus
+     * reveal bar that copies the message's text content (the bubble's
+     * rendered text) and flips to a success glyph for 1.5s.
+     */
+    copyable?: boolean;
+    /**
+     * Custom action nodes (retry, edit, branch…) rendered beside the
+     * built-in copy button. Providing `actions` alone opts the message
+     * into the reveal bar without the copy button.
+     */
+    actions?: ReactNode;
     children: ReactNode;
     className?: string;
 };
-export default function ChatMessage({ role, avatar, name, timestamp, status, children, className, }: ChatMessageProps): import("react").JSX.Element;
+export default function ChatMessage({ role, avatar, name, timestamp, status, copyable, actions, children, className, }: ChatMessageProps): import("react").JSX.Element;
 export type { ChatMessageProps, ChatMessageRole };

package/dist/types/components/Checkbox/Checkbox.d.ts

@@ -1,8 +1,12 @@
-import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type CheckboxProps = {
     checked?: ControlOrValue<boolean>;
     label?: ReactNode;
+    /** Forwarded to the underlying checkbox `<input>` (or through the
+     * label wrapper to it) — form bridges and `ref.current.focus()`
+     * reach. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'checked' | 'type'>;
-export default function Checkbox({ checked: checkedControl, className, label, onChange, ...rest }: CheckboxProps): import("react").JSX.Element;
+export default function Checkbox({ checked: checkedControl, className, label, onChange, ref, ...rest }: CheckboxProps): import("react").JSX.Element;
 export type { CheckboxProps };

package/dist/types/components/Checkbox/CheckboxCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, Ref, ReactNode } from 'react';
 type CheckboxCoreProps = {
     checked: boolean;
     onChange: (checked: boolean) => void;
@@ -7,6 +7,8 @@ type CheckboxCoreProps = {
     onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
     label?: ReactNode;
     className?: string;
+    /** Forwarded to the checkbox `<input>` element. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'checked' | 'onChange' | 'type'>;
-export default function CheckboxCore({ checked, onChange, onNativeChange, className, label, ...rest }: CheckboxCoreProps): import("react").JSX.Element;
+export default function CheckboxCore({ checked, onChange, onNativeChange, className, label, ref, ...rest }: CheckboxCoreProps): import("react").JSX.Element;
 export type { CheckboxCoreProps };

package/dist/types/components/CodeBlock/CodeBlock.d.ts

@@ -1,8 +1,25 @@
 import type { ReactNode } from 'react';
+/**
+ * Pluggable syntax highlighting. Receives the raw code and language,
+ * returns an HTML fragment (`<span>`-wrapped tokens) — synchronously or as a
+ * Promise. The library ships no built-in highlighter: consumers wire up
+ * shiki, Prism, highlight.js, etc. themselves.
+ *
+ * The returned HTML is injected via `dangerouslySetInnerHTML` as-is —
+ * sanitize it or only pass trusted sources.
+ */
+type Highlighter = (code: string, language: string) => string | Promise<string>;
 type CodeBlockProps = {
     children: ReactNode;
     language?: string;
+    /**
+     * Optional highlighter for string children. Sync results render in the
+     * same commit; async results render plain text first, then swap in once
+     * the Promise settles (a rejected Promise falls back to plain text).
+     * Non-string children are rendered unhighlighted.
+     */
+    highlight?: Highlighter;
     className?: string;
 };
-export default function CodeBlock({ children, language, className }: CodeBlockProps): import("react").JSX.Element;
-export type { CodeBlockProps };
+export default function CodeBlock({ children, language, highlight, className }: CodeBlockProps): import("react").JSX.Element;
+export type { CodeBlockProps, Highlighter };

package/dist/types/components/CodeBlock/index.d.ts

@@ -1,2 +1,2 @@
 export { default as CodeBlock } from './CodeBlock';
-export type { CodeBlockProps } from './CodeBlock';
+export type { CodeBlockProps, Highlighter } from './CodeBlock';

package/dist/types/components/Collapsible/Collapsible.d.ts

@@ -1,12 +1,34 @@
 import type { ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape): keys map to the
+ * compound structure, consumer classes appended at the end of each
+ * part's class list (able to override component defaults). The record
+ * is declared once on the `<Collapsible>` root and reaches every
+ * sub-component through context; per-part `className` props stay
+ * available for one-off tweaks and still land after the slot class.
+ */
+type CollapsibleClassNames = {
+    /** The wrapper `<div>` `<Collapsible>` renders. */
+    root?: string;
+    /** The `<CollapsibleTrigger>` `<button>`. */
+    trigger?: string;
+    /** The `<CollapsibleContent>` outer `<div>` (the animated grid row). */
+    content?: string;
+};
 type CollapsibleProps = {
     open?: ControlOrValue<boolean>;
     defaultOpen?: boolean;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): declared once
+     * here and distributed to every sub-component via context — see
+     * {@link CollapsibleClassNames}. Omitting it changes nothing.
+     */
+    classNames?: CollapsibleClassNames;
     children: ReactNode;
     className?: string;
 };
-export declare function Collapsible({ open: openControl, defaultOpen, children, className, }: CollapsibleProps): import("react").JSX.Element;
+export declare function Collapsible({ open: openControl, defaultOpen, classNames, children, className, }: CollapsibleProps): import("react").JSX.Element;
 type CollapsibleTriggerProps = {
     children: ReactNode;
     className?: string;
@@ -17,4 +39,4 @@ type CollapsibleContentProps = {
     className?: string;
 };
 export declare function CollapsibleContent({ children, className }: CollapsibleContentProps): import("react").JSX.Element;
-export type { CollapsibleProps, CollapsibleTriggerProps, CollapsibleContentProps };
+export type { CollapsibleProps, CollapsibleTriggerProps, CollapsibleContentProps, CollapsibleClassNames };

package/dist/types/components/Collapsible/index.d.ts

@@ -1,2 +1,2 @@
 export { Collapsible, CollapsibleTrigger, CollapsibleContent } from './Collapsible';
-export type { CollapsibleProps, CollapsibleTriggerProps, CollapsibleContentProps } from './Collapsible';
+export type { CollapsibleProps, CollapsibleTriggerProps, CollapsibleContentProps, CollapsibleClassNames } from './Collapsible';

package/dist/types/components/ColorPicker/ColorPicker.d.ts

@@ -1,9 +1,15 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type ColorPickerProps = {
     value?: ControlOrValue<string>;
     presets?: string[];
     onChange?: (color: string) => void;
     className?: string;
+    /**
+     * Forwarded to the color swatch `<input type='color'>` (not the root
+     * div) — the element form bridges and `ref.current.focus()` reach.
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function ColorPicker({ value: valueControl, presets, onChange, className, }: ColorPickerProps): import("react").JSX.Element;
+export default function ColorPicker({ value: valueControl, presets, onChange, className, ref, }: ColorPickerProps): import("react").JSX.Element;
 export type { ColorPickerProps };

package/dist/types/components/ColorPicker/ColorPickerCore.d.ts

@@ -1,8 +1,14 @@
+import type { Ref } from 'react';
 type ColorPickerCoreProps = {
     value: string;
     onChange: (value: string) => void;
     presets?: string[];
     className?: string;
+    /**
+     * Forwarded to the color swatch `<input type='color'>` (not the root
+     * div).
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function ColorPickerCore({ value, onChange, presets, className, }: ColorPickerCoreProps): import("react").JSX.Element;
+export default function ColorPickerCore({ value, onChange, presets, className, ref, }: ColorPickerCoreProps): import("react").JSX.Element;
 export type { ColorPickerCoreProps };

package/dist/types/components/Combobox/Combobox.d.ts

@@ -1,11 +1,99 @@
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+/** Metrics override for the `virtualized` option list of Combobox. */
+type ComboboxVirtualizedConfig = {
+    /**
+     * Row height in px of one option row. Defaults to 37 —
+     * ComboboxOption's natural box: space-2 padding top+bottom + text-sm
+     * at leading-normal = 8 + 21 + 8. Virtualization math needs it as a
+     * JS number; rows are stretched to fill it (`virtualRow`), so the two
+     * cannot drift apart.
+     */
+    itemHeight?: number;
+    /** Extra rows kept mounted above/below the visible window. Defaults
+     * to VirtualList's 5. */
+    overscan?: number;
+};
+/** One entry of the `options` prop. */
+type ComboboxOptionData = {
+    value: string;
+    label: string;
+    /**
+     * Optional group heading: consecutive options carrying the same
+     * `group` cluster into one `ComboboxGroup` section (sticky heading,
+     * `role="group"` — the cmdk shape); options without a `group` stay
+     * direct listbox children. A group whose every option was filtered
+     * out hides entirely.
+     */
+    group?: string;
+};
 type ComboboxProps = {
-    value?: ControlOrValue<string>;
+    /**
+     * `string` in single mode, `string[]` when `multiple` is set. The
+     * uncontrolled empty value is `''` in single mode, `[]` in multiple
+     * mode.
+     */
+    value?: ControlOrValue<string | string[]>;
     open?: ControlOrValue<boolean>;
-    options: {
-        value: string;
-        label: string;
-    }[];
+    options: ComboboxOptionData[];
+    /**
+     * Multiple-selection mode: selected values render as chips inside
+     * the trigger, Enter toggles the highlighted option without closing
+     * the panel, and Backspace on an empty query drops the most recently
+     * selected chip.
+     */
+    multiple?: boolean;
+    /**
+     * Value callback for both modes — `string` in single mode,
+     * `string[]` when `multiple` is set — fired after the value updates.
+     */
+    onValuesChange?: (value: string | string[]) => void;
+    /**
+     * Offer the current query as a creatable option: when nothing
+     * matches a non-blank query, a localized `Create "…"` row renders at
+     * the top of the list. Committing it calls `onCreate` and appends the
+     * new value to a local option set layered on top of `options` — the
+     * controlled `options` array is never mutated, and local creations
+     * are dropped when the component unmounts (re-pass `options` to own
+     * them permanently).
+     */
+    creatable?: boolean;
+    /** Fired with the created query when the creatable row is committed. */
+    onCreate?: (query: string) => void;
+    /**
+     * Remote search: while set, local query filtering is suspended — the
+     * list renders exactly the `options` the consumer passes — and every
+     * query transition fires this callback instead: each keystroke,
+     * clearing the input, and the resets that follow a selection (the
+     * empty query restores the full list). The consumer owns the options
+     * end to end; pair with `loading` for the pending state. Debouncing
+     * is the consumer's concern.
+     */
+    onSearch?: (query: string) => void;
+    /**
+     * Async-search pending state: the combobox input carries
+     * `aria-busy` and the panel shows a spinner row instead of the
+     * (stale) option list.
+     */
+    loading?: boolean;
+    /**
+     * Wrap the case-insensitive query match inside each option label in
+     * a token-styled `<mark>` (first occurrence; the label stays one
+     * text node otherwise). Off by default so the un-enabled rendering
+     * stays byte-identical; works through the virtualized path too.
+     */
+    highlightMatches?: boolean;
+    /**
+     * Custom no-results content for the empty filtered list. Defaults to
+     * the `combobox.noResults` locale string.
+     */
+    empty?: ReactNode;
+    /**
+     * Panel max height in px: caps the plain listbox's scroll box and
+     * the virtualized scrollport alike. Defaults to 200 (the historical
+     * cap); omitted leaves the DOM untouched.
+     */
+    maxHeight?: number;
     placeholder?: string;
     /**
      * Render the dropdown through VirtualList once the filtered list is
@@ -13,7 +101,23 @@ type ComboboxProps = {
      * virtualization entirely (plain DOM rendering at any length).
      */
     virtualThreshold?: number;
+    /**
+     * Explicit VirtualList override, bypassing `virtualThreshold`: `true`
+     * (or an object) always renders the list virtually — at any length,
+     * including below the threshold — while an object additionally
+     * customizes row metrics; `false` never virtualizes, even past the
+     * threshold. Omitted (default) keeps the threshold behavior
+     * untouched.
+     */
+    virtualized?: boolean | ComboboxVirtualizedConfig;
     className?: string;
+    /**
+     * Forwarded to the combobox `<input>` — the focusable field in both
+     * single and multiple mode (multiple mode's chip box wraps it but is
+     * not itself the combobox) — so form bridges and
+     * `ref.current.focus()` reach.
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function Combobox({ value: valueControl, open: openControl, options, placeholder, virtualThreshold, className, }: ComboboxProps): import("react").JSX.Element;
-export type { ComboboxProps };
+export default function Combobox({ value: valueControl, open: openControl, options, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, ref, }: ComboboxProps): import("react").JSX.Element;
+export type { ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData };

package/dist/types/components/Combobox/ComboboxGroup.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+type ComboboxGroupProps = {
+    /**
+     * Heading rendered above the group's options. Sticky while the
+     * listbox scrolls: pinned to the scrollport top until the next
+     * group's heading pushes past it (cmdk's form).
+     */
+    label: ReactNode;
+    className?: string;
+    /** The group's `role="option"` rows. */
+    children: ReactNode;
+};
+/**
+ * One labelled section of combobox options: `role="group"` named by
+ * its heading (`aria-labelledby`), the cmdk `CommandGroup` shape.
+ * Combobox clusters consecutive options sharing a `group` label into
+ * one section; groups whose every option was filtered out are not
+ * rendered at all, and keyboard navigation stays continuous across
+ * sections (the highlight lives in the flat option order).
+ */
+export default function ComboboxGroup({ label, className, children, }: ComboboxGroupProps): import("react").JSX.Element;
+export type { ComboboxGroupProps };

package/dist/types/components/Combobox/ComboboxOption.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 type ComboboxOptionProps = {
     value: string;
     highlighted?: boolean;
@@ -8,6 +8,11 @@ type ComboboxOptionProps = {
      * aria-activedescendant while the row holds the keyboard highlight.
      */
     id?: string;
+    /**
+     * Ref to the row element (React 19 ref-as-prop). Combobox points it
+     * at the keyboard-highlighted row to keep it scrolled into view.
+     */
+    ref?: Ref<HTMLDivElement>;
     /**
      * Size of the whole option set, per aria-setsize. Must count every
      * option, not just the rows a windowed (virtualized) list mounted.
@@ -19,5 +24,5 @@ type ComboboxOptionProps = {
     className?: string;
     children: ReactNode;
 };
-export default function ComboboxOption({ value, highlighted, selected, id, setSize, posInSet, onSelect, className, children, }: ComboboxOptionProps): import("react").JSX.Element;
+export default function ComboboxOption({ value, highlighted, selected, id, ref, setSize, posInSet, onSelect, className, children, }: ComboboxOptionProps): import("react").JSX.Element;
 export type { ComboboxOptionProps };

package/dist/types/components/Combobox/index.d.ts

@@ -1,4 +1,6 @@
 export { default as Combobox } from './Combobox';
-export type { ComboboxProps } from './Combobox';
+export type { ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData } from './Combobox';
 export { default as ComboboxOption } from './ComboboxOption';
 export type { ComboboxOptionProps } from './ComboboxOption';
+export { default as ComboboxGroup } from './ComboboxGroup';
+export type { ComboboxGroupProps } from './ComboboxGroup';

package/dist/types/components/Command/Command.d.ts

@@ -1,25 +1,89 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type CommandProps = {
+    /**
+     * The palette's search query (controlled `Control<string>` or plain
+     * uncontrolled initial value). Drives built-in filtering and is
+     * writable through `CommandInput`; consumers may also drive it
+     * themselves — filtering only reads the value.
+     */
     query?: ControlOrValue<string>;
+    /**
+     * Whether items filter themselves against `query` (case-insensitive
+     * substring over the item's `value`/children text and `keywords`).
+     * Default `true` — the palette's historical behavior; pass `false`
+     * when the consumer filters externally (e.g. server-side search).
+     */
+    shouldFilter?: boolean;
+    /**
+     * Palette-level select hook: invoked after any item's own `onSelect`
+     * when it activates (click or Enter/Space). The composition channel
+     * `CommandDialog` uses to close itself on selection; on a bare
+     * `Command` it is a convenient place for logging/focus handoff.
+     */
+    onItemSelect?: () => void;
     children: ReactNode;
     className?: string;
 };
-export default function Command({ query: queryControl, children, className }: CommandProps): import("react").JSX.Element;
+export default function Command({ query: queryControl, shouldFilter, onItemSelect, children, className, }: CommandProps): import("react").JSX.Element;
 type CommandInputProps = {
     placeholder?: string;
     className?: string;
+    /**
+     * Ref to the underlying `<input>` — the palette's focusable element
+     * (Wave 1 ref-channel convention); `CommandDialog` uses it to focus
+     * the input on open.
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export declare function CommandInput({ placeholder, className }: CommandInputProps): import("react").JSX.Element;
+export declare function CommandInput({ placeholder, className, ref }: CommandInputProps): import("react").JSX.Element;
 type CommandListProps = {
     children: ReactNode;
+    /**
+     * Custom no-results content for the empty filtered list. Defaults to
+     * the `command.noResults` locale string.
+     */
+    empty?: ReactNode;
     className?: string;
 };
-export declare function CommandList({ children, className }: CommandListProps): import("react").JSX.Element;
+export declare function CommandList({ children, empty, className }: CommandListProps): import("react").JSX.Element;
+type CommandGroupProps = {
+    /**
+     * Heading rendered above the group's items. Sticky while the list
+     * scrolls: pinned to the scrollport top until the next group's
+     * heading pushes past it (the cmdk shape). Optional — a group may
+     * exist purely to opt its items into empty-group hiding.
+     */
+    heading?: ReactNode;
+    className?: string;
+    /**
+     * The group's `CommandItem` rows (and any wrappers around them).
+     * Optional — a childless group renders nothing (the empty-group
+     * hiding contract covers zero-item groups too).
+     */
+    children?: ReactNode;
+};
+export declare function CommandGroup({ heading, children, className }: CommandGroupProps): import("react").JSX.Element | null;
 type CommandItemProps = {
     children: ReactNode;
+    /**
+     * Explicit filter target. Defaults to the concatenated text of the
+     * item's children (icons and wrappers are walked transparently).
+     */
+    value?: string;
+    /**
+     * Extra filter targets that should surface the item even when its
+     * displayed text misses the query (e.g. synonyms, aliases).
+     */
+    keywords?: readonly string[];
+    /**
+     * Shortcut hint rendered as a `Kbd` badge on the item's inline end —
+     * purely decorative, the binding itself belongs to the consumer
+     * (e.g. `useHotkeys`).
+     */
+    shortcut?: string;
     className?: string;
     onSelect?: () => void;
 };
-export declare function CommandItem({ children, className, onSelect }: CommandItemProps): import("react").JSX.Element | null;
-export type { CommandProps, CommandInputProps, CommandListProps, CommandItemProps };
+export declare function CommandItem({ children, value, keywords, shortcut, className, onSelect, }: CommandItemProps): import("react").JSX.Element | null;
+export type { CommandProps, CommandInputProps, CommandListProps, CommandGroupProps, CommandItemProps, };

package/dist/types/components/Command/CommandDialog.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type CommandDialogProps = {
+    /**
+     * Whether the palette dialog is open (controlled `Control<boolean>`
+     * or plain uncontrolled initial value).
+     */
+    open?: ControlOrValue<boolean>;
+    /**
+     * Called whenever the open state changes through user interaction —
+     * the `hotkey` toggle, selecting an item, Esc or backdrop close.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Global shortcut that toggles the palette, e.g. `'mod+k'` (macOS ⌘K,
+     * elsewhere Ctrl+K; comma-joined aliases and full `useHotkeys` spec
+     * syntax apply). Unset — the default — registers no listener at all.
+     * The binding fires even while focus is inside an input: palette
+     * chords never collide with plain typing.
+     */
+    hotkey?: string;
+    /** Dialog title, rendered as the palette's accessible name (`h2`). */
+    title?: ReactNode;
+    /** Placeholder of the palette's search input. */
+    placeholder?: string;
+    /**
+     * Palette body below the input — `CommandList` (with `CommandGroup` /
+     * `CommandItem` rows). Selecting any item closes the palette; wire
+     * per-item behavior through `CommandItem`'s `onSelect`, which runs
+     * before the close.
+     */
+    children: ReactNode;
+    className?: string;
+};
+export default function CommandDialog({ open: openControl, onOpenChange, hotkey: hotkeySpec, title, placeholder, children, className, }: CommandDialogProps): import("react").JSX.Element;
+export type { CommandDialogProps };