prime-ui-kit 0.18.0 → 0.20.0

package/dist/color-picker.js

@@ -4,8 +4,8 @@ import {
   ColorField,
   ColorPicker,
   parseColor
-} from "./chunks/chunk-X3JT5CLR.js";
-import "./chunks/chunk-OAXJWF3L.js";
+} from "./chunks/chunk-4KONMO7Z.js";
+import "./chunks/chunk-3PY52JP3.js";
 import "./chunks/chunk-QFHE5GKW.js";
 export {
   ColorField,

package/dist/components/data-table/ColumnsMenu.d.ts

@@ -1,23 +1,45 @@
 import * as React from "react";
-import type { PositionAlign, PositionSide } from "../../hooks/usePosition";
-export type DataTableColumnsMenuProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "children"> & {
-    /**
-     * Side of the trigger the menu opens on.
-     */
-    side?: PositionSide;
+import type { ControlSize } from "../../internal/states";
+import type { DataTableLabels } from "./DataTable";
+import type { DataTableColumn } from "./types";
+type Column = DataTableColumn<never>;
+/** The strings of the column chooser, in the table's `labels` and in `DataTableColumnsMenu`. */
+export type DataTableColumnsMenuLabels = Pick<DataTableLabels, "columns" | "showColumns" | "showAllColumns" | "resetColumnOrder" | "reorderColumn">;
+/** The chooser reorders columns too (`columnOrder`). */
+export type ColumnsMenuReorder = {
+    /** Columns that hold their place: a lock instead of the grip. */
+    locked: ReadonlySet<string>;
+    onReorder: (id: string, beforeId: string | null) => void;
+    /** Back to the order of `columns`; null while that is the order. */
+    reset: (() => void) | null;
+};
+type ColumnsMenuProps = {
+    /** Every column, hidden ones included, in table order. */
+    columns: Column[];
+    hidden: ReadonlySet<string>;
+    setHidden: (hidden: string[]) => void;
+    reorder: ColumnsMenuReorder | null;
+    labels: DataTableColumnsMenuLabels;
+    /** The tier of the trigger and the menu. */
+    size: ControlSize;
     /**
-     * Alignment to the trigger. `auto` lines the panel up with the trigger edge that has more room beyond it; `start`, `center` or `end` fix it.
+     * `icon`: the icon-only ghost trigger in the head of the row-actions column (`columnsMenu`);
+     * `button`: the labelled soft trigger with the count of shown columns, for the page's tools.
      */
-    align?: PositionAlign;
-    /** The trigger button. */
-    ref?: React.Ref<HTMLButtonElement>;
+    trigger: "icon" | "button";
+    /** The labelled trigger's own attributes, class and ref (`DataTableColumnsMenu`). */
+    triggerProps?: React.ButtonHTMLAttributes<HTMLButtonElement> & {
+        ref?: React.Ref<HTMLButtonElement>;
+    };
 };
+/** Columns that hold their place in the chooser: `reorderable: false` and the row actions. */
+export declare function lockedInChooser(columns: readonly Column[]): Set<string>;
 /**
- * The column chooser of the table it sits in (put it into `toolbar`): a trigger button and a menu
- * with a check item per column and «Показать все». Writes the table's `hiddenColumns`; a column
- * with `hideable: false` stays checked and disabled, and the last visible column cannot be hidden.
+ * The column chooser: a trigger (`trigger`) opening a Dropdown with a «Показывать» group of check
+ * items, one per column, and «Показать все». A column with `hideable: false` stays checked and
+ * disabled, and the last visible column cannot be hidden. With `reorder` the items are a
+ * Dnd.Sortable list: a grip ends each item (a lock on a column that holds its place), Alt + ↑ / ↓ on
+ * the focused item moves it, and «Исходный порядок» puts the order of `columns` back.
  */
-export declare function DataTableColumnsMenu({ side, align, ...rest }: DataTableColumnsMenuProps): import("react/jsx-runtime").JSX.Element;
-export declare namespace DataTableColumnsMenu {
-    var displayName: string;
-}
+export declare function ColumnsMenu({ columns, hidden, setHidden, reorder, labels, size, trigger, triggerProps, }: ColumnsMenuProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/DataTable.d.ts

@@ -1,8 +1,6 @@
 import * as React from "react";
 import { type ControlSize } from "../../internal/states";
-import { DataTableColumnsMenu } from "./ColumnsMenu";
 import type { DataTableColumn, DataTableGroup, DataTableRowClickEvent, DataTableSortState } from "./types";
-export type { DataTableColumnsMenuProps } from "./ColumnsMenu";
 export type { DataTableColumn, DataTableGroup, DataTableOrder, DataTableRowClickEvent, DataTableSortState, } from "./types";
 /** System strings; `{from}`, `{to}`, `{total}`, `{label}`, `{count}`, `{group}` are replaced. */
 export type DataTableLabels = {
@@ -26,10 +24,16 @@ export type DataTableLabels = {
     expand: string;
     /** `aria-label` of the expand toggle of an expanded row. */
     collapse: string;
-    /** Text of the `DataTable.ColumnsMenu` trigger; `{shown}` and `{total}` are column counts. */
+    /** Name and tooltip of the column chooser (`columnsMenu`); `{shown}` and `{total}` are counts. */
     columns: string;
-    /** The `DataTable.ColumnsMenu` item that shows every column again. */
+    /** The heading of the column chooser's list of columns. */
+    showColumns: string;
+    /** The column chooser item that shows every column again. */
     showAllColumns: string;
+    /** The column chooser item that puts the order of `columns` back (`columnOrder`). */
+    resetColumnOrder: string;
+    /** `aria-label` of a column's grip in the column chooser (`columnOrder`); `{label}` is its header. */
+    reorderColumn: string;
     /** `aria-label` of a row's drag handle (`onReorder`); `{label}` is `getRowLabel(row)`. */
     reorderRow: string;
     /** Tooltip of the handles while the table is sorted by a column (reordering is off). */
@@ -50,7 +54,7 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      */
     columns: DataTableColumn<Row>[];
     /**
-     * Ids of columns that are not rendered, controlled. A column with `hideable: false` stays. `DataTable.ColumnsMenu` in `toolbar` changes it.
+     * Ids of columns that are not rendered, controlled. A column with `hideable: false` stays. The column chooser (`columnsMenu`, `DataTableColumnsMenu`) changes it.
      */
     hiddenColumns?: string[];
     /**
@@ -58,9 +62,25 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      */
     defaultHiddenColumns?: string[];
     /**
-     * The hidden ids changed (`DataTable.ColumnsMenu`). The kit stores nothing: keep the list (local storage, the user's settings) and pass it back to restore the choice.
+     * The hidden ids changed (`columnsMenu`). The kit stores nothing: keep the list (local storage, the user's settings) and pass it back to restore the choice.
      */
     onHiddenColumnsChange?: (hiddenColumns: string[]) => void;
+    /**
+     * Column ids in screen order, hidden ones keeping their place, controlled. Any prop of this triad makes columns reorder: a header drag (the body stays until the drop), Alt + ← / → on a header, grips in the column chooser.
+     */
+    columnOrder?: string[];
+    /**
+     * Initial column order, uncontrolled; `[]` — the order of `columns`, reorderable.
+     */
+    defaultColumnOrder?: string[];
+    /**
+     * The order changed: a header dropped, a keyboard move, a chooser grip or «Исходный порядок». The kit stores nothing: keep it with `hiddenColumns` and pass it back.
+     */
+    onColumnOrderChange?: (columnOrder: string[]) => void;
+    /**
+     * The column chooser in the head of the row-actions column (the last one, `hideHeader`); reorders with `columnOrder`. Without that column it renders nothing and warns: use `DataTableColumnsMenu` in the page's tools.
+     */
+    columnsMenu?: boolean;
     /**
      * Data; sorted in memory when a sort is set. With `source="server"` — the page (or the loaded batches) as the server returned it.
      */
@@ -93,6 +113,10 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      * The first visible column (with the selection and toggle columns) sticks while scrolling sideways; the start edge shadow falls from its end edge.
      */
     stickyFirstColumn?: boolean;
+    /**
+     * The last visible column (row actions) sticks to the end edge while scrolling sideways; the end edge shadow falls from its start edge.
+     */
+    stickyLastColumn?: boolean;
     /**
      * Stable row id (position by default; sub-rows too, `index` among siblings); selection, expansion and the enter animation of new rows are keyed by it. Pass it whenever sorting, selection or expansion is used.
      */
@@ -218,9 +242,13 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      */
     onSelectedChange?: (selected: React.Key[]) => void;
     /**
-     * Rows reorder by a leading handle column. Row `id` goes in front of `beforeId` (`null` = last); apply it with `moveBefore`, return a promise to save. Off while sorted by a column.
+     * Rows reorder (by a grip, see `reorderHandle`). Row `id` goes in front of `beforeId` (`null` = last); apply it with `moveBefore`, return a promise to save. Off while sorted by a column.
      */
     onReorder?: (id: React.Key, beforeId: React.Key | null) => void | Promise<void>;
+    /**
+     * Where a row is picked up (`onReorder`): `end` — a grip ends the row; `start` — a grip column leads it; `row` — no grip, the whole row is carried and takes Alt + ↑ / ↓ itself.
+     */
+    reorderHandle?: "start" | "end" | "row";
     /**
      * Sub-rows rendered under the parent with the same columns, indented by depth.
      */
@@ -254,9 +282,13 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      */
     loadingRows?: number;
     /**
-     * Panel above the table (search, filters, bulk actions); stacks below 30rem of table width.
+     * The table's own tools row — search, filter, `DataTableColumnsMenu`, a view, bulk actions; two or more, unwrapped. Laid out as `Page.Tools`: the search takes the free room, the rest keep their width at the end.
      */
     toolbar?: React.ReactNode;
+    /**
+     * The applied filters (`SmartFilter.Chips`) on a line under the `toolbar`, gone while empty; `SmartFilter.Root` wraps the DataTable.
+     */
+    toolbarChips?: React.ReactNode;
     /**
      * Group key of a row: each group gets a header row and its own `<tbody>`. Groups keep the order in which they first appear in `rows`; a sort orders the rows inside each group; a group split by paging repeats its header.
      */
@@ -282,7 +314,4 @@ export type DataTableProps<Row> = Omit<React.HTMLAttributes<HTMLDivElement>, "ch
      */
     onCollapsedGroupsChange?: (collapsedGroups: (string | number)[]) => void;
 };
-export declare function DataTable<Row>({ columns: allColumns, hiddenColumns, defaultHiddenColumns, onHiddenColumnsChange, rows, source, rowCount, size: sizeProp, className, showHeader, stickyHeader, stickyFirstColumn, getRowKey, getRowHref, onRowClick, isRowClickable, loading, empty, labels: labelsProp, rowDividers, columnDividers, sort, defaultSort, onSortChange, paging, page, defaultPage, onPageChange, pageSize, infiniteBatchSize, hasMore, loadingMore, onLoadMore, scrollHeight, fullWidth, highlightRowOnHover, highlightColumnOnHover, striped, getRowLabel, selectable, selected, defaultSelected, onSelectedChange, onReorder, getRowChildren, renderExpanded, isRowExpandable, expanded, defaultExpanded, onExpandedChange, loadError, loadingRows, toolbar, getRowGroup, renderGroupHeader, stickyGroupHeaders, collapsedGroups, defaultCollapsedGroups, onCollapsedGroupsChange, ref, ...rest }: DataTableProps<Row>): import("react/jsx-runtime").JSX.Element;
-export declare namespace DataTable {
-    var ColumnsMenu: typeof DataTableColumnsMenu;
-}
+export declare function DataTable<Row>({ columns: allColumns, hiddenColumns, defaultHiddenColumns, onHiddenColumnsChange, columnOrder, defaultColumnOrder, onColumnOrderChange, columnsMenu, rows, source, rowCount, size: sizeProp, className, showHeader, stickyHeader, stickyFirstColumn, stickyLastColumn, getRowKey, getRowHref, onRowClick, isRowClickable, loading, empty, labels: labelsProp, rowDividers, columnDividers, sort, defaultSort, onSortChange, paging, page, defaultPage, onPageChange, pageSize, infiniteBatchSize, hasMore, loadingMore, onLoadMore, scrollHeight, fullWidth, highlightRowOnHover, highlightColumnOnHover, striped, getRowLabel, selectable, selected, defaultSelected, onSelectedChange, onReorder, reorderHandle, getRowChildren, renderExpanded, isRowExpandable, expanded, defaultExpanded, onExpandedChange, loadError, loadingRows, toolbar, toolbarChips, getRowGroup, renderGroupHeader, stickyGroupHeaders, collapsedGroups, defaultCollapsedGroups, onCollapsedGroupsChange, ref, ...rest }: DataTableProps<Row>): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/DataTableColumnsMenu.d.ts

@@ -0,0 +1,45 @@
+import * as React from "react";
+import type { ControlSize } from "../../internal/states";
+import { type DataTableColumnsMenuLabels } from "./ColumnsMenu";
+import type { DataTableColumn } from "./types";
+export type { DataTableColumnsMenuLabels } from "./ColumnsMenu";
+export type DataTableColumnsMenuProps<Row> = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children" | "type"> & {
+    /**
+     * The table's `columns`, in the order of the code.
+     */
+    columns: DataTableColumn<Row>[];
+    /**
+     * The ids the table hides: the same list its `hiddenColumns` reads.
+     */
+    hiddenColumns: string[];
+    /**
+     * A column was shown or hidden, or «Показать все».
+     */
+    onHiddenColumnsChange: (hiddenColumns: string[]) => void;
+    /**
+     * The table's `columnOrder`.
+     */
+    columnOrder?: string[];
+    /**
+     * Turns the items into a sortable list (a grip, Alt + ↑ / ↓) with «Исходный порядок»; the new order of every column.
+     */
+    onColumnOrderChange?: (columnOrder: string[]) => void;
+    /**
+     * Tier of the trigger and the menu.
+     */
+    size?: ControlSize;
+    /**
+     * The chooser's strings: `columns`, `showColumns`, `showAllColumns`, `resetColumnOrder`, `reorderColumn`.
+     */
+    labels?: Partial<DataTableColumnsMenuLabels>;
+    ref?: React.Ref<HTMLButtonElement>;
+};
+/**
+ * The column chooser of a DataTable that has no row-actions column to hold it: a labelled soft
+ * Button with the count of shown columns, for the page's tools, bound to the same state the table
+ * reads (`hiddenColumns`, and `columnOrder` when the columns reorder).
+ */
+export declare function DataTableColumnsMenu<Row>({ columns, hiddenColumns, onHiddenColumnsChange, columnOrder, onColumnOrderChange, size: sizeProp, labels: labelsProp, ...triggerProps }: DataTableColumnsMenuProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare namespace DataTableColumnsMenu {
+    var displayName: string;
+}

package/dist/components/data-table/Head.d.ts

@@ -1,20 +1,33 @@
+import * as React from "react";
 import type { ControlSize } from "../../internal/states";
 import type { DataTableColumn, DataTableSortState } from "./types";
+/** Columns that reorder by their headers (`columnOrder`): the head row is a `Dnd.Sortable`. */
+export type HeadColumnReorder = {
+    /** Columns that hold their place: their headers carry nothing, no column moves past them. */
+    locked: ReadonlySet<string>;
+    onReorder: (id: string, beforeId: string | null) => void;
+};
 type HeadProps<Row> = {
     columns: DataTableColumn<Row>[];
     size: ControlSize;
     sort: DataTableSortState;
     onSort: (columnId: string) => void;
     stickyFirstColumn: boolean;
+    /** The last visible column sticks to the end edge (with `stickyHeader`: the end corner). */
+    stickyLastColumn: boolean;
     /** The head sticks to the top of the scroller. */
     stickyHeader: boolean;
-    /** Sticky head and first column: the leading head cells stick to both edges. */
-    stickyCorner: boolean;
     expandEnabled: boolean;
     /** Name of the info glyph of a column with a `description`. */
     infoLabel: string;
-    /** A leading column of row handles (`onReorder`). */
-    reorderable?: boolean;
+    /** A leading column of row grips (`reorderHandle="start"`). */
+    gripStart: boolean;
+    /** The column chooser trigger (`columnsMenu`) for the row-actions head cell, or null. */
+    columnsMenu: React.ReactNode;
+    /** A trailing utility cell ends the row: the head of the end grips' column. */
+    endCell: boolean;
+    /** Header grips (`columnOrder`); null when columns keep their order. */
+    reorder: HeadColumnReorder | null;
     selectAll?: {
         checked: boolean;
         indeterminate: boolean;
@@ -23,5 +36,5 @@ type HeadProps<Row> = {
         onToggle: () => void;
     };
 };
-export declare function Head<Row>({ columns, size, sort, onSort, stickyFirstColumn, stickyHeader, stickyCorner, expandEnabled, infoLabel, reorderable, selectAll, }: HeadProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare function Head<Row>({ columns, size, sort, onSort, stickyFirstColumn, stickyLastColumn, stickyHeader, expandEnabled, infoLabel, gripStart, columnsMenu, endCell, reorder, selectAll, }: HeadProps<Row>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/Row.d.ts

@@ -15,6 +15,10 @@ export type RowShared<Row> = {
     selectable: boolean;
     expandEnabled: boolean;
     stickyFirstColumn: boolean;
+    /** The last visible column sticks to the end edge (row actions). */
+    stickyLastColumn: boolean;
+    /** A trailing utility cell ends every row: the row grip (`reorderHandle="end"`). */
+    endCell: boolean;
     striped: boolean;
     totalColumns: number;
     /**
@@ -29,7 +33,7 @@ export type RowShared<Row> = {
     scaleDomains: Map<string, [number, number]>;
     selection: RowSelectionHandlers;
     toggleExpanded: (key: React.Key) => void;
-    /** Row reordering (`onReorder`): a handle column and sortable rows; null without it. */
+    /** Row reordering (`onReorder`): sortable rows with a grip cell or a row grip; null without it. */
     reorder: RowReorderShared | null;
 };
 type DataTableRowProps<Row> = {
@@ -91,12 +95,14 @@ type MeasureBodyProps<Row> = {
     columns: DataTableColumn<Row>[];
     selectable: boolean;
     expandEnabled: boolean;
-    /** A leading column of row handles (`onReorder`). */
-    reorderable: boolean;
+    /** A leading column of row grips (`reorderHandle="start"`). */
+    gripStart: boolean;
+    /** A trailing utility cell (the end grip, the column chooser). */
+    endCell: boolean;
 };
 /**
  * Sub-rows of collapsed rows and rows of collapsed groups, laid out invisibly so the columns are
  * already as wide as they will be once a row or group opens; never shown or reachable.
  */
-export declare function MeasureBody<Row>({ rows, columns, selectable, expandEnabled, reorderable, }: MeasureBodyProps<Row>): import("react/jsx-runtime").JSX.Element;
+export declare function MeasureBody<Row>({ rows, columns, selectable, expandEnabled, gripStart, endCell, }: MeasureBodyProps<Row>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/StateRows.d.ts

@@ -8,8 +8,10 @@ type StateRowsProps<Row> = {
     totalColumns: number;
     selectable: boolean;
     expandEnabled: boolean;
-    /** A leading column of row handles (`onReorder`). */
-    reorderable?: boolean;
+    /** A leading column of row grips (`reorderHandle="start"`). */
+    gripStart: boolean;
+    /** A trailing utility cell (the end grip, the column chooser). */
+    endCell: boolean;
     loadError: React.ReactNode;
     empty: React.ReactNode;
     emptyLabel: string;
@@ -20,5 +22,5 @@ type StateRowsProps<Row> = {
  * in a sticky box of the visible width, so a wide table centres it in the viewport, not across
  * every column.
  */
-export declare function StateRows<Row>({ state, columns, size, totalColumns, selectable, expandEnabled, reorderable, loadError, empty, emptyLabel, skeletonRows, }: StateRowsProps<Row>): import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
+export declare function StateRows<Row>({ state, columns, size, totalColumns, selectable, expandEnabled, gripStart, endCell, loadError, empty, emptyLabel, skeletonRows, }: StateRowsProps<Row>): import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
 export {};

package/dist/components/data-table/columnOrder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `columns` in the order of `order`. An id `order` does not list (a column added to the code later)
+ * stands right after the column that precedes it in `columns`, so a saved order never hides it;
+ * ids of columns that are gone are skipped.
+ */
+export declare function orderColumns<C extends {
+    id: string;
+}>(columns: readonly C[], order: readonly string[]): C[];
+/**
+ * The order of every column (hidden ones too) once the visible column `id` stands in front of the
+ * visible column `before` — or right after the last visible one when `before` is null, so a hidden
+ * column after it keeps its slot; `null` when that would shift a column that holds its place.
+ */
+export declare function placeColumn(order: readonly string[], visible: readonly string[], id: string, before: string | null, locked: ReadonlySet<string>): string[] | null;

package/dist/components/data-table/reorder.d.ts

@@ -2,6 +2,8 @@ import * as React from "react";
 import type { FlatRow } from "./rows";
 /** What every row needs to know about reordering (part of the rows' shared props). */
 export type RowReorderShared = {
+    /** Where a row is picked up: a grip cell leading or ending it, or the row itself. */
+    handle: "start" | "end" | "row";
     /** The table is sorted by a column: the manual order is not what is on screen. */
     locked: boolean;
     /** `aria-label` of a row's handle; `{label}` is `getRowLabel(row)`. */
@@ -14,6 +16,8 @@ type Entry<Row> = {
     index: number;
 };
 export type RowReorderOptions<Row> = {
+    /** `reorderHandle`: a grip cell at the start or the end of a row, or the whole row. */
+    handle: "start" | "end" | "row";
     onReorder: ((id: React.Key, beforeId: React.Key | null) => void | Promise<void>) | undefined;
     /** Expandable rows (sub-rows, detail panels) do not reorder: a row would leave its children. */
     expandEnabled: boolean;
@@ -47,6 +51,8 @@ type ReorderBodyProps<Row> = {
     entries: Entry<Row>[];
     /** First index of the run among the rows on screen. */
     start: number;
+    /** Only a row's grip picks it up (`reorderHandle` `start` / `end`); else the whole row. */
+    handle: boolean;
     locked: boolean;
     onReorder: (id: string, beforeId: string | null) => void | Promise<void>;
     getRowLabel: ((row: Row) => string) | undefined;
@@ -55,8 +61,11 @@ type ReorderBodyProps<Row> = {
     header?: React.ReactNode;
     className?: string | undefined;
 };
-/** A `<tbody>` whose rows reorder: Dnd's sortable list in its table-rows mode, by the handle only. */
-export declare function ReorderBody<Row>({ entries, start, locked, onReorder, getRowLabel, renderRow, header, className, }: ReorderBodyProps<Row>): import("react/jsx-runtime").JSX.Element;
+/**
+ * A `<tbody>` whose rows reorder: Dnd's sortable list in its table-rows mode, by the grip only, or
+ * by the whole row (`reorderHandle="row"`: the row is the keyboard target and the drag source).
+ */
+export declare function ReorderBody<Row>({ entries, start, handle, locked, onReorder, getRowLabel, renderRow, header, className, }: ReorderBodyProps<Row>): import("react/jsx-runtime").JSX.Element;
 /** The drag session the rows need; it joins one the app already has above the table. */
 export declare function ReorderRoot({ enabled, children, }: {
     enabled: boolean;
@@ -72,7 +81,7 @@ type RowElementProps = Omit<React.ComponentProps<"tr">, "ref"> & {
  * A body row's `<tr>`; in a reorderable table, a sortable item rendered as that `<tr>` (it needs no
  * DOM id: only expandable rows are pointed at, and those do not reorder).
  */
-export declare function RowElement({ reorder, rowKey, rowRef, id, children, ...rest }: RowElementProps): import("react/jsx-runtime").JSX.Element;
+export declare function RowElement({ reorder, rowKey, rowRef, id, tabIndex, children, ...rest }: RowElementProps): import("react/jsx-runtime").JSX.Element;
 type HandleCellProps = {
     reorder: RowReorderShared;
     rowLabel: string | undefined;
@@ -81,8 +90,9 @@ type HandleCellProps = {
     wrap?: (node: React.ReactNode) => React.ReactNode;
 };
 /**
- * The leading cell of a reorderable row: the grip (Alt + ↑ / ↓ from the keyboard; busy while the
- * owner saves this row's move) and, while the table is sorted, a disabled grip that says why.
+ * The grip cell of a reorderable row, leading or ending it (`reorderHandle`): the grip (Alt + ↑ / ↓
+ * from the keyboard; busy while the owner saves this row's move) and, while the table is sorted, a
+ * disabled grip that says why.
  */
 export declare function ReorderHandleCell({ reorder, rowLabel, className, wrap }: HandleCellProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/types.d.ts

@@ -54,6 +54,11 @@ export type DataTableColumn<Row> = {
      * key column that names the row — it stays even when its id is listed.
      */
     hideable?: boolean;
+    /**
+     * The column can move when columns reorder (`columnOrder`). Default `true`; `false` holds its
+     * place: it never moves and no column moves past it.
+     */
+    reorderable?: boolean;
     /**
      * Heatmap: each cell is shaded by its numeric value (`sortAccessor`, else `accessor`) on the
      * five-step chart scale (`--prime-color-chart-scale-1…5`); the value itself stays in the cell.

package/dist/components/data-table/useFrozenColumns.d.ts

@@ -8,8 +8,12 @@ import * as React from "react";
  * (`col[data-grow]`) keep taking the free width.
  */
 export declare function useFrozenColumns(tableRef: React.RefObject<HTMLTableElement | null>, rootRef: React.RefObject<HTMLDivElement | null>, 
-/** Changes with the column set: widths start from scratch. */
-columnsKey: string, 
+/**
+ * One key per `<col>`, in order. A new set of columns starts the widths from scratch; the same
+ * set in another order (columns that changed places, a carried column's gap) keeps every
+ * column's width and only moves it, so nothing reflows while columns reorder.
+ */
+slots: readonly string[], 
 /** Changes with the rendered rows: widths widen when content no longer fits. */
 rowsKey: unknown, 
 /** Real rows are on screen (not loading, empty or error). */

package/dist/components/datepicker/DatepickerPanel.d.ts

@@ -39,7 +39,7 @@ export type CalendarOptions = {
      */
     months?: 1 | 2;
     /**
-     * Preset column (`range` only): `DEFAULT_DATEPICKER_PRESETS` or picks from `datepickerPresets`; a row above the calendar when narrow.
+     * Preset column (`range` only): `DEFAULT_DATEPICKER_PRESETS` (ends with «Всё время») or picks from `datepickerPresets`; a row above the calendar when narrow.
      */
     presets?: DatepickerPreset[] | false;
     /**

package/dist/components/dnd/Dnd.d.ts

@@ -108,15 +108,15 @@ export type DndSortableProps<T> = Omit<React.HTMLAttributes<HTMLElement>, "child
      */
     empty?: React.ReactNode;
     /**
-     * Root element; `ul` / `ol` render items as `li`, `tbody` as table rows `tr` (the gap is a row across every column, the carried copy keeps every cell's width).
+     * Root element; `ul` / `ol` render items as `li`, `tbody` as rows `tr` (a gap row, a one-row copy), `tr` as head cells `th` with `axis="x"` (cells keep their columns, the gap glides among them).
      */
-    as?: "div" | "ul" | "ol" | "tbody";
+    as?: "div" | "ul" | "ol" | "tbody" | "tr";
     /**
      * Accessible name of the list.
      */
     "aria-label"?: string;
     /**
-     * Content in front of the items that never moves and takes no drop position: the heading row of a group in a `tbody`.
+     * Content in front of the items that never moves and takes no drop position: the heading row of a group in a `tbody`, the leading cells of a head row.
      */
     header?: React.ReactNode;
     /**
@@ -146,6 +146,10 @@ export type DndSortableItemProps = {
      * Holds its place: it does not move and nothing is put where it would shift it. Its `Dnd.Handle` turns into a lock. A pinned first row, a system column.
      */
     locked?: boolean;
+    /**
+     * Without `handle`: a press on a control inside picks the item up too once it travels (a finger: holds); a click stays the control's. A table header whose sort button fills it.
+     */
+    dragFromControls?: boolean;
     /**
      * The row look: fill, radius, padding.
      */
@@ -155,12 +159,12 @@ export type DndSortableItemProps = {
      */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLElement>;
-} & Omit<React.HTMLAttributes<HTMLElement>, "id">;
+} & Omit<React.HTMLAttributes<HTMLElement>, "id"> & Pick<React.ThHTMLAttributes<HTMLTableCellElement>, "scope">;
 /**
  * One item of a `Dnd.Sortable`. Renders `li` inside `ul` / `ol`, `tr` inside `tbody`, `div` otherwise.
  * The item is the keyboard target (a `div` one is a named `button`), or with `handle` its grip is.
  */
-declare function DndSortableItem({ id, disabled: itemDisabled, locked, className, children, onPointerDown, onKeyDown, onDragStart, ref, ...rest }: DndSortableItemProps): import("react/jsx-runtime").JSX.Element;
+declare function DndSortableItem({ id, disabled: itemDisabled, locked, dragFromControls, className, children, onPointerDown, onKeyDown, onDragStart, ref, ...rest }: DndSortableItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace DndSortableItem {
     var displayName: string;
 }

package/dist/components/dnd/inPlaceRow.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shifts the cells of `row` while `draggingId` is carried and the gap stands in front of
+ * `gapBefore`. A drop (the order changed) takes the shifts off in the same frame the cells take
+ * their new places, which are the places they were drawn at (each column keeps its width); a
+ * cancel glides them back.
+ */
+export declare function useInPlaceShift(row: HTMLElement | null, order: readonly string[], draggingId: string | null, gapBefore: string | null | undefined): void;

package/dist/components/dnd/useDragSource.d.ts

@@ -1,6 +1,8 @@
 import * as React from "react";
 import type { DragItem, DragOutcome } from "./dragSession";
 import type { Point, Rect } from "./geometry";
+/** Set by `Dnd.SortableItem dragFromControls`: a press on a control inside picks the item up too. */
+export declare const DRAG_FROM_CONTROLS = "data-dnd-drag-controls";
 export type DragSourceItem<TData> = {
     id: string;
     data: TData;

package/dist/components/dnd/useSortableList.d.ts

@@ -31,6 +31,11 @@ export type SortableListOptions = {
     canDrop?: ((id: string) => DropVerdict) | undefined;
     /** Only a press on a `[data-dnd-handle]` element starts a drag. */
     handleOnly?: boolean | undefined;
+    /**
+     * The items keep their places in the layout while one is carried (the cells of a table's head
+     * row stay in their columns): the host shifts them aside itself, nothing glides here mid-drag.
+     */
+    inPlace?: boolean | undefined;
 };
 export type SortableItemProps = DragSourceProps & {
     "data-lifted"?: true | undefined;