@dcs-tech/ui 0.10.0 → 0.11.0

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;

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

@@ -0,0 +1,34 @@
+import type { RowPins } from '../../../core/logic';
+import type { DisplayItem } from '../grouping/groupModel';
+import type { DataTableRowTransaction } from '../types';
+export interface FoundPinnedRows<T> {
+    rows: readonly T[] | null;
+    ids: string;
+    map: Map<string, T>;
+}
+export declare const newFoundPinnedRows: <T>() => FoundPinnedRows<T>;
+export declare function findPinnedRows<T>(cache: FoundPinnedRows<T>, rows: readonly T[], ids: ReadonlySet<string>, keyOf: (row: T) => string): Map<string, T>;
+export interface PinnedRowLines<T> {
+    top: DisplayItem[];
+    bottom: DisplayItem[];
+    rowById: Map<string, any>;
+    originals: {
+        top: T[];
+        bottom: T[];
+    };
+    keep: (id: string, row: T) => void;
+    applyTransaction: (tx: DataTableRowTransaction<T>) => void;
+}
+export declare const isAppPinnedRow: (row: unknown) => boolean;
+export declare function usePinnedRows<T>(opts: {
+    table: any;
+    pins: RowPins;
+    rows: readonly T[];
+    rowKey?: string;
+    serverMode: boolean;
+    app?: {
+        top?: readonly T[];
+        bottom?: readonly T[];
+    };
+    enabled: boolean;
+}): PinnedRowLines<T>;

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

@@ -0,0 +1,44 @@
+import React, { type RefObject } from 'react';
+import { type RowDropTarget, type TreeDragLine, type TreeDropPlace, type TreeShape } from '../../../core/logic';
+import type { DataTableLabels } from '../labels';
+export interface RowDragHost {
+    on: boolean;
+    blocked: string | null;
+    areaRef: RefObject<HTMLElement | null>;
+    surface?: DragSurface;
+    order: () => string[];
+    moving: (id: string) => string[];
+    titleOf: (id: string) => string;
+    drop: (ids: string[], target: RowDropTarget) => void;
+    tree?: RowDragTree | null;
+    announce: (text: string) => void;
+    labels: DataTableLabels;
+    number: (n: number) => string;
+    onStart?: () => void;
+    onEnd?: () => void;
+    scrollToKey?: (key: string) => void;
+}
+export type DragSurface = 'table' | 'cards' | 'list';
+export interface RowDragTreeLine extends TreeDragLine {
+    closed?: boolean;
+}
+export interface RowDragTree {
+    shape: () => TreeShape;
+    lines: () => readonly RowDragTreeLine[];
+    expand: (id: string) => void;
+    drop: (roots: string[], place: TreeDropPlace) => void;
+}
+export declare const TOUCH_HOLD_MS = 400;
+export declare const TREE_OPEN_MS = 700;
+export declare function useRowDrag(host: RowDragHost): {
+    handleProps: (id: string) => {
+        onPointerDown: (e: React.PointerEvent<HTMLElement>) => void;
+        onTouchStart: (e: React.TouchEvent<HTMLElement>) => void;
+        onContextMenu: (e: React.MouseEvent) => void;
+        onClick: (e: React.MouseEvent) => void;
+    };
+    onKeyDown: (e: React.KeyboardEvent) => boolean;
+    overlay: React.ReactPortal | null;
+    dragging: boolean;
+    cancel: () => void;
+};

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

@@ -1,10 +1,11 @@
 import React, { type ReactNode } from 'react';
 import type { RowPressHandlers } from '../rows/rowPress';
-import type { CardLine, CardRow, MotionOptions } from '../cards/CardView';
+import { type CardLine, type CardRow, type MotionOptions } from '../cards/CardView';
 import type { ListParts } from '../cards/rowParts';
 import { type ScrollApi, type VirtualOptions } from '../virtual/useVirtualLines';
 interface SplitViewProps {
     rows: CardRow[];
+    partsOf: (row: CardRow) => ListParts;
     lines?: CardLine[];
     openId: string | null;
     checkboxes: boolean;
@@ -21,9 +22,10 @@ interface SplitViewProps {
     scrollApi?: React.MutableRefObject<ScrollApi | null>;
     listFooter?: ReactNode;
     motion?: MotionOptions;
+    renderLead?: (id: string) => ReactNode;
 }
 export declare function SplitItemContent({ parts }: {
     parts: ListParts;
 }): React.JSX.Element;
-export declare function SplitView({ rows, lines: linesProp, openId, checkboxes, onToggle, press, renderActions, pane, narrowList, focusable, activeKey, placeholder, loading, virtual, scrollApi, listFooter, motion }: SplitViewProps): React.JSX.Element;
+export declare function SplitView({ rows, partsOf, lines: linesProp, openId, checkboxes, onToggle, press, renderActions, pane, narrowList, focusable, activeKey, placeholder, loading, virtual, scrollApi, listFooter, motion, renderLead }: SplitViewProps): React.JSX.Element;
 export default SplitView;

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

@@ -7,5 +7,6 @@ export interface SummaryChartProps {
     locale?: string;
     labels: Partial<ChartLabels> & Pick<ChartLabels, 'count' | 'rest'>;
     onLegendCut?: (hidden: number) => void;
+    animate?: boolean;
 }
-export default function SummaryChart({ item, onSelect, format, locale, labels, onLegendCut }: SummaryChartProps): import("react").JSX.Element;
+export default function SummaryChart({ item, onSelect, format, locale, labels, onLegendCut, animate }: SummaryChartProps): import("react").JSX.Element;

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

@@ -25,10 +25,11 @@ interface TableSummaryProps {
     loadAll: (card: DataTableSummaryBreakdownCard) => Promise<SummaryBucketView[]>;
     image?: TableSummaryImage;
     rootRef?: Ref<HTMLElement>;
+    animate?: boolean;
 }
 type BreakdownItem = Extract<ResolvedSummaryCard, {
     kind: 'breakdown';
 }>;
 export declare function visibleValues(item: BreakdownItem, cut?: number): number;
-declare function TableSummary({ strip, cards, open, onToggle, context, status, onSelect, selectable, loadAll, image, rootRef }: TableSummaryProps): React.JSX.Element;
+declare function TableSummary({ strip, cards, open, onToggle, context, status, onSelect, selectable, loadAll, image, rootRef, animate }: TableSummaryProps): React.JSX.Element;
 export default TableSummary;

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

@@ -1,5 +1,5 @@
 import { type GroupLabels, type GroupValue } from '../grouping/groupModel';
-import { type DataTableColumn, type DataTableExportSummary, type DataTableFilterCondition, type DataTableFilterGroup, type DataTableSummaryAnyChart, type DataTableSummaryBreakdown, type DataTableSummaryBreakdownCard, type DataTableSummaryBucket, type DataTableSummaryCard, type DataTableSummaryFigure, type DataTableSummaryFunnelCard, type DataTableSummaryPart, type DataTableSummaryPeriod, type DataTableSummaryPeriodCount, type DataTableSummaryRequest, type DataTableSummaryShow, type DataTableSummarySubline, type DataTableSummaryTrendCard, type DataTableSummaryValueCard, type DataTableSummaryWidth } from '../types';
+import { type DataTableColumn, type DataTableExportSummary, type DataTableFilterCondition, type DataTableFilterGroup, type DataTableSummaryAnyChart, type DataTableSummaryBreakdown, type DataTableSummaryBreakdownCard, type DataTableSummaryBucket, type DataTableSummaryCard, type DataTableSummaryCardContext, type DataTableSummaryFigure, type DataTableSummaryFunnelCard, type DataTableSummaryPart, type DataTableSummaryPeriod, type DataTableSummaryPeriodCount, type DataTableSummaryRange, type DataTableSummaryRequest, type DataTableSummaryShow, type DataTableSummarySubline, type DataTableSummarySum, type DataTableSummaryTrendCard, type DataTableSummaryValueCard, type DataTableSummaryValueFigure, type DataTableSummaryRowFilter, type DataTableSummaryWidth } from '../types';
 import type { ChartSlot } from '../../Charts';
 export declare const SUMMARY_CONDITION_PREFIX = "summary:";
 export declare const summaryConditionId: (cardId: string) => string;
@@ -19,10 +19,11 @@ export declare function breakdownPart(card: DataTableSummaryBreakdownCard, partT
 export declare function partOf(buckets: readonly DataTableSummaryBucket[], part: DataTableSummaryPart): DataTableSummaryBreakdown;
 export declare const splits: (card: DataTableSummaryTrendCard) => boolean;
 export declare function summaryCardKey(card: SummaryChartCard | DataTableSummaryValueCard, partTop?: number): string;
-export declare function summaryRequest<T>(cards: DataTableSummaryCard<T>[], columns: DataTableColumn<T>[]): DataTableSummaryRequest;
+export declare function summaryRequest<T>(allCards: DataTableSummaryCard<T>[], columns: DataTableColumn<T>[], ctx?: DataTableSummaryCardContext<T>): DataTableSummaryRequest;
 export declare function ownCondition(group: DataTableFilterGroup, cardId: string): DataTableFilterCondition | undefined;
 export declare function withoutOwnCondition(group: DataTableFilterGroup, cardId: string): DataTableFilterGroup;
-export declare function setSummaryCondition(group: DataTableFilterGroup, cardId: string, condition: DataTableFilterCondition | null): DataTableFilterGroup;
+export declare function setSummaryCondition(group: DataTableFilterGroup, cardId: string, condition: DataTableFilterCondition | null, where?: DataTableSummaryRowFilter['condition']): DataTableFilterGroup;
+export declare function withoutOrphanWhere(group: DataTableFilterGroup): DataTableFilterGroup;
 export declare function breakdownCondition<T>(card: DataTableSummaryBreakdownCard, col: DataTableColumn<T> | undefined, value: GroupValue): DataTableFilterCondition;
 export declare function trendCondition(card: DataTableSummaryTrendCard, period: string): DataTableFilterCondition;
 export declare function funnelCondition(card: DataTableSummaryFunnelCard, stepId: string): DataTableFilterCondition | null;
@@ -30,12 +31,25 @@ export declare const bucketKey: (v: GroupValue) => string;
 export declare const OTHERS_KEY = "\0others";
 export declare function selectedKey(card: SummaryChartCard, cond: DataTableFilterCondition | undefined): string | null;
 export declare function computeFigure<T>(figure: DataTableSummaryFigure<T>, rows: T[]): number;
-export declare function countValues<T>(rows: T[], col: DataTableColumn<T>): DataTableSummaryBucket[];
-export declare function withChildren<T>(answer: DataTableSummaryBreakdown, rows: T[], col: DataTableColumn<T>, within: DataTableColumn<T>): DataTableSummaryBreakdown;
+export declare const cardRows: <T>(card: {
+    where?: DataTableSummaryBreakdownCard<T>["where"];
+}, rows: T[]) => T[];
+export declare function countValues<T>(rows: T[], col: DataTableColumn<T>, sum?: DataTableSummarySum<T>): DataTableSummaryBucket[];
+export declare function withChildren<T>(answer: DataTableSummaryBreakdown, rows: T[], col: DataTableColumn<T>, within: DataTableColumn<T>, sum?: DataTableSummarySum<T>): DataTableSummaryBreakdown;
 export declare const monthOf: (v: unknown) => string | null;
 export declare function lastMonths(n: number, now?: Date): string[];
 export declare function lastDays(n: number, now?: Date): string[];
-export declare function countPeriods<T>(rows: T[], col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date, split?: DataTableColumn<T>): DataTableSummaryPeriodCount[];
+export declare function trendRangeOf(range: DataTableSummaryRange | null | undefined, period: DataTableSummaryPeriod, count: number, now?: Date): {
+    from: string;
+    to: string;
+    count: number;
+} | null;
+export declare function summaryCardFor<T>(card: DataTableSummaryCard<T>, ctx?: DataTableSummaryCardContext<T>, now?: Date): DataTableSummaryCard<T>;
+export declare function countPeriods<T>(rows: T[], col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date, split?: DataTableColumn<T>, opts?: {
+    sum?: DataTableSummarySum<T>;
+    range?: Required<DataTableSummaryRange> | null;
+}): DataTableSummaryPeriodCount[];
+export declare const trendPeriods: <T>(card: DataTableSummaryTrendCard<T>, rows: T[], col: DataTableColumn<T>, split?: DataTableColumn<T>, now?: Date) => DataTableSummaryPeriodCount[];
 export declare function figureSeries<T>(rows: T[], figure: DataTableSummaryFigure<T>, col: DataTableColumn<T>, period: DataTableSummaryPeriod, count: number, now?: Date): {
     points: Array<{
         period: string;
@@ -87,6 +101,10 @@ export interface SummaryStepView {
     slot: ChartSlot;
     selectable: boolean;
 }
+export type SummaryFigureView = Pick<DataTableSummaryValueFigure, 'label' | 'text'> & {
+    value: number | null;
+};
+export declare const SUMMARY_FIGURES_FIT = 4;
 export type ResolvedSummaryCard<T = any> = {
     key: string;
     width: DataTableSummaryWidth;
@@ -104,6 +122,7 @@ export type ResolvedSummaryCard<T = any> = {
         points: SummaryPeriodView[];
         previous: number;
     } | null;
+    figures?: SummaryFigureView[];
 } | {
     kind: 'ratio';
     card: DataTableSummaryCard<T> & {
@@ -140,6 +159,9 @@ export type ResolvedSummaryCard<T = any> = {
     reason: string;
 });
 export declare const drawsChart: (item: ResolvedSummaryCard) => boolean;
+export declare const contentHeight: (item: ResolvedSummaryCard) => boolean;
+export declare const summaryFormat: (item: ResolvedSummaryCard, num: (n: number) => string) => ((n: number) => string);
+export declare const figureText: (f: Pick<DataTableSummaryValueFigure, "text">, n: string) => string;
 export declare const shareOf: (value: number, total: number) => number;
 export declare function percentText(p: number): string;
 export declare function sublineText(line: DataTableSummarySubline, n: string): string;

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

@@ -13,6 +13,9 @@ export interface TableSummaryInputs<TData> {
         others: string;
     };
     locale?: string;
+    selectionKey?: unknown;
 }
 export declare function resolveSummaryCards<TData>({ items, columns, serverMode, rowsFor, figures, filterGroup, query, labels, locale }: TableSummaryInputs<TData>): ResolvedSummaryCard<TData>[];
+export declare const SUMMARY_SETTLE_MS = 250;
+export declare const SUMMARY_SLICE_ROWS = 20000;
 export declare function useTableSummary<TData>(inputs: TableSummaryInputs<TData>): ResolvedSummaryCard<TData>[];

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

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface ToolbarMoreItem {
+    id: string;
+    label: string;
+    icon: React.ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+}
+interface ToolbarMoreProps {
+    items: ToolbarMoreItem[];
+    onPick: (id: string) => void;
+}
+export declare function ToolbarMore({ items, onPick }: ToolbarMoreProps): React.JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { type RefObject } from 'react';
+export interface ToolbarFitEntry {
+    id: string;
+    priority: number;
+}
+export interface ToolbarFit {
+    overflow: string[];
+    compact: boolean;
+}
+export declare function useToolbarFit(toolbarRef: RefObject<HTMLElement | null>, actionsRef: RefObject<HTMLElement | null>, entries: readonly ToolbarFitEntry[], key: string): ToolbarFit;

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

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function TreeChips({ onExpandAll, onCollapseAll }: {
+    onExpandAll: () => void;
+    onCollapseAll: () => void;
+}): React.JSX.Element;

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

@@ -0,0 +1,54 @@
+import { type TreeExtraRows } from '../../../core/logic';
+import { type ColumnTextContext } from '../columnValue';
+import type { DataTableColumn } from '../types';
+export declare const TREE_LEVEL_KEY = "__treeLevel";
+export interface TreeLevels<T> {
+    depthOf: (row: T) => number | undefined;
+    isParent: (row: T) => boolean;
+}
+export interface TreeLevelLook {
+    mode: 'column' | 'indent';
+    header: string;
+    text: ColumnTextContext;
+}
+export interface TreeExport<T> {
+    rows: T[];
+    columns: DataTableColumn<T>[];
+    keys: string[];
+    inTotals?: (row: T) => boolean;
+}
+export declare function treeLevelsOf<T>(ordered: ReadonlyArray<{
+    row: T;
+    id: string;
+    depth: number;
+}>, isParent: (id: string) => boolean): {
+    rows: T[];
+    levels: TreeLevels<T>;
+};
+export declare function treeLevelColumns<T>(columns: DataTableColumn<T>[], keys: string[], levels: TreeLevels<T>, look: TreeLevelLook): {
+    columns: DataTableColumn<T>[];
+    keys: string[];
+};
+export declare function treeFileOf<T>(rows: readonly T[], opts: {
+    idOf: (row: T) => string;
+    children?: (row: T) => T[] | null | undefined;
+    parentField?: string;
+    extra?: TreeExtraRows<T>;
+}): {
+    rows: T[];
+    levels: TreeLevels<T>;
+};
+export declare const treeInTotals: <T>(levels: TreeLevels<T>, totals: "leaves" | "all") => ((row: T) => boolean) | undefined;
+export declare function treeExportOf<T>(ordered: Array<{
+    row: {
+        id: string;
+        original: T;
+    };
+    depth: number;
+}> | null, columns: DataTableColumn<T>[], keys: string[], opts: {
+    mode: 'column' | 'indent';
+    totals: 'leaves' | 'all';
+    isParent: (id: string) => boolean;
+    header: string;
+    text: ColumnTextContext;
+}): TreeExport<T> | null;

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

@@ -0,0 +1 @@
+export declare function withNestedValue<T>(row: T, path: string, value: unknown): T;

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

@@ -0,0 +1,15 @@
+import type { DataTableDataSource, DataTableQuery } from '../types';
+export declare function useTreeChildren<T>(opts: {
+    dataSource: DataTableDataSource<T> | undefined;
+    active: boolean;
+    query: DataTableQuery | null;
+    rowKey: string | undefined;
+    tick: number;
+}): {
+    enabled: boolean;
+    rows: T[];
+    parents: Map<string, string>;
+    status: (id: string) => "error" | "loading" | "done" | undefined;
+    load: (id: string, parent: T) => void;
+    forget: (id: string) => void;
+};