haze-ui 1.32.0 → 1.34.0

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

@@ -1,5 +1,26 @@
 import type { Dispatch, RefObject, SetStateAction } from 'react';
-import type { FloatingBehavior } from '../../utils/floating';
+import type { FloatingBehavior } from '../../utils/floating.js';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the
+ * ContextMenu family: declared once on `<ContextMenu>` and distributed
+ * to every part through this context — one record themes the wrapper,
+ * the trigger area, the content panel and every item. Consumer classes
+ * are appended at the end of each part's class list (able to override
+ * component defaults); per-part `className` props remain for one-off
+ * tweaks and still land after the slot class.
+ */
+export type ContextMenuClassNames = {
+    /** The wrapper `<div>` (`data-slot='context-menu'`) the root renders. */
+    root?: string;
+    /** Every `<ContextMenuTrigger>` area (`data-slot='trigger'`). */
+    trigger?: string;
+    /** Every `<ContextMenuContent>` panel (`role="menu"`, `data-slot='content'`). */
+    content?: string;
+    /** Every `<ContextMenuItem>` (`data-slot='menu-item'`). */
+    item?: string;
+    /** Every `<ContextMenuSeparator>` (`data-slot='separator'`). */
+    separator?: string;
+};
 type ContextMenuContextValue = {
     open: boolean;
     setOpen: Dispatch<SetStateAction<boolean>>;
@@ -9,6 +30,9 @@ type ContextMenuContextValue = {
     contentRef: RefObject<HTMLDivElement | null>;
     /** Floating-panel behavior shared by the root and content. */
     floating: FloatingBehavior;
+    /** Slot classes declared on the root `<ContextMenu>`; parts append
+     *  them after their own classes, before per-part `className`. */
+    classNames: ContextMenuClassNames | undefined;
 };
 export declare const ContextMenuProvider: import("react").Provider<ContextMenuContextValue | undefined>;
 export declare function useContextMenuContext(): ContextMenuContextValue;

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

@@ -1,10 +1,11 @@
-export { default as ContextMenu } from './ContextMenu';
-export { default as ContextMenuTrigger } from './ContextMenuTrigger';
-export { default as ContextMenuContent } from './ContextMenuContent';
-export { default as ContextMenuItem } from './ContextMenuItem';
-export { default as ContextMenuSeparator } from './ContextMenuSeparator';
-export type { ContextMenuProps } from './ContextMenu';
-export type { ContextMenuTriggerProps } from './ContextMenuTrigger';
-export type { ContextMenuContentProps } from './ContextMenuContent';
-export type { ContextMenuItemProps } from './ContextMenuItem';
-export type { ContextMenuSeparatorProps } from './ContextMenuSeparator';
+export { default as ContextMenu } from './ContextMenu.js';
+export { default as ContextMenuTrigger } from './ContextMenuTrigger.js';
+export { default as ContextMenuContent } from './ContextMenuContent.js';
+export { default as ContextMenuItem } from './ContextMenuItem.js';
+export { default as ContextMenuSeparator } from './ContextMenuSeparator.js';
+export type { ContextMenuProps } from './ContextMenu.js';
+export type { ContextMenuClassNames } from './ContextMenuContext.js';
+export type { ContextMenuTriggerProps } from './ContextMenuTrigger.js';
+export type { ContextMenuContentProps } from './ContextMenuContent.js';
+export type { ContextMenuItemProps } from './ContextMenuItem.js';
+export type { ContextMenuSeparatorProps } from './ContextMenuSeparator.js';

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

@@ -1,4 +1,4 @@
-export { default as ConversationList } from './ConversationList';
-export { default as ConversationItem } from './ConversationItem';
-export type { ConversationListProps } from './ConversationList';
-export type { ConversationItemProps } from './ConversationItem';
+export { default as ConversationList } from './ConversationList.js';
+export { default as ConversationItem } from './ConversationItem.js';
+export type { ConversationListProps } from './ConversationList.js';
+export type { ConversationItemProps } from './ConversationItem.js';

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

@@ -0,0 +1,56 @@
+import type { ReactNode } from 'react';
+import type { ButtonProps } from '../Button/index.js';
+/** Semantic slot classes for CopyButton (AntD v6 `classNames` shape;
+ * keys follow the data-slot names). */
+type CopyButtonClassNames = {
+    /** The button element (Button's data-slot='button'). */
+    root?: string;
+    /** Both glyphs (copy/check); the active one wears the class. */
+    icon?: string;
+};
+type CopyButtonOwnProps = {
+    /** The text to copy. */
+    value?: string;
+    /** Lazy source evaluated on every click (a live reading like the
+     * current URL or a fresh token); wins over `value` when both are
+     * set. */
+    getValue?: () => string;
+    /** How long the copied feedback lasts, in ms. Defaults to 2000. */
+    copiedTimeout?: number;
+    /** Accessible name while idle. Defaults to 'Copy'. */
+    copyLabel?: string;
+    /** Accessible name while copied. Defaults to 'Copied'. */
+    copiedLabel?: string;
+    /** Slot classes (see {@link CopyButtonClassNames}). */
+    classNames?: CopyButtonClassNames;
+};
+type CopyButtonProps = CopyButtonOwnProps & {
+    /**
+     * Icon or label. Defaults to the copy/check glyph pair; a function
+     * receives the copied state so text labels can switch their own
+     * wording (`(copied) => copied ? 'Copied!' : 'Copy'`).
+     */
+    children?: ReactNode | ((copied: boolean) => ReactNode);
+} & Omit<ButtonProps, keyof CopyButtonOwnProps | 'children'>;
+/**
+ * A `Button` that copies text to the clipboard on click and flips into
+ * a copied state for `copiedTimeout` ms (default 2000): the glyph
+ * swaps copy → check (non-solid variants also ink success), the
+ * accessible name swaps `copyLabel` → `copiedLabel`, and a visually
+ * hidden `role='status'` announces the change to screen readers
+ * (WCAG 4.1.3 — the label swap alone is not announced on an already
+ * focused control).
+ *
+ * The copy plumbing is `useClipboard`: async clipboard API first,
+ * deprecated `execCommand` fallback second; when both fail the button
+ * simply stays idle. Sizing and variants are Button's — including the
+ * ConfigProvider `Button.size` default tier. The default shape is the
+ * square icon button (`square`, outline); text-label render props pair
+ * naturally with `square={false}`.
+ *
+ * Precedence notes: `getValue` wins over `value`; an explicit
+ * `aria-label` passed through the rest props overrides the swapped
+ * `copyLabel`/`copiedLabel` naming (statically, for both states).
+ */
+export default function CopyButton({ value, getValue, copiedTimeout, copyLabel, copiedLabel, variant, square, size, classNames, className, children, onClick, ...rest }: CopyButtonProps): import("react").JSX.Element;
+export type { CopyButtonClassNames, CopyButtonProps };

package/dist/types/components/CopyButton/Snippet.d.ts

@@ -0,0 +1,48 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+/** Semantic slot classes for Snippet (AntD v6 `classNames` shape;
+ * keys follow the data-slot names). */
+type SnippetClassNames = {
+    /** The chip wrapper (data-slot='snippet'). */
+    root?: string;
+    /** The mono content cell (data-slot='content'). */
+    content?: string;
+    /** The docked copy button (forwarded to CopyButton's root slot). */
+    copyButton?: string;
+    /** The copy/check glyphs (forwarded to CopyButton's icon slot). */
+    icon?: string;
+};
+type SnippetOwnProps = {
+    /** The text the copy button puts on the clipboard. */
+    value: string;
+    /** How long the copied feedback lasts, in ms. Defaults to 2000. */
+    copiedTimeout?: number;
+    /** CopyButton's accessible name while idle. Defaults to 'Copy'. */
+    copyLabel?: string;
+    /** CopyButton's accessible name while copied. Defaults to 'Copied'. */
+    copiedLabel?: string;
+    /** Slot classes (see {@link SnippetClassNames}). */
+    classNames?: SnippetClassNames;
+};
+type SnippetProps = SnippetOwnProps & {
+    /**
+     * Display content inside the chip; defaults to `value` verbatim.
+     * Pass a styled node to mask secrets or abbreviate long payloads —
+     * the clipboard always gets `value`.
+     */
+    children?: ReactNode;
+    className?: string;
+    /** Forwarded to the chip wrapper (data-slot='snippet'). */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, keyof SnippetOwnProps | 'className' | 'children'>;
+/**
+ * An inline snippet with one-click copy: a mono chip (`value`, or a
+ * custom `children` display) with a small ghost `CopyButton` docked
+ * at the trailing edge — the install-command / API-key / share-link
+ * affordance. Display and clipboard payload are independent: children
+ * never reach the clipboard, `value` always does.
+ *
+ * For a multiline code listing with optional syntax highlighting, use
+ * `CodeBlock` instead — a snippet is a single inline value.
+ */
+export default function Snippet({ value, copiedTimeout, copyLabel, copiedLabel, classNames, className, children, ref, ...rest }: SnippetProps): import("react").JSX.Element;
+export type { SnippetClassNames, SnippetProps };

package/dist/types/components/CopyButton/copy-button-styles.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared CopyButton skin — the copy/check glyph sizing per Button size
+ * and the copied feedback wash. The button chrome itself is Button's
+ * (CopyButton composes a real `Button`), so only the icon steps and
+ * the copied accent live here; split-css groups the emitted CSS into
+ * `haze-ui/css/copy-button.css` (Button's own rules ride along via
+ * the build's cross-family dependency closure).
+ */
+export declare const iconSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+/**
+ * Copied-state accent: the check glyph inks success while
+ * `data-copied` is set. Gated by the component to the non-solid
+ * variants — success-on-primary would sit on a saturated fill where
+ * the tone has no contrast; solid buttons keep their label ink and
+ * the glyph swap alone carries the feedback.
+ */
+export declare const copiedSkin: import("@linaria/core").LinariaClassName;

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

@@ -0,0 +1,5 @@
+export { default as CopyButton } from './CopyButton.js';
+export type { CopyButtonProps, CopyButtonClassNames } from './CopyButton.js';
+export { default as Snippet } from './Snippet.js';
+export type { SnippetProps, SnippetClassNames } from './Snippet.js';
+export { iconSizes } from './copy-button-styles.js';

package/dist/types/components/CopyButton/snippet-styles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared Snippet skin — the inline code chip `Snippet` renders: mono
+ * content cell that ellipsizes, with a CopyButton docked at the
+ * trailing edge. Living in its own module keeps the component file
+ * free of style internals (react-refresh boundary); split-css groups
+ * the emitted CSS into `haze-ui/css/copy-button.css` (Snippet lives
+ * in the CopyButton directory and shares its css family).
+ */
+export declare const snippet: import("@linaria/core").LinariaClassName;
+export declare const content: import("@linaria/core").LinariaClassName;

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

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

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

@@ -0,0 +1,30 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/** Decomposed remaining time handed to `format`/`render`. */
+type CountdownParts = {
+    /** Whole seconds left — `ceil` of the exact milliseconds so every
+     * displayed second is a full second and the display lands on 0 exactly
+     * at the deadline. */
+    totalSeconds: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    /** Deadline reached — parts are all zero and the clock has stopped. */
+    finished: boolean;
+};
+type CountdownProps = {
+    /** Deadline: epoch milliseconds or a `Date`. Changing it re-aims the
+     * clock (and re-arms a spent `onFinish`). */
+    value: number | Date;
+    /** Fires exactly once when the deadline is reached. */
+    onFinish?: () => void;
+    /** Parts → display string. Default: adaptive — `1d 02:03:04` past a
+     * day, `02:03:04` under it. */
+    format?: (parts: CountdownParts) => string;
+    /** Parts → arbitrary node — the render escape hatch next to `format`
+     * for non-string output. */
+    render?: (parts: CountdownParts) => ReactNode;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'children'>;
+export default function Countdown({ value, onFinish, format, render, className, ...rest }: CountdownProps): import("react").JSX.Element;
+export type { CountdownProps, CountdownParts };

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

@@ -0,0 +1,2 @@
+export { default as Countdown } from './Countdown.js';
+export type { CountdownProps, CountdownParts } from './Countdown.js';

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

@@ -1,8 +1,9 @@
-import type { ComponentPropsWithoutRef, MouseEvent, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, MouseEvent, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { ColumnDef, ColumnVisibilityState, ExpandedState, Row, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
-import type { DataTableCellEditorProps, DataTableColumnMeta } from './features';
-import { dataTableFeatures } from './features';
+import type { ColumnDef, ColumnOrderState, ColumnVisibilityState, ExpandedState, Row, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
+import type { DataTableCellEditorProps, DataTableColumnMeta } from './features.js';
+import type { DataTableFiltersState } from './filters.js';
+import { dataTableFeatures } from './features.js';
 /** Windowing configuration for the table body, reusing `VirtualList`. */
 type DataTableVirtualized = boolean | {
     /** Fixed row height in px — must match the rendered row (custom cell
@@ -16,9 +17,22 @@ type DataTableVirtualized = boolean | {
  * bound to DataTable's feature set and column meta. The native `size`
  * field doubles as a static px width hint (read as the colgroup width
  * fallback after `meta.width`) and seeds the resize math when `resizable`
- * is on. */
+ * is on. The `meta` extension adds `filterFn`, the custom predicate of
+ * the header filter menu, typed against this table's row data (the
+ * feature-registered meta carries only the TData-independent fields). */
 type DataTableColumnDef<TData extends RowData> = ColumnDef<typeof dataTableFeatures, TData> & {
     size?: number;
+    meta?: {
+        /**
+         * Replaces the default membership check of the header filter menu
+         * (`meta.filters`): a row passes the column's filter when this
+         * returns true for the selected values array. Receives the row's
+         * original data, the selected option values and the current cell
+         * value. The default keeps rows whose cell value equals a selected
+         * one (`values.includes(rowValue)`).
+         */
+        filterFn?: (row: TData, filterValue: unknown[], rowValue: unknown) => boolean;
+    };
 };
 /** One cell of a summary row: a static string or number (`undefined`
  * renders an empty cell — `dataTableAvg` of no numeric values), or a
@@ -32,6 +46,43 @@ type DataTableSummary<TData extends RowData = RowData> = {
     label?: string;
     cells: DataTableSummaryCell<TData>[];
 };
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for DataTable:
+ * declared once on the root and distributed to the structural parts —
+ * the wrapper, the toolbar strip and the pagination footer on their
+ * own `<div>`s, the header/body/row/cell slots through the same
+ * context the Table primitives read (every `<th>`/`<td>` the table
+ * renders — header, body, selection, skeleton, empty, filter and
+ * summary cells alike). Slot classes are appended at the end of each
+ * part's class list; per-part `className` stays on the root and still
+ * lands after the `wrapper` slot.
+ */
+type DataTableClassNames = {
+    /** The root wrapper (`data-slot='data-table'`). */
+    wrapper?: string;
+    /** The header `<thead>` (rendered through `TableHead`). */
+    header?: string;
+    /** The toolbar strip above the table (`data-slot='toolbar'`) — only
+     *  rendered while the `toolbar` slot or `columnToggle` (without
+     *  `pageSize`) contributes something. */
+    toolbar?: string;
+    /** The pagination footer row (`data-slot='pagination'`) — only
+     *  rendered while `pageSize` is set. */
+    footer?: string;
+    /** Every body `<tbody>` (rendered through `TableBody`) — data,
+     *  skeleton, empty and filter bodies alike. */
+    body?: string;
+    /** Every data row `<tr>` — body rows plus the skeleton and empty
+     *  placeholder rows and the summary rows (header rows keep the
+     *  `header` slot's domain). */
+    row?: string;
+    /** Every cell `<th>`/`<td>` — header, body (incl. selection),
+     *  skeleton, empty, filter and summary cells alike. */
+    cell?: string;
+    /** The summary `<tfoot>` (`data-slot='summary'`) — only rendered
+     *  while `summary` returns rows. */
+    summary?: string;
+};
 type DataTableProps<TData extends RowData> = {
     /** Column definitions: accessors, headers and cell templates. */
     columns: DataTableColumnDef<TData>[];
@@ -95,9 +146,11 @@ type DataTableProps<TData extends RowData> = {
      * height; an object pins it explicitly (plus an optional `overscan`,
      * default 5).
      *
-     * The default height is `34px` — the natural single-line row of the
-     * default cell styles: 2 × `--haze-space-2` padding (16px) + a 14px
-     * (`--haze-text-sm`) line box + the 1px row border.
+     * The default height follows the `size` density step — `34px` at `md`,
+     * the natural single-line row of the default cell styles: 2 ×
+     * `--haze-space-2` padding (16px) + a 14px (`--haze-text-sm`) line box +
+     * the 1px row border. `sm` tightens it to `23px`, `lg` loosens it to
+     * `39px`.
      *
      * Limitations and tradeoffs (evaluated against keeping `<tr>`s in one
      * shared table): `VirtualList` positions rows through absolutely
@@ -209,6 +262,31 @@ type DataTableProps<TData extends RowData> = {
      * filter function. Defaults to `false`.
      */
     filterable?: boolean;
+    /**
+     * Column filter menus: any column declaring `meta.filters` (a list of
+     * `{ text, value }` options) grows a funnel trigger in its header cell
+     * opening a floating panel with one checkbox per option, plus
+     * Apply/Reset. The state maps column id → selected option values; it
+     * composes with the `filterable` text row, sorting and pagination
+     * (menus filter first, then the text filters, then sorting, then the
+     * page slice), and `dataTableToCsv` mirrors it through its `filters`
+     * option. A row passes when `meta.filterFn` returns true for the
+     * selection — the default keeps rows whose cell value equals a
+     * selected one. Controllable exactly like `sorting`/`page`: pass a
+     * value or `Control` to seed or drive it, observe every mutation
+     * through `onFiltersChange`. In `manual` mode the table renders `data`
+     * as received (the refetch trigger is yours, like sorting); row ids
+     * derive from the filtered array, so combine with `getRowId` when
+     * filtering and selecting together.
+     */
+    filters?: ControlOrValue<DataTableFiltersState>;
+    /**
+     * Fires with the next column-filter state whenever a menu commits —
+     * Apply and Reset clicks alike, and programmatic updates on a
+     * controlled `filters`. In `manual` mode this is the server refetch
+     * trigger.
+     */
+    onFiltersChange?: (filters: DataTableFiltersState) => void;
     /**
      * Renders summary rows in a `<tfoot>` below the body: one row per entry,
      * one cell per leaf column (`cells[i]` aligns with column `i`; the
@@ -248,7 +326,88 @@ type DataTableProps<TData extends RowData> = {
      * consumer owns the data — update it to make the edit visible.
      */
     onCellEdit?: (rowId: string, columnId: string, nextValue: unknown, prevValue: unknown) => void;
+    /**
+     * Custom actions rendered in the toolbar strip at the table's inline-end
+     * corner — the same container as the `columnToggle` trigger (flex row,
+     * content first, trigger last). Renders above the table whether or not
+     * `pageSize` is set; the strip only appears when this slot or
+     * `columnToggle` contributes something (`null`/`undefined` render
+     * nothing). Available in every mode — `loading` swaps the body for the
+     * skeleton and leaves the strip untouched.
+     */
+    toolbar?: ReactNode;
+    /**
+     * Cell density across header, body and summary footer: `sm` tightens the
+     * cell padding to `--haze-space-1/--haze-space-2`, `lg` loosens it to
+     * `--haze-space-3/--haze-space-4`, `md` (the default) keeps the Table
+     * primitives' `--haze-space-2/--haze-space-3`. Padding comes from spacing
+     * tokens, so the global `compact` density class composes — it shrinks the
+     * tokens these rules consume rather than fighting them (compact + `sm`
+     * stacks). Font size stays `--haze-text-sm` in every step; when
+     * `virtualized` without an explicit `rowHeight`, the default height
+     * follows the step (23/34/39px).
+     */
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Enable column reordering: every leaf header cell grows a drag grip
+     * (an inline-start ⠿ affordance) that can be dragged with the pointer —
+     * via `@dnd-kit`, loaded lazily the first time this prop is on, so
+     * tables that never opt in carry none of the drag runtime — or moved
+     * with the keyboard: the grip is a focusable button (its own tab stop,
+     * the resize-handle precedent) and Alt+ArrowLeft / Alt+ArrowRight move
+     * the column one slot (mirrored under RTL). The order lives in
+     * TanStack's `columnOrder` state and every reorder reports through
+     * `onColumnOrderChange`. The selection column stays pinned out of the
+     * reordering set, as do hidden columns (they simply have no grip);
+     * tree-expandable rows keep their expander inside the first content
+     * column, which reorders like any other. Composes with sorting,
+     * resizing (grip inline-start, resize handle inline-end), fixed
+     * columns, filtering and `virtualized` — the mirrored colgroup follows
+     * the new order. Grouped (nested) headers disable reordering: the prop
+     * is ignored and a dev-mode `console.warn` explains why, because a
+     * group header spans several leaves and has no single slot to move.
+     */
+    columnReorderable?: boolean;
+    /**
+     * Reports the next column order — the ids of every visible leaf column,
+     * in their new sequence — after a completed reorder, whether it came
+     * from a pointer drag or the Alt+Arrow keys. Purely observational: the
+     * order itself is owned by the table's internal state, so persisting a
+     * preferred order means seeding `columns` in that sequence next mount.
+     */
+    onColumnOrderChange?: (order: ColumnOrderState) => void;
+    /**
+     * Infinite-scroll trigger: fires when the table's scroll position comes
+     * within `endReachedThreshold` px of the last rendered row — the "load
+     * the next page" signal. In `virtualized` mode this is VirtualList's
+     * own end-reached channel (content shorter than the window fires
+     * immediately, and the trigger re-arms after content grows); otherwise
+     * a zero-footprint sentinel after the body is watched through an
+     * IntersectionObserver rooted at the table's own scroll container when
+     * it scrolls vertically (`stickyHeader`), falling back to the viewport —
+     * which still respects consumer scroll containers, since intersection
+     * is computed through every scrollable clipper between the sentinel
+     * and the viewport. Coexists with `manual` pagination on purpose:
+     * `onEndReached` keeps firing and the consumer decides whether to
+     * append rows or let the pager turn pages.
+     */
+    onEndReached?: () => void;
+    /**
+     * Distance in px from the end of the content that arms `onEndReached`.
+     * Defaults to `200`.
+     */
+    endReachedThreshold?: number;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): keyed by
+     * structural part (see {@link DataTableClassNames}). Not passing it
+     * renders identical output.
+     */
+    classNames?: DataTableClassNames;
     className?: string;
+    /** Forwarded to the root wrapper `<div>` (`data-slot='data-table'`)
+     *  — the `...rest` spread keeps landing on the inner `<table>`. */
+    ref?: Ref<HTMLDivElement>;
 } & Omit<ComponentPropsWithoutRef<'table'>, 'children' | 'summary'>;
-export default function DataTable<TData extends RowData>({ columns, data, sortable, selectable, rowSelection: rowSelectionControl, sorting: sortingControl, pageSize, page: pageControl, manual, pageCount, onPageChange, onSortChange, loading, stickyHeader, virtualized, getRowId, onRowClick, empty, resizable, expanded: expandedControl, getRowCanExpand, renderExpandedRow, subRowsKey, columnVisibility: columnVisibilityControl, columnToggle, filterable, summary, stickyFooter, editable, onCellEdit, className, ...rest }: DataTableProps<TData>): import("react").JSX.Element;
-export type { DataTableProps, DataTableColumnDef, DataTableColumnMeta, DataTableVirtualized, DataTableSummary, DataTableSummaryCell, DataTableCellEditorProps, };
+export default function DataTable<TData extends RowData>({ columns, data, sortable, selectable, rowSelection: rowSelectionControl, sorting: sortingControl, pageSize, page: pageControl, manual, pageCount, onPageChange, onSortChange, loading, stickyHeader, virtualized, getRowId, onRowClick, empty, resizable, expanded: expandedControl, getRowCanExpand, renderExpandedRow, subRowsKey, columnVisibility: columnVisibilityControl, columnToggle, filterable, filters: filtersControl, onFiltersChange, summary, stickyFooter, editable, onCellEdit, toolbar: toolbarSlot, size: density, columnReorderable, onColumnOrderChange, onEndReached, endReachedThreshold, classNames, className, ref, ...rest }: DataTableProps<TData>): import("react").JSX.Element;
+export type { DataTableProps, DataTableClassNames, DataTableColumnDef, DataTableColumnMeta, DataTableVirtualized, DataTableSummary, DataTableSummaryCell, DataTableCellEditorProps, };
+export type { DataTableFiltersState } from './filters.js';

package/dist/types/components/DataTable/column-filter.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+/** One predefined option of a column's header filter menu (`meta.filters`
+ * entry): the visible label and the value landing in the `filters` state
+ * when selected. */
+type ColumnFilterOption = {
+    text: ReactNode;
+    value: unknown;
+};
+/**
+ * The funnel trigger on a filterable column's header cell: a `Popover`
+ * (its trigger span carries `role=button`, `aria-expanded`,
+ * `aria-haspopup` and the keyboard model) opening the column's filter
+ * menu. The icon marks the active state — filled and primary-colored
+ * while the column carries a selection.
+ */
+declare function ColumnFilterTrigger({ label, options, selected, onChange, }: {
+    /** Column label — the trigger's sr-only name and the group's. */
+    label: string;
+    /** The column's predefined options, in declared order. */
+    options: ColumnFilterOption[];
+    /** The committed selection (selected option values). */
+    selected: unknown[];
+    /** Commits the next selection for this column. */
+    onChange: (values: unknown[]) => void;
+}): import("react").JSX.Element;
+export default ColumnFilterTrigger;
+export type { ColumnFilterOption };

package/dist/types/components/DataTable/column-reorder.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+import { SortableItem } from '../../utils/sortable.js';
+/**
+ * The lazily loaded drag wiring behind DataTable's `columnReorderable` —
+ * the Chart/recharts contract inverted: DataTable is a base component, so
+ * its static import graph must stay free of the `@dnd-kit` runtime (the
+ * dist-esm contract's peer import rules); the table imports this module
+ * dynamically the first time column reordering is actually enabled. Only
+ * the pointer-drag mechanics live here — the reorder grips (focusable
+ * buttons with their Alt+Arrow keyboard model) render from DataTable.tsx
+ * with no dnd dependency at all, so keyboard reordering works even before
+ * this chunk arrives and nothing about the table changes for consumers
+ * that never opt in.
+ *
+ * Reaches @dnd-kit only through the utils sortable modules — never
+ * directly — so no dist file outside the contract's allowlist grows an
+ * engine import. Not part of the public barrel.
+ */
+type ColumnReorderRegionProps = {
+    /** Visible leaf column ids in current order — one sortable item each. */
+    ids: string[];
+    /** Index move resolved from a completed pointer drag. */
+    onMove: (from: number, to: number) => void;
+    children: ReactNode;
+};
+/** DndContext + SortableContext around the table root. Renders no DOM of
+ * its own except dnd-kit's screen-reader live regions, which land inside
+ * the DataTable root div — outside the `<table>`, where a stray `<div>`
+ * would be invalid markup (the SortableTabList precedent keeps them out
+ * of its tablist for the same reason). */
+export declare function ColumnReorderRegion({ ids, onMove, children, }: ColumnReorderRegionProps): import("react").JSX.Element;
+export { SortableItem as ColumnReorderItem };

package/dist/types/components/DataTable/csv.d.ts

@@ -1,5 +1,6 @@
 import type { ColumnVisibilityState, RowData } from '@tanstack/react-table';
-import type { DataTableColumnDef } from './DataTable';
+import type { DataTableColumnDef } from './DataTable.js';
+import type { DataTableFiltersState } from './filters.js';
 /** Options for `dataTableToCsv`. */
 type DataTableCsvOptions = {
     /**
@@ -16,6 +17,13 @@ type DataTableCsvOptions = {
      * the table renders.
      */
     columnVisibility?: ColumnVisibilityState;
+    /**
+     * The table's header-filter state (the `filters` control's value): rows
+     * are filtered through the same engine the table uses before
+     * serialization, so the export mirrors the filtered rows exactly —
+     * pass the value straight from your control, like `columnVisibility`.
+     */
+    filters?: DataTableFiltersState;
 };
 /**
  * Serializes rows and column defs to a CSV string (RFC 4180: CRLF row
@@ -24,8 +32,10 @@ type DataTableCsvOptions = {
  * back to its id; grouped columns flatten to their leaves. Only exporting
  * columns contribute: display-only columns (no `accessorKey`/`accessorFn`)
  * are skipped, as are `meta.excludeFromExport` columns and columns hidden
- * in `options.columnVisibility`. A UTF-8 BOM is prepended by default so
- * Excel decodes non-ASCII text correctly (`bom: false` drops it).
+ * in `options.columnVisibility`; `options.filters` drops rows through
+ * the header filter menus' engine first. A UTF-8 BOM is prepended by
+ * default so Excel decodes non-ASCII text correctly (`bom: false` drops
+ * it).
  *
  * Pure string building — no DOM, no table instance — so it runs anywhere
  * the row data lives (client, worker, server) on the same `columns` array

package/dist/types/components/DataTable/features.d.ts

@@ -70,6 +70,21 @@ type DataTableColumnMeta = {
      * column. The native TanStack `enableColumnFilter` field wins over this.
      */
     filterable?: boolean;
+    /**
+     * Predefined filter options for the column's header filter menu (the
+     * AntD `column.filters` seam): when non-empty, the column header grows
+     * a funnel trigger opening a floating panel with one checkbox per
+     * option. Selected `value`s land in the table-level `filters` state
+     * keyed by column id; a row passes when `meta.filterFn` (or the
+     * default membership check) returns true for the selection. Leaf
+     * columns only — a group header spans several columns and has no
+     * single value to filter on. `dataTableToCsv` honors the same state
+     * through its `filters` option.
+     */
+    filters?: {
+        text: ReactNode;
+        value: unknown;
+    }[];
     /**
      * `true` keeps the column out of `dataTableToCsv` exports — the flag for
      * columns whose cells are presentation-only (badges, action buttons) or
@@ -92,7 +107,8 @@ type DataTableColumnMeta = {
  * actually drives are registered. `columnMeta` is a type-only slot that
  * types `meta` on column definitions.
  *
- * The resizing, expanding, visibility and filtering features are registered
+ * The resizing, expanding, visibility, ordering and filtering features are
+ * registered
  * unconditionally but stay inert until their table-level props opt in —
  * with empty state and no `getSubRows` wired their row-model steps are
  * identities, so the default render path is unchanged. The column-sizing
@@ -111,6 +127,7 @@ declare const dataTableFeatures: {
     rowExpandingFeature: import("@tanstack/react-table").TableFeature;
     expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
     columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/react-table").TableFeature;
     columnFilteringFeature: import("@tanstack/react-table").TableFeature;
     filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
     filterFns: {

package/dist/types/components/DataTable/filters.d.ts

@@ -0,0 +1,25 @@
+import type { RowData } from '@tanstack/react-table';
+import type { DataTableColumnDef } from './DataTable.js';
+/**
+ * The header-filter state: selected option `value`s keyed by column id
+ * (the id TanStack derives — explicit `id`, else the `accessorKey`). An
+ * absent key or empty array means "no filter"; empty selections are
+ * dropped from the state on commit so `{}` is the canonical "no
+ * filters" value.
+ */
+type DataTableFiltersState = Record<string, unknown[]>;
+/**
+ * Applies the header filter menus' selections to raw rows — the shared
+ * engine behind the table's data pipeline (menus filter before sorting
+ * and pagination) and `dataTableToCsv`'s `filters` option, so an export
+ * mirrors exactly what the table renders. A column with no active
+ * selection filters nothing; with one, a row passes when its
+ * `meta.filterFn` returns true for the selected values array, defaulting
+ * to a membership check on the cell value (`values.includes(rowValue)`,
+ * SameValueZero — NaN-safe). Columns are combined with AND, options
+ * within a column with the `filterFn`'s own semantics (OR by default).
+ * Inert without active selections — the input array is returned as-is.
+ */
+declare function applyColumnFilters<TData extends RowData>(rows: TData[], columns: DataTableColumnDef<TData>[], filters: DataTableFiltersState | undefined): TData[];
+export { applyColumnFilters };
+export type { DataTableFiltersState };