haze-ui 1.26.0 → 1.28.0

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

@@ -0,0 +1,34 @@
+import type { ReactElement, ReactNode } from 'react';
+/**
+ * Props of a `<CommandItem>` element as far as built-in filtering is
+ * concerned. Structurally typed (not imported from Command.tsx) so the
+ * helper stays free of the component-file import cycle.
+ */
+export type CommandItemLikeProps = {
+    value?: string;
+    keywords?: readonly string[];
+    children?: ReactNode;
+};
+/**
+ * Concatenated text of an item's children — the default filter target
+ * when no explicit `value` is given. Strings/numbers/booleans pass
+ * through; nested arrays and elements are walked depth-first (the same
+ * shape as Select's `selectOptionText`).
+ */
+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.
+ */
+export declare function commandItemMatches(props: CommandItemLikeProps, query: string): boolean;
+/**
+ * Collects every `<CommandItem>` element in the subtree at any nesting
+ * depth (directly under the list, inside `<CommandGroup>` wrappers, or
+ * behind plain layout elements/fragments). The component reference is
+ * passed in by the caller — the identity check is what keeps the walk
+ * precise without importing the component (import cycle).
+ */
+export declare function collectCommandItems(children: ReactNode, itemComponent: unknown): ReactElement<CommandItemLikeProps>[];

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

@@ -1,2 +1,4 @@
-export { default as Command, CommandInput, CommandList, CommandItem } from './Command';
-export type { CommandProps, CommandInputProps, CommandListProps, CommandItemProps } from './Command';
+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';

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

@@ -0,0 +1,24 @@
+type CellEditorProps = {
+    /** Built-in editor variant: text saves the raw draft, number parses it. */
+    kind: 'text' | 'number';
+    /** Current cell value — stringified into the draft. */
+    value: unknown;
+    /** Accessible name for the editor input. */
+    ariaLabel: string;
+    /**
+     * Commits the draft: the text variant reports the raw string, the number
+     * variant a parsed number (`null` when the draft is empty). Called once
+     * (Enter or blur); the editor then unmounts as DataTable exits edit mode.
+     */
+    onSave: (next: string | number | null) => void;
+    /** Discards the draft (Escape). */
+    onCancel: () => void;
+};
+/**
+ * The built-in inline cell editor behind `editable` + `meta.editor:
+ * 'text' | 'number'`. Enters with focus and the draft selected; Enter
+ * saves, Escape cancels, blur saves. After a keyboard exit (Enter/Escape)
+ * focus returns to the cell so Tab keeps walking the row.
+ */
+export default function CellEditor({ kind, value, ariaLabel, onSave, onCancel, }: CellEditorProps): import("react").JSX.Element;
+export type { CellEditorProps };

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

@@ -1,11 +1,8 @@
 import type { ComponentPropsWithoutRef, MouseEvent, ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { ColumnDef, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
-/** Per-column metadata understood by DataTable. */
-type DataTableColumnMeta = {
-    /** Column-level sorting switch — overrides the table-level `sortable` default. */
-    sortable?: boolean;
-};
+import type { ColumnDef, ColumnVisibilityState, ExpandedState, Row, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
+import type { DataTableCellEditorProps, DataTableColumnMeta } from './features';
+import { dataTableFeatures } from './features';
 /** Windowing configuration for the table body, reusing `VirtualList`. */
 type DataTableVirtualized = boolean | {
     /** Fixed row height in px — must match the rendered row (custom cell
@@ -15,25 +12,26 @@ type DataTableVirtualized = boolean | {
      * Defaults to `VirtualList`'s `5`. */
     overscan?: number;
 };
-/** The feature set stitched into every DataTable instance — TanStack v9's
- * tree-shaking contract: only the row models and registries the component
- * actually drives are registered. `columnMeta` is a type-only slot that
- * types `meta` on column definitions. */
-declare const dataTableFeatures: {
-    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
-    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
-    rowSortingFeature: import("@tanstack/react-table").TableFeature;
-    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
-    sortFns: {
-        alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
-        text: import("@tanstack/react-table").CreatedSortFn<any, any>;
-    };
-    columnMeta: DataTableColumnMeta;
-};
 /** Column definition accepted by DataTable — a TanStack Table column def
- * bound to DataTable's feature set and column meta. */
-type DataTableColumnDef<TData extends RowData> = ColumnDef<typeof dataTableFeatures, TData>;
+ * 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. */
+type DataTableColumnDef<TData extends RowData> = ColumnDef<typeof dataTableFeatures, TData> & {
+    size?: number;
+};
+/** One cell of a summary row: a static string or number (`undefined`
+ * renders an empty cell — `dataTableAvg` of no numeric values), or a
+ * function of the summarized rows (the place `dataTableSum` & co. plug
+ * in). */
+type DataTableSummaryCell<TData extends RowData = RowData> = string | number | undefined | ((rows: Row<typeof dataTableFeatures, TData>[]) => ReactNode);
+/** One `<tfoot>` row produced by the `summary` callback: an optional
+ * accessible label for the whole row (rendered as its `aria-label`) and
+ * one cell per leaf column, in column order. */
+type DataTableSummary<TData extends RowData = RowData> = {
+    label?: string;
+    cells: DataTableSummaryCell<TData>[];
+};
 type DataTableProps<TData extends RowData> = {
     /** Column definitions: accessors, headers and cell templates. */
     columns: DataTableColumnDef<TData>[];
@@ -52,6 +50,41 @@ type DataTableProps<TData extends RowData> = {
     pageSize?: number;
     /** Current page, 1-based, when paginating. */
     page?: ControlOrValue<number>;
+    /**
+     * Server-driven mode: sorting and pagination stop being computed
+     * locally. TanStack's `manualSorting` / `manualPagination` under the
+     * hood — the table renders `data` exactly as received (no reordering,
+     * no page slicing), so the consumer fetches each page pre-sorted and
+     * pre-sliced. Sort-header clicks still toggle the `sorting` state (and
+     * `aria-sort`), and the footer still tracks the `page` state; the
+     * consumer observes both through the `onSortChange` / `onPageChange`
+     * callbacks (or the `sorting` / `page` controls) and refetches. Pass
+     * `pageCount` so the footer knows the server-side page total — without
+     * it the footer falls back to `data.length`, i.e. one full page.
+     * Composes with `rowSelection`, `loading`, `virtualized` and the
+     * skeleton exactly as in local mode.
+     */
+    manual?: boolean;
+    /**
+     * Total number of pages, overriding the footer's page math in `manual`
+     * mode (locally derived from `data.length` otherwise). Only meaningful
+     * together with `pageSize`.
+     */
+    pageCount?: number;
+    /**
+     * Fires with the next 1-based page whenever the page changes — footer
+     * clicks and programmatic updates alike, in local and `manual` mode.
+     * The `manual`-mode refetch trigger; pairs with `pageCount`.
+     */
+    onPageChange?: (page: number) => void;
+    /**
+     * Fires with the next TanStack `SortingState` whenever sorting changes
+     * — header clicks (including multi-sort) and programmatic updates
+     * alike, in local and `manual` mode. In `manual` mode this is the
+     * server refetch trigger; the table itself keeps rendering `data`
+     * untouched.
+     */
+    onSortChange?: (sorting: SortingState) => void;
     /** Render skeleton rows instead of data. */
     loading?: boolean;
     /** Keep the header visible while the table body scrolls. */
@@ -72,13 +105,22 @@ type DataTableProps<TData extends RowData> = {
      * `display: table-row` — so rows cannot stay in the header's table.
      * Instead each row renders as a complete sibling `<table><tbody><tr>`
      * inside the wrapper. Rows remain legal, axe-clean table structures
-     * with row/cell roles, and `table-layout: fixed` on header and rows
-     * distributes columns equally in both, keeping them aligned without a
-     * column-width measurement pass. Consequences:
+     * with row/cell roles. One shared `<colgroup>` — the selection column
+     * plus every leaf column's `meta.width` (falling back to the native
+     * `size`) — is mirrored into the header table and every row table, and
+     * `table-layout: fixed` honors it identically in each sibling: columns
+     * with a width are fixed at it, columns without one split the remaining
+     * space equally. That mirrored sequence is the alignment contract
+     * between the sibling tables — no column-width measurement pass.
+     * Consequences:
      * - Fixed row height only — dynamic or wrapping row heights are not
      *   supported; content taller than `rowHeight` overlaps the next row.
-     * - Columns distribute equally instead of auto-sizing to content;
-     *   per-column widths are not supported in this mode.
+     * - Column widths are declarative (`meta.width` / `size`), never
+     *   content-driven: columns without a width share the remainder equally
+     *   instead of auto-sizing to content.
+     * - `meta.fixed` is ignored in this mode — each row is its own table
+     *   inside its own absolutely positioned wrapper, so there is no shared
+     *   horizontal scrollport for cells to stick against.
      * - The header sits outside the scroll window (always visible) — the
      *   `stickyHeader` behavior is implied.
      * - The root must be height-bounded by the consumer (e.g. a
@@ -96,7 +138,117 @@ type DataTableProps<TData extends RowData> = {
     onRowClick?: (row: TData, event: MouseEvent<HTMLTableRowElement>) => void;
     /** Custom empty-state node; defaults to the `Empty` component. */
     empty?: ReactNode;
+    /**
+     * Enable column resizing: every leaf header cell (except those switched
+     * off per column) grows a drag handle on its inline-end edge. Dragging
+     * commits widths live (TanStack `columnResizeMode: 'onChange'`); the
+     * handle is a focusable `separator` widget — ArrowLeft/ArrowRight nudge
+     * the width by 5px (mirrored under RTL, read from the DOM at event
+     * time), double-click resets the column to its declared width.
+     * Per-column `meta.resizable` (or native `enableResizing`) overrides per
+     * column. Defaults to `false` — no handles, no colgroup change.
+     */
+    resizable?: boolean;
+    /**
+     * Expanded-row state (TanStack `ExpandedState`: `true` for all, or a map
+     * keyed by row id). Drives both expansion flavors: custom panels
+     * (`getRowCanExpand` + `renderExpandedRow`) and tree data (`subRows`).
+     */
+    expanded?: ControlOrValue<ExpandedState>;
+    /**
+     * Decides which rows offer an expander button in the first content
+     * column. Without it, providing `renderExpandedRow` alone makes every
+     * row expandable. Explicit expansion props win over tree data: when
+     * either this or `renderExpandedRow` is given, `subRows` fields are
+     * ignored and rows never nest.
+     */
+    getRowCanExpand?: (row: Row<typeof dataTableFeatures, TData>) => boolean;
+    /**
+     * Renders the expansion panel: a full-width row (`colSpan` across every
+     * visible column) directly below each expanded row. Called with the
+     * TanStack row (`.original` carries the data). Providing it (or
+     * `getRowCanExpand`) switches the table to custom-panel expansion and
+     * disables tree mode.
+     */
+    renderExpandedRow?: (row: Row<typeof dataTableFeatures, TData>) => ReactNode;
+    /**
+     * The field DataTable reads tree children from, when rows carry nested
+     * data — `'subRows'` by default. Tree mode turns on by itself when some
+     * top-level row holds a non-empty array there: parent rows grow expander
+     * buttons in the first content column, expanded children render as
+     * indented rows (one `--haze-space-4` per depth level) in document
+     * order, and the `expanded` state keeps its TanStack semantics (keyed by
+     * row id — sub-row ids default to `parentId.index`, so pass `getRowId`
+     * for stable ids). Works with sorting, filtering, selection, pagination
+     * and `virtualized` (the expanded row model already yields the flat
+     * display order the window slices). Explicit `getRowCanExpand` /
+     * `renderExpandedRow` take priority — with either present, `subRows`
+     * data is not read at all.
+     */
+    subRowsKey?: string;
+    /**
+     * Column visibility state (TanStack `ColumnVisibilityState`): a map keyed by
+     * column id, `true` (or absent) meaning visible. Hidden columns drop
+     * from header, body and colgroup.
+     */
+    columnVisibility?: ControlOrValue<ColumnVisibilityState>;
+    /**
+     * Render the column-settings trigger opening a `DropdownMenu` of
+     * checkboxes — one per hideable column (`meta.hideable: false` pins a
+     * column out of the menu). With `pageSize` the trigger sits in the
+     * pagination row (pagination keeps the end edge); without it a toolbar
+     * row appears above the table's inline-end corner. Defaults to `false`.
+     */
+    columnToggle?: boolean;
+    /**
+     * Render a filter row directly below the header: one `Input` per
+     * filterable column, typing filters rows through TanStack's
+     * case-insensitive `includesString` (empty input clears the filter).
+     * Per-column `meta.filterable` (or native `enableColumnFilter`)
+     * overrides per column; a columnDef `filterFn` replaces the default
+     * filter function. Defaults to `false`.
+     */
+    filterable?: boolean;
+    /**
+     * 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
+     * selection column, when present, renders an empty cell first). Cell
+     * functions receive the rows being summarized — every row of the
+     * filtered data (all pages, tree sub-rows included), so totals stay
+     * stable across pagination; `label` names the row accessibly. Skipped
+     * while `loading` or when no rows render. When `virtualized`, the
+     * summary renders in its own table below the scrolling window — pinned
+     * by construction, `stickyFooter` is unnecessary there.
+     */
+    summary?: (rows: Row<typeof dataTableFeatures, TData>[]) => DataTableSummary<TData>[];
+    /**
+     * Keep the summary footer visible while the body scrolls vertically —
+     * the tfoot cells stick to the bottom of the scroll area (needs a
+     * height-bounded table: `stickyHeader`'s scroll area or a consumer
+     * `max-height`). No effect when `virtualized` (already pinned) or
+     * without `summary`. Defaults to `false`.
+     */
+    stickyFooter?: boolean;
+    /**
+     * Enable inline cell editing: cells become focusable and enter edit mode
+     * on double-click or Enter; the built-in editors (an `InputCore`) save
+     * on Enter or blur and cancel on Escape. The editor kind is chosen per
+     * column through `meta.editor` (`'text'` by default, `'number'` parses
+     * the draft — reporting `null` when cleared — a function renders a
+     * custom editor, `false` opts the column out). DataTable never mutates
+     * `data`: committed values are reported through `onCellEdit`, and the
+     * cell keeps rendering the current value until the consumer updates the
+     * data. Note `onRowClick` still fires for the clicks of a double-click.
+     */
+    editable?: boolean;
+    /**
+     * Reports a committed cell edit: the row id, the column id, the next
+     * value and the previous one. Called after Enter/blur/custom-editor
+     * saves, only when the value actually changed (`Object.is`). The
+     * consumer owns the data — update it to make the edit visible.
+     */
+    onCellEdit?: (rowId: string, columnId: string, nextValue: unknown, prevValue: unknown) => void;
     className?: string;
-} & Omit<ComponentPropsWithoutRef<'table'>, 'children'>;
-export default function DataTable<TData extends RowData>({ columns, data, sortable, selectable, rowSelection: rowSelectionControl, sorting: sortingControl, pageSize, page: pageControl, loading, stickyHeader, virtualized, getRowId, onRowClick, empty, className, ...rest }: DataTableProps<TData>): import("react").JSX.Element;
-export type { DataTableProps, DataTableColumnDef, DataTableColumnMeta, DataTableVirtualized, };
+} & 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, };

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

@@ -0,0 +1,36 @@
+import type { ColumnVisibilityState, RowData } from '@tanstack/react-table';
+import type { DataTableColumnDef } from './DataTable';
+/** Options for `dataTableToCsv`. */
+type DataTableCsvOptions = {
+    /**
+     * Prepend a UTF-8 byte-order mark (`\uFEFF`), default `true`. Excel
+     * sniffs the BOM to decode the file as UTF-8 — without it, CJK and
+     * other non-ASCII cell values come up mojibake in Excel's legacy
+     * default encoding. Turn it off when the consumer already handles
+     * encoding (or feeds the string to a parser that chokes on it).
+     */
+    bom?: boolean;
+    /**
+     * The table's column-visibility state (the `columnVisibility` control's
+     * value): columns hidden there are skipped, so the export mirrors what
+     * the table renders.
+     */
+    columnVisibility?: ColumnVisibilityState;
+};
+/**
+ * Serializes rows and column defs to a CSV string (RFC 4180: CRLF row
+ * separators, quoted fields around commas, quotes and embedded line
+ * breaks). The header row uses each column's string `header`, falling
+ * 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).
+ *
+ * Pure string building — no DOM, no table instance — so it runs anywhere
+ * the row data lives (client, worker, server) on the same `columns` array
+ * handed to DataTable.
+ */
+declare function dataTableToCsv<TData extends RowData>(rows: TData[], columns: DataTableColumnDef<TData>[], options?: DataTableCsvOptions): string;
+export { dataTableToCsv };
+export type { DataTableCsvOptions };

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

@@ -0,0 +1,124 @@
+import type { ReactNode } from 'react';
+/**
+ * Props handed to a custom cell editor (`meta.editor` as a function): the
+ * current cell value, the row and column (structural views of the TanStack
+ * objects), and the two exit channels. The editor is uncontrolled UI inside
+ * the cell — call `onSave` with the next value (routed to `onCellEdit`,
+ * which owns the data) or `onCancel` to leave the value untouched. After
+ * either, move focus yourself if needed (e.g. back onto the cell) —
+ * DataTable cannot know where a custom editor's focusables live.
+ */
+type DataTableCellEditorProps = {
+    /** Current cell value (`row.getValue(column.id)`), untyped. */
+    value: unknown;
+    /** Structural view of the TanStack row being edited. */
+    row: {
+        id: string;
+        index: number;
+        depth: number;
+        original: unknown;
+        getValue: (columnId: string) => unknown;
+    };
+    /** Structural view of the column being edited. */
+    column: {
+        id: string;
+    };
+    /** Exits edit mode and reports the next value through `onCellEdit`. */
+    onSave: (value: unknown) => void;
+    /** Exits edit mode leaving the value untouched. */
+    onCancel: () => void;
+};
+/** Per-column metadata understood by DataTable. */
+type DataTableColumnMeta = {
+    /** Column-level sorting switch — overrides the table-level `sortable` default. */
+    sortable?: boolean;
+    /**
+     * Column width, applied through a `<colgroup>` shared by every table in
+     * the layout: a number is px, strings pass through as CSS lengths
+     * (`'25%'`, `'12rem'`). Wins over the native TanStack `size` field, which
+     * is read as a px fallback. Columns without any width keep their previous
+     * sizing — content-driven in normal mode, an equal share of the remainder
+     * when `virtualized`.
+     */
+    width?: number | string;
+    /**
+     * Pin the column to the scroll area's left/right edge so it stays visible
+     * while the table scrolls horizontally. Normal mode only — ignored when
+     * `virtualized`, where each row is its own table with no shared
+     * scrollport. The sticky offset sums the widths of the preceding fixed
+     * columns on the same side, starting from the selection column, so fixed
+     * columns should declare numeric px widths; non-numeric widths contribute
+     * nothing to the offset math. Honored on leaf columns.
+     */
+    fixed?: 'left' | 'right';
+    /**
+     * Column-level resizing switch — overrides the table-level `resizable`
+     * default (`false` hides this column's handle when the table is
+     * resizable; `true` is the per-column default). The native TanStack
+     * `enableResizing` field wins over this.
+     */
+    resizable?: boolean;
+    /**
+     * `false` pins the column in the visibility menu — it renders without a
+     * toggle and can never be hidden. The native TanStack `enableHiding`
+     * field wins over this.
+     */
+    hideable?: boolean;
+    /**
+     * Column-level filtering switch — overrides the table-level `filterable`
+     * default, deciding whether the filter row renders an input for this
+     * column. The native TanStack `enableColumnFilter` field wins over this.
+     */
+    filterable?: boolean;
+    /**
+     * `true` keeps the column out of `dataTableToCsv` exports — the flag for
+     * columns whose cells are presentation-only (badges, action buttons) or
+     * internal (row ids) and meaningless in a spreadsheet.
+     */
+    excludeFromExport?: boolean;
+    /**
+     * Cell editor for this column while the table-level `editable` switch is
+     * on. `'text'` and `'number'` render the built-in inline editor (an
+     * `InputCore`; the number variant parses the draft on save and reports
+     * `null` when cleared); a function renders a fully custom editor through
+     * `DataTableCellEditorProps`; `false` opts the column out. Defaults to
+     * `'text'` — every column is editable unless switched off here.
+     */
+    editor?: false | 'text' | 'number' | ((props: DataTableCellEditorProps) => ReactNode);
+};
+/**
+ * The feature set stitched into every DataTable instance — TanStack v9's
+ * tree-shaking contract: only the row models and registries the component
+ * 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
+ * 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
+ * feature's `size: 150` column-def default is neutralized through
+ * `defaultColumn` (see there). */
+declare const dataTableFeatures: {
+    rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+    paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+    rowSortingFeature: import("@tanstack/react-table").TableFeature;
+    sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    sortFns: {
+        alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+        text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    };
+    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;
+    columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+    filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+    filterFns: {
+        includesString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    };
+    columnSizingFeature: import("@tanstack/react-table").TableFeature;
+    columnResizingFeature: import("@tanstack/react-table").TableFeature;
+    columnMeta: DataTableColumnMeta;
+};
+export { dataTableFeatures };
+export type { DataTableCellEditorProps, DataTableColumnMeta };

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

@@ -1,2 +1,5 @@
 export { default as DataTable } from './DataTable';
-export type { DataTableProps, DataTableColumnDef, DataTableColumnMeta, DataTableVirtualized, } from './DataTable';
+export type { DataTableProps, DataTableColumnDef, DataTableColumnMeta, DataTableVirtualized, DataTableSummary, DataTableSummaryCell, DataTableCellEditorProps, } from './DataTable';
+export { dataTableToCsv } from './csv';
+export type { DataTableCsvOptions } from './csv';
+export { dataTableSum, dataTableAvg, dataTableCount } from './summary';

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

@@ -0,0 +1,19 @@
+import type { Row, RowData } from '@tanstack/react-table';
+import type { dataTableFeatures } from './features';
+/** A row as DataTable hands it to the `summary` callback and editors. */
+type DataTableRow<TData extends RowData> = Row<typeof dataTableFeatures, TData>;
+/**
+ * Sums the numeric values of one column across the given rows (the array
+ * `summary` receives). Non-numeric and missing cells contribute nothing,
+ * so string columns simply total `0`.
+ */
+export declare function dataTableSum<TData extends RowData>(rows: DataTableRow<TData>[], columnId: string): number;
+/**
+ * Averages the numeric values of one column across the given rows.
+ * Non-numeric cells are excluded from both the total and the divisor;
+ * with no numeric values at all the result is `undefined`.
+ */
+export declare function dataTableAvg<TData extends RowData>(rows: DataTableRow<TData>[], columnId: string): number | undefined;
+/** Counts the given rows — the summary helper for non-numeric columns. */
+export declare function dataTableCount<TData extends RowData>(rows: DataTableRow<TData>[]): number;
+export {};

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

@@ -1,12 +1,38 @@
 import type { ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { DateRangePickerPreset } from './DateRangePickerCore';
+/**
+ * Shortcut rows for the range panel: `'common'` selects the built-in
+ * set (today / yesterday / last 7 days / last 30 days / this month /
+ * last month, localized by the LocaleProvider), plain objects are
+ * custom rows, and an array may mix both — `'common'` inside an array
+ * splices the built-ins in at that position, so customs append after
+ * them as `['common', { label, range }]`.
+ */
+type DateRangePickerPresets = 'common' | readonly ('common' | DateRangePickerPreset)[];
 type DateRangePickerProps = {
     startDate?: ControlOrValue<string>;
     endDate?: ControlOrValue<string>;
     onStartChange?: (value: string) => void;
     onEndChange?: (value: string) => void;
     separator?: ReactNode;
+    /**
+     * Number of month grids in the range panel. `2` renders an inline
+     * dual-month calendar below the inputs for visual range picking
+     * (first pick sets the start, second completes the range).
+     * @default 1
+     */
+    months?: 1 | 2;
+    /** Disables individual dates on the panel's Calendar (see Calendar's
+     * `disabledDate`). */
+    disabledDate?: (date: Date) => boolean;
+    /** Shortcut rows at the top of the panel; clicking applies the
+     * preset's range to the start/end pair. `'common'` enables the
+     * built-in set; a custom array lists its own rows and may include
+     * `'common'` to prepend the built-ins (see
+     * {@link DateRangePickerPresets}). */
+    presets?: DateRangePickerPresets;
     className?: string;
 };
-export default function DateRangePicker({ startDate: startDateControl, endDate: endDateControl, onStartChange, onEndChange, separator, className, }: DateRangePickerProps): import("react").JSX.Element;
-export type { DateRangePickerProps };
+export default function DateRangePicker({ startDate: startDateControl, endDate: endDateControl, onStartChange, onEndChange, separator, months, disabledDate, presets, className, }: DateRangePickerProps): import("react").JSX.Element;
+export type { DateRangePickerProps, DateRangePickerPresets };

package/dist/types/components/DateRangePicker/DateRangePickerCore.d.ts

@@ -1,11 +1,35 @@
 import type { ReactNode } from 'react';
+/** One shortcut row at the top of the range panel: clicking applies
+ * `range` as the start/end pair. */
+type DateRangePickerPreset = {
+    /** Visible row copy. */
+    label: string;
+    /** Applied range as two "YYYY-MM-DD" strings. */
+    range: [string, string];
+};
 type DateRangePickerCoreProps = {
     startDate: string;
     endDate: string;
     onStartChange: (value: string) => void;
     onEndChange: (value: string) => void;
     separator?: ReactNode;
+    /**
+     * Number of month grids in the range panel. `2` renders an inline
+     * dual-month calendar below the inputs: the first pick sets the start
+     * date, the second completes the range (a pick before the start
+     * restarts it), and the two grids move together under one navigation.
+     * The default keeps the plain two-input layout.
+     * @default 1
+     */
+    months?: 1 | 2;
+    /** Disables individual dates on the panel's Calendar (see Calendar's
+     * `disabledDate`). */
+    disabledDate?: (date: Date) => boolean;
+    /** Shortcut rows at the top of the panel; clicking applies the
+     * preset's range to the start/end pair. Providing presets renders
+     * the inline panel even with the default `months={1}`. */
+    presets?: DateRangePickerPreset[];
     className?: string;
 };
-export default function DateRangePickerCore({ startDate, endDate, onStartChange, onEndChange, separator, className, }: DateRangePickerCoreProps): import("react").JSX.Element;
-export type { DateRangePickerCoreProps };
+export default function DateRangePickerCore({ startDate, endDate, onStartChange, onEndChange, separator, months, disabledDate, presets, className, }: DateRangePickerCoreProps): import("react").JSX.Element;
+export type { DateRangePickerCoreProps, DateRangePickerPreset };

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

@@ -1,4 +1,4 @@
 export { default as DateRangePicker } from './DateRangePicker';
-export type { DateRangePickerProps } from './DateRangePicker';
+export type { DateRangePickerProps, DateRangePickerPresets } from './DateRangePicker';
 export { default as DateRangePickerCore } from './DateRangePickerCore';
-export type { DateRangePickerCoreProps } from './DateRangePickerCore';
+export type { DateRangePickerCoreProps, DateRangePickerPreset } from './DateRangePickerCore';

package/dist/types/components/DateRangePicker/presets.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in range presets for DateRangePicker's `presets='common'` set.
+ *
+ * Date arithmetic follows Calendar/date.ts semantics: every value is a
+ * local civil date realized at midnight (`new Date(year, month, day)`),
+ * and day shifts ride the Date constructor's day-rollover — DST never
+ * moves midnight, so a shifted local midnight always round-trips its
+ * civil date.
+ */
+import type { DateRangePickerPreset } from './DateRangePickerCore';
+/** Localized labels for the built-in rows (LocaleProvider's
+ * `dateRangePicker` section). */
+type CommonPresetLabels = {
+    today: string;
+    yesterday: string;
+    last7Days: string;
+    last30Days: string;
+    thisMonth: string;
+    lastMonth: string;
+};
+/** The built-in shortcut rows relative to `today` (defaults to now). */
+export declare function commonRangePresets(labels: CommonPresetLabels, today?: Date): DateRangePickerPreset[];
+export {};