@dcs-tech/ui 0.9.0 → 0.11.0

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

@@ -1,6 +1,8 @@
 import type { DataTableSummaryAnyChart } from './types';
 export declare const DEFAULT_DATA_TABLE_LABELS: {
     toolbar: string;
+    toolbarMore: string;
+    toolbarMoreOn: string;
     search: string;
     searchPlaceholder: string;
     closeSearch: string;
@@ -19,6 +21,7 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     columnFilters: string;
     layout: string;
     layoutCurrent: (layout: string) => string;
+    layoutFieldsItem: (fields: string) => string;
     layoutTable: string;
     layoutCards: string;
     layoutSplit: string;
@@ -80,6 +83,16 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     undoFailed: string;
     dismiss: string;
     dataTable: string;
+    rowsNewAbove: (n: string, count: number) => string;
+    rowsNewBelow: (n: string, count: number) => string;
+    rowsNewOnOtherPages: (n: string, count: number) => string;
+    rowsRemovedAbove: (n: string) => string;
+    rowsRemovedBelow: (n: string) => string;
+    rowsKeptInPlace: (n: string, count: number) => string;
+    sortNow: string;
+    pauseUpdates: string;
+    resumeUpdates: (n: string, count: number) => string;
+    rowsChangedAnnouncement: (added: string, removed: string, addedCount: number, removedCount: number) => string;
     selectAllRows: string;
     selectRow: (n: string) => string;
     open: string;
@@ -87,12 +100,44 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     actions: string;
     expandRow: string;
     collapseRow: string;
+    rowDragHandle: (row: string) => string;
+    rowDragHint: string;
+    rowDragOffSorted: string;
+    rowDragOffSearched: string;
+    rowDragOffFiltered: string;
+    rowDragOffGrouped: string;
+    rowDragPicked: (row: string, at: string, of: string) => string;
+    rowDragPickedMany: (n: string, at: string, of: string) => string;
+    rowDragAt: (at: string, of: string) => string;
+    rowDragDropped: (row: string, at: string, of: string) => string;
+    rowDragDroppedMany: (n: string, at: string, of: string) => string;
+    rowDragCancelled: (row: string) => string;
+    rowDragMore: (n: string) => string;
+    rowDragTreeIn: (parent: string, at: string, of: string) => string;
+    rowDragTreeTop: (at: string, of: string) => string;
+    rowDragTreeInto: (parent: string, at: string, of: string) => string;
+    rowDragTreeToTop: (at: string, of: string) => string;
+    rowDragTreePicked: (row: string, where: string) => string;
+    rowDragTreePickedMany: (n: string, where: string) => string;
+    rowDragTreeDropped: (row: string, where: string) => string;
+    rowDragTreeDroppedMany: (n: string, where: string) => string;
+    rowDragTreeNoIndent: string;
+    rowDragTreeNoOutdent: string;
+    treeExpand: (row: string) => string;
+    treeCollapse: (row: string) => string;
+    treeLoading: string;
+    treeLoadFailed: string;
+    treeExpandAll: string;
+    treeCollapseAll: string;
+    treeRows: string;
+    treeLevel: string;
     showMore: string;
     showLess: string;
     total: string;
     yes: string;
     no: string;
     empty: string;
+    noResults: string;
     loading: string;
     loadError: string;
     rowsHidden: string;
@@ -111,6 +156,11 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     copyFailed: string;
     selectRowMenu: string;
     unselectRowMenu: string;
+    pinRowTop: string;
+    pinRowBottom: string;
+    unpinRow: string;
+    pinnedRowTop: string;
+    pinnedRowBottom: string;
     filterOnly: (value: string) => string;
     filterAdd: (value: string) => string;
     filterHide: (value: string) => string;
@@ -177,6 +227,34 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     kbFilterOnly: string;
     kbFilterHide: string;
     selectionCleared: string;
+    kbCellRange: string;
+    kbCellRangeEdge: string;
+    kbCellAdd: string;
+    kbCellAll: string;
+    kbCellCopy: string;
+    kbCellPaste: string;
+    kbCellRows: string;
+    kbCellEscape: string;
+    cellRangeAnnouncement: (cells: string, rows: string, columns: string, count: {
+        cells: number;
+        rows: number;
+        columns: number;
+        ranges: number;
+    }) => string;
+    cellRangeCleared: string;
+    cellsCopied: (n: string, count: number) => string;
+    cellsPasted: (n: string, count: number) => string;
+    cellRangeBar: string;
+    cellRangeCount: string;
+    cellRangeSum: string;
+    cellRangeAvg: string;
+    cellRangeMin: string;
+    cellRangeMax: string;
+    cellTouchBar: string;
+    cellTouchSize: (n: string, count: number) => string;
+    cellTouchCopy: string;
+    cellTouchMenu: string;
+    cellTouchClear: string;
     groupButton: string;
     groupButtonOn: (columns: string) => string;
     groupMenu: string;
@@ -265,6 +343,9 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     actionDisplayMode: string;
     actionDisplayModeCard: string;
     actionDisplayModeHint: string;
+    maxVisibleActions: string;
+    maxVisibleActionsCard: string;
+    maxVisibleActionsHint: string;
     modeIcon: string;
     modeLabel: string;
     modeIconLabel: string;
@@ -424,6 +505,7 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     summaryWidthFull: string;
     summaryWidthAuto: (best: string) => string;
     summaryWidthBetter: (best: string) => string;
+    manageSummaryRangeHint: string;
     summarySeeAll: (n: string) => string;
     summaryAllOf: (title: string, n: string) => string;
     summaryLoading: string;
@@ -463,6 +545,7 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     exportAwaitingClick: (title: string) => string;
     exportValidationFailed: string;
     exportCapped: (shown: string, total: string) => string;
+    exportTreePartial: string;
     exportBusiness: string;
     exportAddress: string;
     exportPhone: string;
@@ -470,6 +553,7 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     exportFiltersLabel: string;
     exportSearchLabel: string;
     exportRowsLabel: string;
+    exportNoteLabel: string;
     exportRowsTotal: (n: string) => string;
     exportRowsFiltered: (n: string) => string;
     exportRowsExported: (n: string) => string;
@@ -596,6 +680,7 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     listAllInList: string;
     fieldsDropHere: string;
     fieldsRemove: (field: string) => string;
+    fieldsMove: (field: string) => string;
     fieldsAdd: string;
     fieldsLivePreview: string;
     cardPreviewCard: string;
@@ -605,6 +690,51 @@ export declare const DEFAULT_DATA_TABLE_LABELS: {
     fieldsTab: string;
     previewTab: string;
     fieldsResetDefault: string;
+    pivot: string;
+    pivotOn: string;
+    pivotTitle: string;
+    pivotSubtitle: string;
+    pivotMode: string;
+    pivotModeHint: string;
+    pivotRows: string;
+    pivotRowsHint: string;
+    pivotColumns: string;
+    pivotColumnsHint: string;
+    pivotValues: string;
+    pivotValuesHint: string;
+    pivotFields: string;
+    pivotFieldsHint: string;
+    pivotAllPlaced: string;
+    pivotDropHere: string;
+    pivotAdd: string;
+    pivotAddTo: (part: string) => string;
+    pivotAddField: (field: string, part: string) => string;
+    pivotRemove: (field: string) => string;
+    pivotMove: (field: string) => string;
+    pivotAggregation: (field: string) => string;
+    pivotAggSum: string;
+    pivotAggCount: string;
+    pivotAggAvg: string;
+    pivotAggMin: string;
+    pivotAggMax: string;
+    pivotAggFirst: string;
+    pivotAggLast: string;
+    pivotAggCustom: string;
+    pivotValueHeader: (agg: string, column: string) => string;
+    pivotTotal: string;
+    pivotTotalOf: (value: string) => string;
+    pivotGrandTotal: string;
+    pivotTotals: string;
+    pivotTotalsRows: string;
+    pivotTotalsColumns: string;
+    pivotTotalsGrand: string;
+    pivotCapped: (shown: string, total: string) => string;
+    pivotNoValues: string;
+    pivotNoRows: string;
+    pivotLoadFailed: string;
+    pivotResult: string;
+    pivotReset: string;
+    pivotFieldsOf: (n: string) => string;
     prefsChanged: (what: string) => string;
     prefsColumnsGone: (n: string, count: number) => string;
     prefsFiltersOff: (n: string, count: number) => string;

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

@@ -1,9 +1,17 @@
 import React from 'react';
 import type { DataTableLayout } from '../types';
 export declare const LAYOUT_ICONS: Record<DataTableLayout, React.ReactNode>;
-export declare function LayoutSwitcher({ layouts, layout, onChange }: {
+export interface LayoutFieldsEntry {
+    label: string;
+    icon: React.ReactNode;
+    onOpen: () => void;
+}
+interface LayoutSwitcherProps {
     layouts: DataTableLayout[];
     layout: DataTableLayout;
     onChange: (layout: DataTableLayout) => void;
-}): React.JSX.Element | null;
+    compact?: boolean;
+    fields?: LayoutFieldsEntry;
+}
+export declare function LayoutSwitcher({ layouts, layout, onChange, compact, fields }: LayoutSwitcherProps): React.JSX.Element | null;
 export default LayoutSwitcher;

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

@@ -0,0 +1,7 @@
+import { type RefObject } from 'react';
+import { type FitColumn } from '../../../core/logic';
+export interface FitWidthColumn extends FitColumn {
+    scaledMin?: number;
+}
+export declare const FIT_COL_ATTR = "data-fit-col";
+export declare function useFitWidths(tableRef: RefObject<HTMLTableElement | null>, boxRef: RefObject<HTMLElement | null>, active: boolean, columns: FitWidthColumn[], reserved: number, key: string): void;

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

@@ -44,6 +44,7 @@ export interface RowMenuPlacement {
     y: number;
     sheet: boolean;
     alignRight?: boolean;
+    anchorHeight?: number;
 }
 interface RowMenuProps {
     model: RowMenuModel;

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

@@ -1,8 +1,7 @@
-import React, { type ReactNode } from 'react';
-import type { DataTableCardFields, DataTableFilterGroup, DataTableRowMenuConfig, DataTableRowMenuBuiltIn, DataTableRowAction, DataTableColumn } from '../types';
+import { type ReactNode } from 'react';
+import type { DataTableCardFields, DataTableFilterGroup, DataTableRowMenuConfig, DataTableRowMenuBuiltIn, DataTableRowAction, DataTableColumn, DataTableRowPinSide } from '../types';
 import type { DataTableLabels } from '../labels';
 import type { RowMenuModel } from './RowMenu';
-export declare function NotEqualIcon(): React.JSX.Element;
 export declare const DEFAULT_BUILT_INS: DataTableRowMenuBuiltIn[];
 export interface RowMenuContext<T> {
     row: T;
@@ -31,5 +30,9 @@ export interface RowMenuContext<T> {
     filterGroup: DataTableFilterGroup;
     onFilter: (group: DataTableFilterGroup) => void;
     format: (n: number) => string;
+    pin?: {
+        side: DataTableRowPinSide | null;
+        onPin: (side: DataTableRowPinSide | null) => void;
+    };
 }
 export declare function buildRowMenu<T>(ctx: RowMenuContext<T>): RowMenuModel;

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

@@ -0,0 +1,19 @@
+import type { RowChangeNotice as Notice } from './useRowChangeNotices';
+export interface LiveUpdatesControl {
+    paused: boolean;
+    waiting: number;
+    onPause: () => void;
+    onResume: () => void;
+}
+interface Props {
+    notice: Notice;
+    side: 'top' | 'bottom';
+    onJump: (side: 'above' | 'below') => void;
+    onOtherPages: () => void;
+    onDismiss: () => void;
+    held?: number;
+    onSortNow?: () => void;
+    live?: LiveUpdatesControl | null;
+}
+export declare function RowChangeNotice({ notice, side, onJump, onOtherPages, onDismiss, held, onSortNow, live }: Props): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,25 @@
+import type { CSSProperties } from 'react';
+import type { DataTableFlashColor, DataTableRowChanges } from '../types';
+import { type RowChangeReport } from './useRowMotion';
+export interface RowChangesOptions {
+    enterMs: number;
+    exitMs: number;
+    maxAnimated: number;
+    onChange?: (report: RowChangeReport) => void;
+    which?: (added: string[], removed: string[]) => {
+        added: string[];
+        removed: string[];
+    };
+    held?: ReadonlyMap<string, unknown>;
+}
+export interface ResolvedRowChanges {
+    enterMs: number;
+    exitMs: number;
+    maxAnimated: number;
+    outOfView: boolean;
+    announce: boolean;
+    pauseControl: boolean;
+    style: CSSProperties;
+}
+export declare const rowChangeColor: (c: DataTableFlashColor) => string;
+export declare function resolveRowChanges(cfg: DataTableRowChanges | undefined): ResolvedRowChanges;

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

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare function useNoticeInsets(areaRef: RefObject<HTMLElement | null>, active: boolean, key: string): void;

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

@@ -0,0 +1,35 @@
+import { type RefObject } from 'react';
+import { type RowChangeReport } from './useRowMotion';
+export type Where = 'above' | 'in' | 'below';
+export interface RowChangeNotice {
+    addedAbove: number;
+    addedBelow: number;
+    removedAbove: number;
+    removedBelow: number;
+    otherPages: number;
+}
+export declare function rowElement(area: HTMLElement, key: string, exit?: boolean): HTMLElement | null;
+export declare function whereIs(el: HTMLElement, area: HTMLElement): Where;
+export interface RowChangeNoticesOptions {
+    areaRef: RefObject<HTMLElement | null>;
+    outOfView: boolean;
+    announce: boolean;
+    tellFromViews: boolean;
+    placeOf: (key: string) => number;
+    reveal: (key: string) => void;
+    describe: (added: number, removed: number) => string;
+}
+export interface RowChangeNotices {
+    notice: RowChangeNotice;
+    onChange: (report: RowChangeReport) => void;
+    addOtherPages: (keys: string[]) => void;
+    otherPageKeys: () => string[];
+    jump: (side: 'above' | 'below') => void;
+    dismiss: () => void;
+    announcement: string;
+    pulse: (key: string) => void;
+    tell: (added: number, removed: number) => void;
+    refresh: () => void;
+    bringIntoView: (key: string, flash?: boolean) => void;
+}
+export declare function useRowChangeNotices(opts: RowChangeNoticesOptions): RowChangeNotices;

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

@@ -5,14 +5,26 @@ export interface MotionItem<T> {
     item: T;
     motion?: RowMotion;
 }
-export declare const EXIT_MS = 240;
-export declare const ENTER_MS = 1400;
+export declare const EXIT_MS = 700;
+export declare const ENTER_MS = 2000;
+export declare const MAX_ANIMATED_ROWS = 25;
 export declare function prefersReducedMotion(): boolean;
+export declare function visibleSpan(el: HTMLElement): {
+    top: number;
+    bottom: number;
+};
 interface Exit<T> {
     key: string;
     item: T;
     at: number;
 }
+export declare function rowDiff(before: string[], after: string[]): {
+    added: string[];
+    removed: Array<{
+        key: string;
+        at: number;
+    }>;
+};
 export declare function diffRows(before: string[], after: string[]): {
     added: string[];
     removed: Array<{
@@ -20,11 +32,25 @@ export declare function diffRows(before: string[], after: string[]): {
         at: number;
     }>;
 } | null;
-export declare function mergeExits<T>(items: Array<MotionItem<T>>, exits: Array<Exit<T>>): Array<MotionItem<T>>;
+export interface RowChangeReport {
+    added: string[];
+    removed: string[];
+    removedAt: number[];
+    marked: boolean;
+}
+export declare function mergeExits<T>(items: Array<MotionItem<T>>, exits: Array<Exit<T>>, has?: (key: string) => boolean): Array<MotionItem<T>>;
 export declare function useRowMotion<T>(items: T[], keyOf: (item: T) => string, opts: {
     enabled: boolean;
     resetKey: string | undefined;
     containerRef: RefObject<HTMLElement | null>;
+    enterMs?: number;
+    exitMs?: number;
+    maxAnimated?: number;
+    onChange?: (report: RowChangeReport) => void;
+    which?: (added: string[], removed: string[]) => {
+        added: string[];
+        removed: string[];
+    };
 }): {
     items: Array<MotionItem<T>>;
     heightOf: (key: string) => number | undefined;

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

@@ -22,6 +22,9 @@ export interface ViewPrefsContext extends PrefsVersioning {
     summaryCharts?: ReadonlyMap<string, readonly string[]>;
     summaryCounts?: ReadonlyMap<string, readonly number[]>;
     summaryBreakdowns: ReadonlySet<string>;
+    pivotOffered?: boolean;
+    pivotFields?: ReadonlySet<string>;
+    pivotValues?: ReadonlyMap<string, readonly string[]>;
 }
 export interface ManagePrefsContext extends PrefsVersioning {
     key: string;
@@ -44,6 +47,7 @@ export declare function viewPrefsContext(view: DataTableView, opts: {
     key: string;
     serverMode: boolean;
     hasGroupsSource: boolean;
+    hasPivotSource?: boolean;
     operators?: readonly string[];
     summaryBreakdownFields?: readonly string[];
 } & PrefsVersioning): ViewPrefsContext;

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

@@ -1,5 +1,6 @@
-import { type DataTableExportSettings, type DataTableCardFields, type DataTableListFields, type DataTableLayout, type DataTableSavedFilter, type DataTableDisplayPrefs, type DataTablePdfPageSize, type DataTablePdfOrientation, type DataTablePdfFontSize, type DataTablePdfMargins, type DataTablePersistence, type DataTableColumnPinning, type DataTableExportSummaryMode, type DataTableSummaryPrefs, type DataTableExportOptionValues } from '../types';
+import { type DataTableExportSettings, type DataTableCardFields, type DataTableListFields, type DataTableLayout, type DataTableSavedFilter, type DataTableDisplayPrefs, type DataTablePdfPageSize, type DataTablePdfOrientation, type DataTablePdfFontSize, type DataTablePdfMargins, type DataTablePersistence, type DataTableColumnPinning, type DataTableExportSummaryMode, type DataTableSummaryPrefs, type DataTableExportOptionValues, type DataTablePivotState } from '../types';
 import type { PrefsReconciled, PrefsReport } from './reconcile';
+import { type RowPins } from '../../../core/logic';
 export declare const PREFS_SAVE_DEBOUNCE_MS = 500;
 export declare const EXPORT_SETTINGS_DEFAULTS: DataTableExportSettings;
 export interface TemplateExportPrefs {
@@ -37,6 +38,9 @@ export interface ViewExtras {
     setListFields?: (fields: DataTableListFields) => void;
     setGrouping?: (levels: string[]) => void;
     setSummary?: (prefs: DataTableSummaryPrefs) => void;
+    rowPins?: RowPins;
+    setRowPins?: (pins: RowPins) => void;
+    setPivot?: (state: DataTablePivotState) => void;
 }
 export interface ViewDocSync {
     reconcile: (doc: Record<string, any>, key: string) => PrefsReconciled;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { DataTablePivotState } from '../types';
+import { type ResolvedPivot } from './pivotModel';
+interface PivotPanelProps<T> {
+    resolved: ResolvedPivot<T>;
+    state: DataTablePivotState;
+    onApply: (state: DataTablePivotState) => void;
+    onClose: () => void;
+}
+export declare function PivotPanel<T>({ resolved, state: initial, onApply, onClose }: PivotPanelProps<T>): React.JSX.Element;
+export default PivotPanel;

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

@@ -0,0 +1,22 @@
+import React, { type MutableRefObject, type RefObject } from 'react';
+import type { DataTableCellRange, DataTableDisplayPrefs, DataTableView } from '../types';
+import type { PivotOutput } from './usePivot';
+interface PivotViewProps<T> {
+    pivot: PivotOutput<T>;
+    view: DataTableView<T>;
+    displayPrefs: DataTableDisplayPrefs;
+    areaRef: RefObject<HTMLDivElement | null>;
+    keyboard: boolean;
+    phone: boolean;
+    canCopy: boolean;
+    copy: (text: string, cells: number) => void;
+    openHelp: () => void;
+    emptyText: string;
+    rangesRef?: MutableRefObject<PivotRanges | null>;
+}
+export interface PivotRanges {
+    getCellRanges: () => DataTableCellRange[];
+    clearCellRanges: () => void;
+}
+export declare function PivotView<T>({ pivot, view, displayPrefs, areaRef, keyboard, phone, canCopy, copy, openHelp, emptyText, rangesRef }: PivotViewProps<T>): React.JSX.Element;
+export default PivotView;

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

@@ -0,0 +1,54 @@
+import { type PivotAggFn, type PivotAggName, type PivotColumn, type PivotCube, type PivotKey, type PivotLayout, type PivotLine, type PivotSort, type PivotSpec } from '../../../core/logic';
+import { type GroupLabels } from '../grouping/groupModel';
+import type { DataTableLabels } from '../labels';
+import type { DataTableColumn, DataTableColumnGroup, DataTablePivotRequest, DataTablePivotState, DataTablePivotTotals, DataTableView } from '../types';
+export declare const PIVOT_MAX_COLUMNS = 200;
+export interface ResolvedPivot<T> {
+    offered: boolean;
+    panel: boolean;
+    fields: DataTableColumn<T>[];
+    values: DataTableColumn<T>[];
+    aggsOf: (column: string) => string[];
+    aggLabel: (agg: string) => string;
+    aggFn: (agg: string) => PivotAggName | PivotAggFn<T> | null;
+    defaults: DataTablePivotState;
+    maxColumns: number;
+}
+export declare function resolvePivot<T>(view: Pick<DataTableView<T>, 'pivot'>, columns: DataTableColumn<T>[], opts: {
+    serverMode: boolean;
+    hasSource: boolean;
+    labels: DataTableLabels;
+}): ResolvedPivot<T>;
+export declare const pivotTotalsOf: (t: DataTablePivotTotals | undefined) => Required<DataTablePivotTotals>;
+export declare function normalizePivotState<T>(state: unknown, r: Pick<ResolvedPivot<T>, 'fields' | 'values' | 'aggsOf'>): DataTablePivotState;
+export declare const samePivot: (a: DataTablePivotState, b: DataTablePivotState) => boolean;
+export declare function pivotSpecOf<T>(state: DataTablePivotState, r: Pick<ResolvedPivot<T>, 'aggFn'>, byKey: ReadonlyMap<string, DataTableColumn<T>>): PivotSpec<T>;
+export declare function pivotRequestOf<T>(state: DataTablePivotState, byKey: ReadonlyMap<string, DataTableColumn<T>>): DataTablePivotRequest;
+export declare function keyOrderOf<T>(col: DataTableColumn<T> | undefined): (a: PivotKey, b: PivotKey) => number;
+export interface PivotRow {
+    key: string;
+    kind: PivotLine['kind'];
+    depth: number;
+    f: string[];
+    v: unknown[];
+}
+export interface PivotTable {
+    columns: DataTableColumn<PivotRow>[];
+    groups: DataTableColumnGroup[];
+    rows: PivotRow[];
+    rowByLine: ReadonlyMap<string, PivotRow>;
+    grand: PivotRow | null;
+    fieldKeys: string[];
+    slots: ReadonlyMap<string, PivotColumn>;
+}
+export declare function pivotTableOf<T>(cube: PivotCube, layout: PivotLayout, ctx: {
+    state: DataTablePivotState;
+    byKey: ReadonlyMap<string, DataTableColumn<T>>;
+    resolved: Pick<ResolvedPivot<T>, 'aggLabel'>;
+    labels: DataTableLabels;
+    groupLabels: GroupLabels;
+}): PivotTable;
+export declare function pivotSortsOf(sorting: ReadonlyArray<{
+    id: string;
+    desc: boolean;
+}>, table: Pick<PivotTable, 'fieldKeys' | 'slots'>): PivotSort[];

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

@@ -0,0 +1,44 @@
+import type { GroupLabels } from '../grouping/groupModel';
+import type { DataTableLabels } from '../labels';
+import type { DataTableColumn, DataTableDataSource, DataTablePivotState, DataTableQuery, DataTableRowTransaction, DataTableTransactionResult } from '../types';
+import { type PivotRow, type PivotTable, type ResolvedPivot } from './pivotModel';
+export declare const PIVOT_SETTLE_MS = 250;
+export declare const PIVOT_SLICE_ROWS = 20000;
+export declare function transactionKeysOf<T>(tx: DataTableRowTransaction<T>, rowKey: string | undefined): DataTableTransactionResult | null;
+type Sorting = Array<{
+    id: string;
+    desc: boolean;
+}>;
+export interface PivotOutput<T> {
+    resolved: ResolvedPivot<T>;
+    state: DataTablePivotState;
+    on: boolean;
+    table: PivotTable | null;
+    rows: PivotRow[];
+    capped: {
+        shown: number;
+        total: number;
+    } | null;
+    loading: boolean;
+    error: unknown;
+    retry: () => void;
+    sorting: Sorting;
+    setSorting: (s: Sorting) => void;
+}
+export declare function usePivot<T>(opts: {
+    resolved: ResolvedPivot<T>;
+    state: DataTablePivotState;
+    on: boolean;
+    viewId: string;
+    columns: DataTableColumn<T>[];
+    serverMode: boolean;
+    dataSource?: DataTableDataSource<T>;
+    rows: T[];
+    queryKey: string;
+    query: DataTableQuery | null;
+    tick: number;
+    changes?: number;
+    labels: DataTableLabels;
+    groupLabels: GroupLabels;
+}): PivotOutput<T>;
+export {};

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

@@ -2,6 +2,7 @@ import React from 'react';
 interface PressRowProps extends React.HTMLAttributes<HTMLElement> {
     as: 'tr' | 'div';
     pressable: boolean;
+    feedback?: 'tint' | 'wave';
 }
 export declare const PressRow: React.ForwardRefExoticComponent<PressRowProps & React.RefAttributes<HTMLElement>>;
 export {};

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { TreeLineState } from '../grouping/groupModel';
+export interface RowLeadProps {
+    rowId: string;
+    title: string;
+    drag?: {
+        blocked: string | null;
+        tabbable: boolean;
+        props: Record<string, unknown>;
+    };
+    dragSpace?: boolean;
+    tree?: {
+        depth: number;
+        state?: TreeLineState;
+        onToggle: () => void;
+    };
+    toggleTabbable?: boolean;
+}
+export declare function DragHandle({ rowId, title, blocked, tabbable, props }: {
+    rowId: string;
+    title: string;
+} & NonNullable<RowLeadProps['drag']>): React.JSX.Element;
+export declare function RowLead({ rowId, title, drag, dragSpace, tree, toggleTabbable }: RowLeadProps): React.JSX.Element;

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

@@ -9,6 +9,7 @@ export interface RowMenuRequest {
     columnKey: string | null;
     touch: boolean;
     alignRight?: boolean;
+    anchorHeight?: number;
 }
 export interface RowPressOptions<R> {
     canOpen: boolean;
@@ -21,6 +22,7 @@ export interface RowPressOptions<R> {
     onToggle: (row: R) => void;
     onMenu: (row: R, at: RowMenuRequest) => void;
     onOtherClick?: (row: R) => void;
+    ownsLongPress?: (target: EventTarget | null) => boolean;
 }
 export interface RowPressHandlers {
     onMouseDown: (e: React.MouseEvent) => void;