haze-ui 1.32.0 → 1.34.0

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

@@ -1,5 +1,6 @@
 import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { ComboboxOptionData } from './combobox-options.js';
 /** Metrics override for the `virtualized` option list of Combobox. */
 type ComboboxVirtualizedConfig = {
     /**
@@ -14,19 +15,6 @@ type ComboboxVirtualizedConfig = {
      * 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;
-};
 /**
  * Semantic slot classes for Combobox (keys follow the data-slot names;
  * see the `classNames` prop on {@link ComboboxProps}).
@@ -37,15 +25,28 @@ type ComboboxClassNames = {
     item?: string;
     empty?: string;
 };
-type ComboboxProps = {
+type ComboboxProps<T extends string | number = string> = {
     /**
-     * `string` in single mode, `string[]` when `multiple` is set. The
-     * uncontrolled empty value is `''` in single mode, `[]` in multiple
-     * mode.
+     * The option value type: `T` in single mode, `T[]` when `multiple`
+     * is set (defaults to `string`). The uncontrolled empty value is `''`
+     * in single mode, `[]` in multiple mode.
      */
-    value?: ControlOrValue<string | string[]>;
+    value?: ControlOrValue<T | T[]>;
     open?: ControlOrValue<boolean>;
-    options: ComboboxOptionData[];
+    /**
+     * Data-driven option entries (the Select `options` / Menu `items`
+     * precedent): `{value, label, disabled?, group?}` objects. Optional
+     * when compound children supply the rows — the two forms compose,
+     * with the data options rendering first and the children after.
+     */
+    options?: ComboboxOptionData<T>[];
+    /**
+     * Declarative compound children (the Select authoring form):
+     * `<ComboboxOption value>` rows, optionally inside
+     * `<ComboboxGroup label>` sections, flatten into the same option
+     * data the `options` prop takes — both forms behave identically.
+     */
+    children?: ReactNode;
     /**
      * Multiple-selection mode: selected values render as chips inside
      * the trigger, Enter toggles the highlighted option without closing
@@ -54,10 +55,10 @@ type ComboboxProps = {
      */
     multiple?: boolean;
     /**
-     * Value callback for both modes — `string` in single mode,
-     * `string[]` when `multiple` is set — fired after the value updates.
+     * Value callback for both modes — `T` in single mode, `T[]` when
+     * `multiple` is set — fired after the value updates.
      */
-    onValuesChange?: (value: string | string[]) => void;
+    onValuesChange?: (value: T | T[]) => void;
     /**
      * Offer the current query as a creatable option: when nothing
      * matches a non-blank query, a localized `Create "…"` row renders at
@@ -137,5 +138,5 @@ type ComboboxProps = {
      */
     ref?: Ref<HTMLInputElement>;
 };
-export default function Combobox({ value: valueControl, open: openControl, options, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, classNames, ref, }: ComboboxProps): import("react").JSX.Element;
+export default function Combobox<T extends string | number = string>({ value: valueControl, open: openControl, options, children, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, classNames, ref, }: ComboboxProps<T>): import("react").JSX.Element;
 export type { ComboboxClassNames, ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData };

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

@@ -1,8 +1,15 @@
 import type { ReactNode, Ref } from 'react';
-type ComboboxOptionProps = {
-    value: string;
+type ComboboxOptionProps<T extends string | number = string> = {
+    value: T;
     highlighted?: boolean;
     selected?: boolean;
+    /**
+     * Option-level disabled state (from the `options` data or the
+     * declarative `disabled` prop): the row renders dimmed and
+     * `aria-disabled`, and both the click and keyboard pick paths reject
+     * it — the maxCount lock's inert-row contract.
+     */
+    disabled?: boolean;
     /**
      * DOM id of this option — what the combobox input points at via
      * aria-activedescendant while the row holds the keyboard highlight.
@@ -20,9 +27,9 @@ type ComboboxOptionProps = {
     setSize?: number;
     /** 1-based position of this option in the set, per aria-posinset. */
     posInSet?: number;
-    onSelect?: (value: string) => void;
+    onSelect?: (value: T) => void;
     className?: string;
     children: ReactNode;
 };
-export default function ComboboxOption({ value, highlighted, selected, id, ref, setSize, posInSet, onSelect, className, children, }: ComboboxOptionProps): import("react").JSX.Element;
+export default function ComboboxOption<T extends string | number = string>({ value, highlighted, selected, disabled, id, ref, setSize, posInSet, onSelect, className, children, }: ComboboxOptionProps<T>): import("react").JSX.Element;
 export type { ComboboxOptionProps };

package/dist/types/components/Combobox/combobox-options.d.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react';
+/**
+ * One entry of the `options` prop: value, string label, an optional
+ * `disabled` state (rendered dimmed/`aria-disabled`, clicks and Enter
+ * rejected) and an optional `group` heading — consecutive options
+ * sharing a `group` cluster into one `ComboboxGroup` section (the
+ * cmdk shape); options without a `group` stay direct listbox children.
+ */
+export type ComboboxOptionData<T extends string | number = string> = {
+    value: T;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+};
+/**
+ * Flattens declarative compound children — `<ComboboxOption>` rows,
+ * optionally inside `<ComboboxGroup label>` sections — into the same
+ * `ComboboxOptionData[]` the `options` prop takes. The label must be
+ * textual (filtering compares strings): string/number children pass
+ * through, anything else falls back to the stringified value, the same
+ * tolerance Select's extraction shows. Stray non-family children are
+ * ignored, and group nesting assigns the nearest enclosing label.
+ */
+export declare function extractComboboxOptions<T extends string | number = string>(children: ReactNode): ComboboxOptionData<T>[];

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

@@ -1,6 +1,6 @@
-export { default as Combobox } from './Combobox';
-export type { ComboboxClassNames, 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';
+export { default as Combobox } from './Combobox.js';
+export type { ComboboxClassNames, ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData } from './Combobox.js';
+export { default as ComboboxOption } from './ComboboxOption.js';
+export type { ComboboxOptionProps } from './ComboboxOption.js';
+export { default as ComboboxGroup } from './ComboboxGroup.js';
+export type { ComboboxGroupProps } from './ComboboxGroup.js';

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

@@ -10,9 +10,10 @@ type CommandProps = {
     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).
+     * fuzzy subsequence match over the item's `value`/children text and
+     * `keywords`, ranked best-first while a query is active). Default
+     * `true` — the palette's historical behavior; pass `false` when the
+     * consumer filters externally (e.g. server-side search).
      */
     shouldFilter?: boolean;
     /**
@@ -37,6 +38,22 @@ type CommandInputProps = {
     ref?: Ref<HTMLInputElement>;
 };
 export declare function CommandInput({ placeholder, className, ref }: CommandInputProps): import("react").JSX.Element;
+/** Metrics override for CommandList's `virtualized` prop. */
+type CommandListVirtualizedConfig = {
+    /**
+     * Row height in px of one item row. Defaults to 37 — CommandItem's
+     * natural single-line box (space-2 padding top+bottom + text-sm at
+     * leading-normal = 8 + 21 + 8, the same math as Combobox's virtual
+     * rows). Items are stretched to fill it, so the two cannot drift.
+     */
+    itemHeight?: number;
+    /** Extra rows kept mounted around the visible window. Defaults to
+     * VirtualList's 5. */
+    overscan?: number;
+    /** Scrollport height cap in px. Defaults to 300 — the plain list's
+     * `max-height`, so both modes are equally tall at the limit. */
+    height?: number;
+};
 type CommandListProps = {
     children: ReactNode;
     /**
@@ -44,9 +61,23 @@ type CommandListProps = {
      * the `command.noResults` locale string.
      */
     empty?: ReactNode;
+    /**
+     * Render the list through VirtualList — explicit opt-in for long
+     * flat lists (hundreds+ items) where plain DOM rendering gets slow.
+     * `true` uses the default metrics; an object customizes them.
+     *
+     * Flat `<CommandItem>` children only (fragments dissolve): grouped
+     * or wrapped content has no stable row shape to virtualize, so it
+     * logs a dev warning and renders the plain path instead. The empty
+     * state and `shouldFilter={false}` work through the virtual path
+     * like through the plain one; keyboard navigation reaches the
+     * mounted window (focusing an option scrolls it into view, which
+     * re-windows the list).
+     */
+    virtualized?: boolean | CommandListVirtualizedConfig;
     className?: string;
 };
-export declare function CommandList({ children, empty, className }: CommandListProps): import("react").JSX.Element;
+export declare function CommandList({ children, empty, virtualized, className, }: CommandListProps): import("react").JSX.Element;
 type CommandGroupProps = {
     /**
      * Heading rendered above the group's items. Sticky while the list
@@ -86,4 +117,4 @@ type CommandItemProps = {
     onSelect?: () => void;
 };
 export declare function CommandItem({ children, value, keywords, shortcut, className, onSelect, }: CommandItemProps): import("react").JSX.Element | null;
-export type { CommandProps, CommandInputProps, CommandListProps, CommandGroupProps, CommandItemProps, };
+export type { CommandProps, CommandInputProps, CommandListProps, CommandListVirtualizedConfig, CommandGroupProps, CommandItemProps, };

package/dist/types/components/Command/command-filter.d.ts

@@ -9,6 +9,28 @@ export type CommandItemLikeProps = {
     keywords?: readonly string[];
     children?: ReactNode;
 };
+/** Result of one fuzzy probe: whether the query matched, and how well. */
+export type FuzzyMatch = {
+    matched: boolean;
+    score: number;
+};
+/**
+ * Zero-dependency fuzzy match: every query character must appear in the
+ * text, in order (case-insensitive subsequence — a superset of the old
+ * substring match). The score ranks how well it appears:
+ *
+ * - prefix hits beat middle hits (`'sa'` → `Save` over `Mesa`),
+ * - contiguous runs beat scattered singles (`'us'` → `User` over `Status`),
+ * - word starts / camelCase humps beat word middles (`'fb'` → `fooBar`
+ *   over `foobar`),
+ * - earlier hits beat later ones (gap penalty between matches).
+ *
+ * Greedy leftmost matching: each query character binds to its next
+ * occurrence after the previous one. Not globally optimal, but
+ * deterministic, linear-time, and it ranks the cases above correctly.
+ * An empty query matches everything with score 0.
+ */
+export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
 /**
  * Concatenated text of an item's children — the default filter target
  * when no explicit `value` is given. Strings/numbers/booleans pass
@@ -17,13 +39,43 @@ export type CommandItemLikeProps = {
  */
 export declare function commandItemText(node: ReactNode): string;
 /**
- * Case-insensitive substring match of the query against an item's
- * filterable text: the explicit `value` (falling back to the item's
- * concatenated children text) plus every `keywords` entry. An empty
- * query matches everything, preserving the pre-filter behavior of a
- * fresh palette.
+ * Best fuzzy score of an item against the query, over its explicit
+ * `value` (falling back to the concatenated children text) plus every
+ * `keywords` entry. `null` when nothing matches; `0` for the empty
+ * query (everything matches, no ranking signal).
+ */
+export declare function commandItemScore(props: CommandItemLikeProps, query: string): number | null;
+/**
+ * Whether an item matches the query at all (fuzzy subsequence over the
+ * `value`/children text and `keywords`). Boolean view of
+ * `commandItemScore` for callers that do not rank.
  */
 export declare function commandItemMatches(props: CommandItemLikeProps, query: string): boolean;
+/**
+ * Whether a child node is an element of the given item component (the
+ * component reference is passed in — the identity check keeps the walk
+ * precise without importing the component, which would cycle).
+ */
+export declare function isCommandItemElement(node: ReactNode, itemComponent: unknown): node is ReactElement<CommandItemLikeProps>;
+/**
+ * Flattens command children one conceptual level: nested arrays and
+ * null/booleans dissolve (Children.toArray) and fragments are
+ * transparent — their descendants participate as if direct, so a
+ * `<>{cond && <CommandItem/>}{items.map(...)}</>` composition behaves
+ * like a flat item run. Fragment descendants get their keys prefixed
+ * with the fragment's key so merged positional keys cannot collide.
+ */
+export declare function flattenCommandChildren(children: ReactNode): ReactNode[];
+/**
+ * Reorders a flattened child list so matching items come first, best
+ * fuzzy score first (ties keep source order — the sort is stable).
+ * Non-item children (groups, wrappers, text) keep their slots: item
+ * positions are refilled from the ranked queue, so interleaved
+ * non-item content never jumps around. Non-matching items drop out
+ * (they would render nothing anyway). With filtering off or an empty
+ * query the flattened input is returned verbatim.
+ */
+export declare function orderCommandChildren(flatChildren: ReactNode[], itemComponent: unknown, shouldFilter: boolean, query: string): ReactNode[];
 /**
  * Collects every `<CommandItem>` element in the subtree at any nesting
  * depth (directly under the list, inside `<CommandGroup>` wrappers, or

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

@@ -1,4 +1,4 @@
-export { default as Command, CommandInput, CommandList, CommandItem, CommandGroup } from './Command';
-export type { CommandProps, CommandInputProps, CommandListProps, CommandItemProps, CommandGroupProps } from './Command';
-export { default as CommandDialog } from './CommandDialog';
-export type { CommandDialogProps } from './CommandDialog';
+export { default as Command, CommandInput, CommandList, CommandItem, CommandGroup } from './Command.js';
+export type { CommandProps, CommandInputProps, CommandListProps, CommandListVirtualizedConfig, CommandItemProps, CommandGroupProps } from './Command.js';
+export { default as CommandDialog } from './CommandDialog.js';
+export type { CommandDialogProps } from './CommandDialog.js';

package/dist/types/components/ConfigProvider/ConfigContext.d.ts

@@ -1,25 +1,33 @@
-import type { DrawerClassNames } from '../Drawer/Drawer';
-import type { SelectClassNames } from '../Select/Select';
-import type { ComboboxClassNames } from '../Combobox/Combobox';
-import type { TagGroupClassNames } from '../TagGroup/TagGroup';
-import type { ToastPlacement } from '../Toast/ToastContainer';
+import type { DrawerClassNames } from '../Drawer/Drawer.js';
+import type { SelectClassNames } from '../Select/Select.js';
+import type { ComboboxClassNames } from '../Combobox/Combobox.js';
+import type { TagGroupClassNames } from '../TagGroup/TagGroup.js';
+import type { MenuClassNames } from '../Menu/MenuContext.js';
+import type { ToastPlacement } from '../Toast/ToastContainer.js';
+import type { CalendarPickerMode } from '../Calendar/Calendar.js';
+import type { TimePickerFormat } from '../TimePicker/time.js';
 /**
- * Component default overrides, keyed by the exported component name —
- * a simplified AntD-v6 `ConfigProvider` channel scoped to prop defaults
- * (theming stays on the token classes, i18n on `LocaleProvider`).
+ * THE registration record for ConfigProvider prop defaults: one entry
+ * per wired component, keyed by the exported component name, holding
+ * the partial props that component resolves config-side. Adding a
+ * component is one entry here plus the component's own
+ * `useConfigDefaults('Name')` read — nothing else (the merge below and
+ * the accessor in useConfigDefaults.ts are generic over this record).
  *
+ * A simplified AntD-v6 `ConfigProvider` channel scoped to prop defaults
+ * (theming stays on the token classes, i18n on `LocaleProvider`).
  * Each section names the defaults of one component; an explicit prop on
  * the component itself always beats anything set here, and a missing
  * provider leaves every component on its built-in defaults.
  */
-type HazeConfig = {
-    /** `Button` prop defaults. */
-    Button?: {
+type ComponentDefaultsSections = {
+    /** `Button` prop defaults (CopyButton reads the same section). */
+    Button: {
         /** Default `size` when the prop is omitted (built-in `'md'`). */
         size?: 'sm' | 'md' | 'lg';
     };
     /** `ButtonLink` prop defaults — the anchor wearing Button's skin. */
-    ButtonLink?: {
+    ButtonLink: {
         /** Default `size` when the prop is omitted (built-in `'md'`). */
         size?: 'sm' | 'md' | 'lg';
     };
@@ -29,7 +37,7 @@ type HazeConfig = {
      * own 3000ms default regardless of config. `loading()` toasts keep
      * their persistent (0ms) semantics — config never re-arms them.
      */
-    Toast?: {
+    Toast: {
         /** Auto-dismiss budget in ms when a call omits `duration` (3000). */
         duration?: number;
         /** Viewport edge the stack is pinned to (`'bottom-right'`). */
@@ -38,50 +46,122 @@ type HazeConfig = {
         maxCount?: number;
     };
     /** `Tooltip` prop defaults. */
-    Tooltip?: {
+    Tooltip: {
         /** Hover/focus delay in ms before the tooltip appears (150). */
         delay?: number;
     };
     /** `HoverCard` prop defaults. */
-    HoverCard?: {
+    HoverCard: {
         /** Hover/focus dwell in ms before the card opens (200). */
         openDelay?: number;
         /**
          * Grace period in ms after the pointer leaves before the card
-         * closes — the travel window into the panel (120).
+         * closes — the travel window into the panel (120; 300 when the
+         * card renders `interactive`).
          */
         closeDelay?: number;
     };
     /** `Drawer` slot classes — merged under an explicit `classNames` prop. */
-    Drawer?: {
+    Drawer: {
         classNames?: DrawerClassNames;
     };
     /** `Select` slot classes — merged under an explicit `classNames` prop. */
-    Select?: {
+    Select: {
         classNames?: SelectClassNames;
     };
     /** `Combobox` slot classes — merged under an explicit `classNames` prop. */
-    Combobox?: {
+    Combobox: {
         classNames?: ComboboxClassNames;
     };
     /** `TagGroup` slot classes — merged under an explicit `classNames` prop. */
-    TagGroup?: {
+    TagGroup: {
         classNames?: TagGroupClassNames;
     };
+    /** `Input` prop defaults. */
+    Input: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+    };
+    /** `Textarea` prop defaults. */
+    Textarea: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+    };
+    /** `NumberInput` prop defaults. */
+    NumberInput: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+        /** Default increment/decrement `step` (built-in `1`). */
+        step?: number;
+    };
+    /** `Datepicker` prop defaults. */
+    Datepicker: {
+        /** Calendar granularity when the prop is omitted (built-in `'date'`). */
+        picker?: CalendarPickerMode;
+        /** First day of the week for the day grid (locale-derived). */
+        weekStartsOn?: 0 | 1;
+    };
+    /** `TimePicker` prop defaults. */
+    TimePicker: {
+        /** Column granularity / value serialization (built-in `'HH:mm'`). */
+        format?: TimePickerFormat;
+        /** 12-hour clock + AM/PM column, value stays 24-hour (built-in off). */
+        use12Hours?: boolean;
+    };
+    /** `Menu` slot classes — merged under an explicit `classNames` prop. */
+    Menu: {
+        classNames?: MenuClassNames;
+    };
+    /** `Pagination` prop defaults. */
+    Pagination: {
+        /** Default `size` when the prop is omitted (built-in `'md'`). */
+        size?: 'sm' | 'md' | 'lg';
+    };
+    /** `Table` prop defaults. */
+    Table: {
+        /** Zebra-stripe even body rows (built-in off). */
+        striped?: boolean;
+        /** Full cell borders on every th/td (built-in off). */
+        bordered?: boolean;
+    };
+};
+/**
+ * Component default overrides, keyed by the exported component name —
+ * every section of {@link ComponentDefaultsSections}, optional.
+ */
+type HazeConfig = {
+    [Section in keyof ComponentDefaultsSections]?: ComponentDefaultsSections[Section];
 };
+/**
+ * Global spacing density. `'compact'` re-declares the spacing scale at
+ * 75% (tokens/density.ts) inside density-aware components; `'normal'`
+ * is the built-in scale. Carried in context, not DOM — each density-
+ * aware component (Table today) applies the token classes itself.
+ */
+type HazeDensity = 'normal' | 'compact';
 /**
  * The fully merged config visible below a `ConfigProvider`. The
  * provider resolves nesting itself (inner sections shallow-merge over
- * outer ones), so the context always carries one flat value — consumers
- * never walk a chain.
+ * outer ones; an inner `density` wins, an unset one inherits), so the
+ * context always carries one flat value — consumers never walk a chain.
  */
-declare const ConfigContext: import("react").Context<HazeConfig | undefined>;
+type ConfigContextValue = {
+    /** Merged component defaults (see {@link HazeConfig}). */
+    defaults: HazeConfig;
+    /** Resolved spacing density (`'normal'` with no provider). */
+    density: HazeDensity;
+};
+declare const ConfigContext: import("react").Context<ConfigContextValue | undefined>;
 /**
  * Per-section shallow merge for nested providers: keys the inner
  * provider names win, keys it leaves unset keep the outer value, and
  * sections present on only one side pass through untouched. Pure — no
  * DOM access, SSR-safe.
+ *
+ * Generic over the registration record: the section keys come from the
+ * two records themselves, so registering a new section in
+ * `ComponentDefaultsSections` needs no edit here.
  */
 declare function mergeConfig(outer: HazeConfig | undefined, inner: HazeConfig | undefined): HazeConfig;
 export { ConfigContext, mergeConfig };
-export type { HazeConfig };
+export type { HazeConfig, HazeDensity, ConfigContextValue, ComponentDefaultsSections };

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

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { HazeConfig } from './ConfigContext';
+import type { HazeConfig, HazeDensity } from './ConfigContext.js';
 type ConfigProviderProps = {
     /**
      * Component defaults, keyed by exported component name (see
@@ -8,18 +8,28 @@ type ConfigProviderProps = {
      * outer value. Explicit props on a component always beat config values.
      */
     defaults?: HazeConfig;
+    /**
+     * Global spacing density for the subtree. `'compact'` re-declares the
+     * spacing scale at 75% (tokens/density.ts) inside density-aware
+     * components — Table today; `'normal'` (the built-in) leaves the
+     * ambient scale. Nested providers: an inner `density` wins, one that
+     * omits it inherits the outer value. Explicit per-component props (a
+     * component's own density-ish sizing, e.g. DataTable's `size`) stay
+     * on their own axis and keep winning over the ambient scale.
+     */
+    density?: HazeDensity;
     children: ReactNode;
 };
 /**
- * Supplies library-wide component defaults to the subtree — the
- * AntD-v6-ConfigProvider idea, scoped to defaults only. Theming stays on
- * the token classes (`lightTheme` / brand themes) and copy on
- * `LocaleProvider`; the two providers are independent contexts and may
+ * Supplies library-wide component defaults and spacing density to the
+ * subtree — the AntD-v6-ConfigProvider idea, scoped to defaults +
+ * density. Theming stays on the token classes (`lightTheme` / brand
+ * themes) and copy on `LocaleProvider`; the two providers are independent contexts and may
  * be mounted in either order, nested in one another, or used alone.
  *
  * Renders no DOM and touches no browser API — safe under SSR (string
  * render and hydration alike). A client-boundary module (React context):
  * the lib build stamps `'use client'` on it.
  */
-export default function ConfigProvider({ defaults, children, }: ConfigProviderProps): import("react").JSX.Element;
+export default function ConfigProvider({ defaults, density, children, }: ConfigProviderProps): import("react").JSX.Element;
 export type { ConfigProviderProps };

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

@@ -1,4 +1,4 @@
-export { default } from './ConfigProvider';
-export type { ConfigProviderProps } from './ConfigProvider';
-export { useConfigDefaults } from './useConfigDefaults';
-export type { HazeConfig } from './ConfigContext';
+export { default } from './ConfigProvider.js';
+export type { ConfigProviderProps } from './ConfigProvider.js';
+export { useConfigDefaults } from './useConfigDefaults.js';
+export type { HazeConfig, HazeDensity } from './ConfigContext.js';

package/dist/types/components/ConfigProvider/useConfigDefaults.d.ts

@@ -1,4 +1,4 @@
-import type { HazeConfig } from './ConfigContext';
+import type { HazeConfig, HazeDensity } from './ConfigContext.js';
 /**
  * Reads one component's resolved defaults from the enclosing
  * `ConfigProvider` chain. Returns a frozen empty object when no provider
@@ -7,13 +7,17 @@ import type { HazeConfig } from './ConfigContext';
  *
  * ## Wiring a new component (the internal pattern)
  *
- * 1. Declare a section in `HazeConfig` (`ConfigContext.ts`) named after
- *    the exported component:
+ * 1. Register the section — ONE entry in the `ComponentDefaultsSections`
+ *    record (`ConfigContext.ts`) named after the exported component:
  *
  *    ```ts
- *    MyComponent?: { size?: 'sm' | 'md' | 'lg' };
+ *    MyComponent: { size?: 'sm' | 'md' | 'lg' };
  *    ```
  *
+ *    That single entry types the provider prop (`defaults`), the nesting
+ *    merge and this accessor at once — `mergeConfig` derives its section
+ *    keys from the records it merges, so nothing else needs editing.
+ *
  * 2. In the component, drop the destructuring default for each wired
  *    prop and resolve three tiers — explicit prop, config, built-in:
  *
@@ -26,3 +30,12 @@ import type { HazeConfig } from './ConfigContext';
  *    the component rendered before the wiring (byte-identical).
  */
 export declare function useConfigDefaults<K extends keyof HazeConfig>(component: K): Readonly<NonNullable<HazeConfig[K]>>;
+/**
+ * Reads the resolved spacing density from the enclosing
+ * `ConfigProvider` chain — `'normal'` with no provider, an inner
+ * provider's value over an outer one. Density-aware components use this
+ * to apply the token classes that re-declare the spacing scale for
+ * their subtree (Table today; see tokens/density.ts for the island
+ * contract — the spacing class must be re-declared alongside `compact`).
+ */
+export declare function useConfigDensity(): HazeDensity;

package/dist/types/components/ConfirmDialog/confirm.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { ConfirmDialogProps } from './ConfirmDialog';
+import type { ConfirmDialogProps } from './ConfirmDialog.js';
 /**
  * Options for the imperative confirm — {@link ConfirmDialogProps} minus
  * the wired callbacks (the promise carries the answer, so `onClose`/

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

@@ -1,4 +1,4 @@
-export { default as ConfirmDialog } from './ConfirmDialog';
-export type { ConfirmDialogProps } from './ConfirmDialog';
-export { confirm } from './confirm';
-export type { ConfirmOptions } from './confirm';
+export { default as ConfirmDialog } from './ConfirmDialog.js';
+export type { ConfirmDialogProps } from './ConfirmDialog.js';
+export { confirm } from './confirm.js';
+export type { ConfirmOptions } from './confirm.js';

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

@@ -1,2 +1,2 @@
-export { default as Container } from './Container';
-export type { ContainerProps } from './Container';
+export { default as Container } from './Container.js';
+export type { ContainerProps } from './Container.js';

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

@@ -1,10 +1,28 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { ContextMenuClassNames } from './ContextMenuContext.js';
 type ContextMenuProps = {
     open?: ControlOrValue<boolean>;
     onOpenChange?: (open: boolean) => void;
     children: ReactNode;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): declared once
+     * here and distributed to every family part through context (see
+     * {@link ContextMenuClassNames}). Slot classes are appended at the
+     * end of each part's class list; per-part `className` props still
+     * land after the slot class. Not passing it renders identical output.
+     */
+    classNames?: ContextMenuClassNames;
     className?: string;
+    /**
+     * Forwarded to the family's root wrapper `<div>`
+     * (`data-slot='context-menu'`) — the container holding both the
+     * right-click area and the floating panel. The panel itself is a
+     * native popover with its own DOM; reach it through
+     * `classNames.content` styling or panel queries (`role="menu"`), not
+     * this ref.
+     */
+    ref?: Ref<HTMLDivElement>;
 };
-export default function ContextMenu({ open: openControl, onOpenChange, children, className, }: ContextMenuProps): import("react").JSX.Element;
+export default function ContextMenu({ open: openControl, onOpenChange, children, classNames, className, ref, }: ContextMenuProps): import("react").JSX.Element;
 export type { ContextMenuProps };