@dcs-tech/ui 0.9.0 → 0.11.0

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

@@ -2,7 +2,17 @@ import { type ComponentType, type ReactNode } from 'react';
 import type { ChartProgressColor, ChartSlot, TrendGood } from '../Charts';
 import type { DataTableLabels } from './labels';
 import type { DateDisplayFormat } from '../../core/types';
-export type DataTableFlashColor = 'green' | 'red' | 'amber' | 'blue' | 'purple' | 'teal' | 'orange' | 'pink';
+export type DataTableFlashColor = 'green' | 'red' | 'amber' | 'blue' | 'purple' | 'teal' | 'orange' | 'pink' | (string & {});
+export interface DataTableRowChanges {
+    addedColor?: DataTableFlashColor;
+    removedColor?: DataTableFlashColor;
+    addedDuration?: number;
+    removedDuration?: number;
+    maxAnimated?: number;
+    outOfView?: boolean;
+    announce?: boolean;
+    pauseControl?: boolean;
+}
 export interface DataTableFlashColors {
     up?: DataTableFlashColor;
     down?: DataTableFlashColor;
@@ -65,8 +75,14 @@ export interface DataTableColumn<TData = any> {
     groupValue?: (value: any, row: TData) => string | number | boolean | null;
     field?: string;
     groupable?: boolean;
+    pivotable?: boolean;
+    aggregatable?: boolean | string[];
     authorized?: boolean;
     license?: DataTableLicense;
+    dataOnly?: boolean;
+    flash?: boolean;
+    flashDirection?: (next: unknown, previous: unknown, row: TData) => 'up' | 'down' | 'changed' | null;
+    flashDuration?: number;
     flashStyle?: DataTableCellFlashStyle;
     flashBadge?: boolean;
     flashColors?: DataTableFlashColors;
@@ -76,6 +92,140 @@ export interface DataTableColumn<TData = any> {
     exportHeader?: string;
     exportable?: boolean;
 }
+export interface DataTableColumnGroup {
+    id: string;
+    header: string;
+    children: Array<string | DataTableColumnGroup>;
+    keepTogether?: boolean;
+    align?: 'left' | 'center' | 'right';
+    exportHeader?: string;
+}
+export type DataTableRowPinSide = 'top' | 'bottom';
+export interface DataTableRowPinningConfig {
+    menu?: boolean;
+    keepInPlace?: boolean;
+}
+export interface DataTableRowPins {
+    top: string[];
+    bottom: string[];
+}
+export type DataTableCellRangeFigure = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export interface DataTableCellRange {
+    startRowId: string;
+    endRowId: string;
+    startColumn: string;
+    endColumn: string;
+    columns: string[];
+    rowIds: string[];
+}
+export interface DataTableCellPaste<TData = any> {
+    rowId: string;
+    row: TData;
+    columnKey: string;
+    value: string;
+}
+export interface DataTableCellSelectionConfig<TData = any> {
+    multiRange?: boolean;
+    copyHeaders?: boolean;
+    statusBar?: boolean | DataTableCellRangeFigure[];
+    onCellRangesChange?: (ranges: DataTableCellRange[]) => void;
+    onCellsPaste?: (event: {
+        cells: DataTableCellPaste<TData>[];
+    }) => void;
+}
+export interface DataTableRowDragConfig<TData = any> {
+    managed?: boolean;
+    canDrag?: (row: TData) => boolean;
+    multiple?: boolean;
+}
+export interface DataTableRowOrderChange<TData = any> {
+    viewId: string;
+    row: TData;
+    moved: TData[];
+    from: number;
+    to: number;
+    rows: TData[];
+    before: TData | null;
+    managed: boolean;
+    parent?: TData | null;
+    parentKey?: string | null;
+    index?: number;
+    previousParent?: TData | null;
+    previousParentKey?: string | null;
+    previousIndex?: number;
+}
+export interface DataTableTreeDataConfig<TData = any> {
+    getChildren?: (row: TData) => TData[] | null | undefined;
+    parentField?: string;
+    defaultExpanded?: boolean | number;
+    filterMode?: 'ancestors' | 'matches';
+    totals?: 'leaves' | 'all';
+    selectChildren?: boolean;
+    exportLevel?: 'column' | 'indent';
+    hasChildren?: (row: TData) => boolean;
+}
+export type DataTablePivotAggregate = 'sum' | 'count' | 'avg' | 'min' | 'max' | 'first' | 'last';
+export type DataTablePivotAggFn<TData = any> = (values: unknown[], rows: TData[]) => unknown;
+export interface DataTablePivotAggregation<TData = any> {
+    label: string;
+    fn: DataTablePivotAggFn<TData>;
+}
+export interface DataTablePivotValue<TData = any> {
+    column: string;
+    agg: DataTablePivotAggregate | (string & {}) | DataTablePivotAggFn<TData>;
+    label?: string;
+}
+export interface DataTablePivotTotals {
+    rows?: boolean;
+    columns?: boolean;
+    grand?: boolean;
+}
+export interface DataTablePivotState {
+    enabled: boolean;
+    rows: string[];
+    columns: string[];
+    values: Array<{
+        column: string;
+        agg: string;
+        label?: string;
+    }>;
+    totals?: DataTablePivotTotals;
+}
+export interface DataTablePivotConfig<TData = any> {
+    enabled?: boolean;
+    rows?: string[];
+    columns?: string[];
+    values?: DataTablePivotValue<TData>[];
+    totals?: DataTablePivotTotals;
+    maxColumns?: number;
+    aggregations?: Record<string, DataTablePivotAggregation<TData>>;
+    panel?: boolean;
+}
+export interface DataTablePivotRequest {
+    rows: Array<{
+        key: string;
+        field: string;
+    }>;
+    columns: Array<{
+        key: string;
+        field: string;
+    }>;
+    values: Array<{
+        key: string;
+        field: string;
+        agg: string;
+    }>;
+    totals: Required<DataTablePivotTotals>;
+}
+export type DataTablePivotKey = string | number | boolean | null;
+export interface DataTablePivotCell {
+    row: DataTablePivotKey[];
+    column: DataTablePivotKey[];
+    values: unknown[];
+}
+export interface DataTablePivotResult {
+    cells: DataTablePivotCell[];
+}
 export interface DataTableFilterCondition {
     id: string;
     column: string;
@@ -129,6 +279,27 @@ export interface DataTableSummarySubline<TData = any> {
     value: DataTableSummaryFigure<TData>;
     text?: (formatted: string) => string;
 }
+export interface DataTableSummaryValueFigure<TData = any> {
+    label: string;
+    value: DataTableSummaryFigure<TData>;
+    text?: (formatted: string) => string;
+}
+export interface DataTableSummarySum<TData = any> {
+    id: string;
+    label: string;
+    value?: (row: TData) => number;
+    format?: (n: number) => string;
+}
+export interface DataTableSummaryRowFilter<TData = any> {
+    id: string;
+    test?: (row: TData) => boolean;
+    condition?: Pick<DataTableFilterCondition, 'column' | 'operator' | 'value'>;
+}
+export interface DataTableSummaryRange {
+    from?: string;
+    to?: string;
+}
+export type DataTableSummaryCardHeight = 'fixed' | 'content';
 export type DataTableSummaryChart = 'donut' | 'pie' | 'bars' | 'stacked' | 'treemap';
 export type DataTableSummaryTrendChart = 'columns' | 'line' | 'area' | 'grouped' | 'stacked' | 'calendar';
 export type DataTableSummaryValueChart = 'number' | 'numberTrend';
@@ -139,7 +310,7 @@ export declare const SUMMARY_KIND_CHARTS: {
     readonly ratio: readonly ["bar", "gauge", "ring", "donut", "pie"];
     readonly breakdown: readonly ["donut", "pie", "bars", "stacked", "treemap"];
     readonly trend: readonly ["columns", "line", "area", "grouped", "stacked", "calendar"];
-    readonly funnel: readonly ["funnel"];
+    readonly funnel: readonly ["funnel", "bars"];
 };
 export type DataTableSummaryWidth = 'auto' | 'quarter' | 'half' | 'full';
 export declare const SUMMARY_WIDTHS: readonly DataTableSummaryWidth[];
@@ -178,8 +349,10 @@ export interface DataTableSummaryValueCard<TData = any> extends DataTableSummary
     kind: 'value';
     value: DataTableSummaryFigure<TData>;
     sub?: DataTableSummarySubline<TData>;
+    figures?: DataTableSummaryValueFigure<TData>[];
     chart?: DataTableSummaryValueChart;
     trend?: DataTableSummaryValueTrend;
+    height?: DataTableSummaryCardHeight;
 }
 export interface DataTableSummaryRatioCard<TData = any> extends DataTableSummaryCardBase {
     kind: 'ratio';
@@ -188,16 +361,19 @@ export interface DataTableSummaryRatioCard<TData = any> extends DataTableSummary
     color?: ChartProgressColor;
     sub?: DataTableSummarySubline<TData>;
     chart?: DataTableSummaryRatioChart;
+    height?: DataTableSummaryCardHeight;
 }
-export interface DataTableSummaryBreakdownCard extends DataTableSummaryCardBase {
+export interface DataTableSummaryBreakdownCard<TData = any> extends DataTableSummaryCardBase {
     kind: 'breakdown';
     column: string;
     chart?: DataTableSummaryChart;
     show?: DataTableSummaryShow;
     slots?: Record<string, ChartSlot>;
     within?: string;
+    sum?: DataTableSummarySum<TData>;
+    where?: DataTableSummaryRowFilter<TData>;
 }
-export interface DataTableSummaryTrendCard extends DataTableSummaryCardBase {
+export interface DataTableSummaryTrendCard<TData = any> extends DataTableSummaryCardBase {
     kind: 'trend';
     column: string;
     period: DataTableSummaryPeriod;
@@ -206,6 +382,9 @@ export interface DataTableSummaryTrendCard extends DataTableSummaryCardBase {
     chart?: DataTableSummaryTrendChart;
     split?: string;
     slots?: Record<string, ChartSlot>;
+    sum?: DataTableSummarySum<TData>;
+    where?: DataTableSummaryRowFilter<TData>;
+    range?: DataTableSummaryRange | ((ctx: DataTableSummaryCardContext<any>) => DataTableSummaryRange | null | undefined);
 }
 export interface DataTableSummaryFunnelStep<TData = any> {
     id: string;
@@ -213,14 +392,19 @@ export interface DataTableSummaryFunnelStep<TData = any> {
     value: DataTableSummaryFigure<TData>;
     condition?: Pick<DataTableFilterCondition, 'column' | 'operator' | 'value'>;
     slot?: ChartSlot;
+    showWhen?: (ctx: DataTableSummaryCardContext<any>) => boolean;
+    hideAtZero?: boolean;
 }
 export interface DataTableSummaryFunnelCard<TData = any> extends DataTableSummaryCardBase {
     kind: 'funnel';
     steps: DataTableSummaryFunnelStep<TData>[];
+    chart?: 'funnel' | 'bars';
+    showChange?: boolean;
 }
-export type DataTableSummaryCard<TData = any> = DataTableSummaryValueCard<TData> | DataTableSummaryRatioCard<TData> | DataTableSummaryBreakdownCard | DataTableSummaryTrendCard | DataTableSummaryFunnelCard<TData>;
+export type DataTableSummaryCard<TData = any> = DataTableSummaryValueCard<TData> | DataTableSummaryRatioCard<TData> | DataTableSummaryBreakdownCard<TData> | DataTableSummaryTrendCard<TData> | DataTableSummaryFunnelCard<TData>;
 export interface DataTableSummaryConfig<TData = any> {
     cards: DataTableSummaryCard<TData>[];
+    animate?: boolean;
 }
 export declare const SUMMARY_TREND_COUNTS: {
     readonly month: readonly [3, 6, 12, 24, 36];
@@ -270,6 +454,8 @@ export type DataTableSummaryCardRequest = {
     field: string;
     part: DataTableSummaryPart;
     within?: string;
+    sum?: string;
+    where?: string;
 } | {
     key: string;
     id: string;
@@ -278,6 +464,10 @@ export type DataTableSummaryCardRequest = {
     period: DataTableSummaryPeriod;
     count: number;
     split?: string;
+    sum?: string;
+    where?: string;
+    from?: string;
+    to?: string;
 } | {
     key: string;
     id: string;
@@ -331,6 +521,7 @@ export interface DataTableRowAction<TData = any> {
     showWhen?: (row: TData) => boolean;
     disabledWhen?: (row: TData) => boolean;
     tooltip?: string | ((row: TData) => string);
+    disableTextTransform?: boolean;
     primary?: boolean | ((row: TData) => boolean);
     shortcut?: string;
 }
@@ -486,6 +677,18 @@ export interface DataTableBulkAction<TData = any> {
     undoTimeoutMs?: number;
     onRun: (ctx: DataTableBulkActionContext<TData>) => Promise<DataTableBulkActionResult | void> | DataTableBulkActionResult | void;
 }
+export interface DataTableToolbarAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    variant?: ActionVariant;
+    display?: 'icon' | 'label' | 'icon-label';
+    tooltip?: string;
+    disabled?: boolean;
+    priority?: number;
+    authorize?: () => boolean;
+    onClick: () => void;
+}
 export interface DataTableColumnPinning {
     left: string[];
     right: string[];
@@ -632,6 +835,7 @@ export interface DataTableExportMetadata {
     selectedRows: number;
     labels?: Partial<DataTableLabels>;
     locale?: string;
+    notes?: string[];
 }
 export type DataTableExportFormat = 'csv' | 'xlsx' | 'json' | 'pdf' | 'html' | 'xml';
 export type DataTableExportAction = 'download' | 'share' | 'preview' | 'print';
@@ -778,6 +982,10 @@ export interface DataTableExportTemplate<TData = any> {
     };
     onResult?: (data: TData[], meta: DataTableExportMeta) => DataTableExportResult | undefined;
     license?: DataTableLicense;
+    headerGroups?: boolean;
+    csvGroupRows?: boolean;
+    treeLevel?: boolean;
+    pinnedRows?: boolean;
 }
 export type DataTableFileNameAs = 'title' | 'title-date' | 'title-generated' | 'title-date-generated';
 export interface DataTableQuickExport<TData = any> {
@@ -790,6 +998,8 @@ export interface DataTableQuickExport<TData = any> {
     summary?: (rows: TData[]) => Record<string, string | number>;
     xlsx?: DataTableXlsxStyle;
     pdf?: DataTablePdfConfig;
+    csvGroupRows?: boolean;
+    pinnedRows?: boolean;
     generate?: Partial<Record<DataTableExportFormat, DataTableExportGenerator<TData>>>;
 }
 export interface DataTableExportConfig<TData = any> {
@@ -873,6 +1083,7 @@ export interface DataTableManagePrefs {
 export interface DataTableView<TData = any> {
     columns: DataTableColumn<TData>[];
     resolveColumns?: (data: TData[]) => DataTableColumn<TData>[];
+    columnGroups?: DataTableColumnGroup[];
     id: string;
     renamed?: Record<string, string>;
     label?: string;
@@ -883,7 +1094,11 @@ export interface DataTableView<TData = any> {
     rowKey?: string;
     transform?: (data: any[]) => any[];
     animateRows?: boolean;
+    rowChanges?: DataTableRowChanges;
+    flash?: boolean;
     flashColors?: DataTableFlashColors;
+    flashStyle?: DataTableCellFlashStyle;
+    flashDuration?: number;
     HeaderComponent?: ComponentType<DataTableComponentProps<TData> & Record<string, any>>;
     FooterComponent?: ComponentType<DataTableComponentProps<TData> & Record<string, any>>;
     headerProps?: Record<string, any>;
@@ -904,8 +1119,14 @@ export interface DataTableView<TData = any> {
     inlineActions?: number;
     actionsHeader?: boolean;
     bulkActions?: DataTableBulkAction<TData>[];
+    toolbarActions?: DataTableToolbarAction[];
     hideBulkActions?: string[];
     pinning?: DataTablePinningConfig;
+    rowPinning?: boolean | DataTableRowPinningConfig;
+    cellSelection?: boolean | DataTableCellSelectionConfig<TData>;
+    rowDrag?: boolean | DataTableRowDragConfig<TData>;
+    treeData?: DataTableTreeDataConfig<TData>;
+    pivot?: boolean | DataTablePivotConfig<TData>;
     devTools?: boolean;
     singleRowView?: DataTableSingleRowView;
     cardFields?: Partial<DataTableCardFields>;
@@ -924,6 +1145,7 @@ export interface DataTableView<TData = any> {
     bordered?: boolean;
     stickyHeader?: boolean;
     emptyMessage?: string;
+    noResultsMessage?: string;
     loadingMessage?: string;
     loading?: boolean;
 }
@@ -943,6 +1165,10 @@ export interface DataTableProps<TData = any> {
     apiRef?: {
         current: DataTableApi<TData> | null;
     };
+    pinnedRows?: {
+        top?: TData[];
+        bottom?: TData[];
+    };
     bulkActions?: DataTableBulkAction<TData>[];
     labels?: Partial<DataTableLabels>;
     locale?: string;
@@ -950,6 +1176,11 @@ export interface DataTableProps<TData = any> {
     detailBar?: boolean;
     openRowId?: string | null;
     onOpenRowChange?: (id: string | null, row: TData | null) => void;
+    onRowOrderChange?: (change: DataTableRowOrderChange<TData>) => void;
+    pivot?: DataTablePivotState;
+    onPivotChange?: (state: DataTablePivotState, ctx: {
+        viewId: string;
+    }) => void;
     shortcuts?: DataTableShortcut<TData>[];
     sharing?: DataTableSharing;
     renamedViews?: Record<string, string>;
@@ -978,6 +1209,13 @@ export interface DataTableAllRowsResult<TData = any> {
     rows: TData[];
     total?: number;
     capped?: boolean;
+    tree?: boolean;
+}
+export interface DataTableExportTreeRequest {
+    withChildren: true;
+    rowKey: string;
+    shape: 'nested' | 'flat';
+    parentField?: string;
 }
 export interface DataTableCounts {
     views?: Record<string, number>;
@@ -992,6 +1230,7 @@ export interface DataTableDataSource<TData = any> {
         action: DataTableExportAction;
         selection: DataTableSelection<TData>;
         params?: Record<string, unknown>;
+        tree?: DataTableExportTreeRequest;
     }) => Promise<DataTableAllRowsResult<TData>>;
     summaries?: (query: DataTableQuery, ctx: {
         selection: DataTableSelection<TData>;
@@ -1010,6 +1249,14 @@ export interface DataTableDataSource<TData = any> {
     }, ctx: {
         signal: AbortSignal;
     }) => Promise<DataTableGroupResult[]>;
+    children?: (parent: TData, ctx: {
+        query: DataTableQuery;
+        signal: AbortSignal;
+    }) => Promise<TData[]>;
+    pivot?: (query: DataTableQuery, ctx: {
+        request: DataTablePivotRequest;
+        signal: AbortSignal;
+    }) => Promise<DataTablePivotResult>;
     operators?: readonly string[];
     summaryBreakdownFields?: readonly string[];
     subscribe?: (refetch: () => void) => () => void;
@@ -1028,12 +1275,44 @@ export interface DataTableInitialState {
     pageIndex?: number;
     pageSize?: number;
 }
+export interface DataTableRowTransaction<TData = any> {
+    add?: TData[];
+    addAt?: 'start' | 'end';
+    update?: Array<Partial<TData>>;
+    remove?: Array<TData | string | number>;
+}
+export interface DataTableTransactionResult {
+    added: string[];
+    updated: string[];
+    removed: string[];
+}
+export interface DataTableTransactionOptions {
+    keepPlace?: boolean;
+}
 export interface DataTableApi<TData = any> {
+    applyTransaction: (transaction: DataTableRowTransaction<TData>, options?: DataTableTransactionOptions) => DataTableTransactionResult | null;
+    applyTransactionAsync: (transaction: DataTableRowTransaction<TData>, options?: DataTableTransactionOptions) => void;
+    scrollToRow: (id: string, options?: {
+        flash?: boolean;
+    }) => boolean;
+    getRowPage: (id: string) => number | null;
+    flashRows: (ids: string[]) => void;
+    pauseUpdates: () => void;
+    resumeUpdates: () => void;
     refresh: () => void;
     clearSelection: () => void;
     getQuery: () => DataTableQuery;
     getRows: () => TData[];
     openRow: (id: string | null) => void;
+    pinRow: (id: string, side: DataTableRowPinSide | null, row?: TData) => boolean;
+    getPinnedRows: () => {
+        top: TData[];
+        bottom: TData[];
+    };
+    getCellRanges: () => DataTableCellRange[];
+    clearCellRanges: () => void;
+    getPivot: () => DataTablePivotState | null;
+    setPivot: (state: DataTablePivotState | null) => void;
 }
 export interface DataTablePersistence {
     load: (key: string) => Promise<Record<string, any> | null>;
@@ -1041,7 +1320,7 @@ export interface DataTablePersistence {
     list?: (prefix: string) => Promise<string[]>;
     remove?: (key: string) => Promise<void>;
 }
-export type DataTableGate = 'export' | 'export.format' | 'export.template' | 'manage' | 'selection' | 'columns' | 'cardFields' | 'savedFilters' | 'devTools' | 'license' | 'bulkAction' | 'copy' | 'layout' | 'grouping' | 'shareView' | 'rows';
+export type DataTableGate = 'export' | 'export.format' | 'export.template' | 'manage' | 'selection' | 'columns' | 'cardFields' | 'savedFilters' | 'devTools' | 'license' | 'bulkAction' | 'toolbarAction' | 'copy' | 'layout' | 'grouping' | 'shareView' | 'rows';
 export type DataTableAuthorize = (gate: DataTableGate, subject?: unknown) => boolean;
 export interface DataTablePdfFonts {
     fonts?: Record<string, {
@@ -1072,6 +1351,8 @@ export interface DataTableDisplayPrefs {
     showActions: boolean;
     actionDisplayMode: DataTableActionDisplay;
     actionDisplayModeCard: DataTableActionDisplay;
+    maxVisibleActions?: number;
+    maxVisibleActionsCard?: number;
     summaryTop: boolean;
     summaryBottom: boolean;
 }
@@ -1090,6 +1371,8 @@ export interface DataTableViewPrefs {
     filterRow?: boolean;
     grouping?: string[];
     summary?: DataTableSummaryPrefs;
+    pinnedRows?: DataTableRowPins;
+    pivot?: DataTablePivotState;
 }
 export interface ContextMenuState {
     visible: boolean;
@@ -1111,6 +1394,7 @@ export interface UseTableReturn<TData = any> {
     clearAllFilters: () => void;
     globalFilter: string;
     setGlobalFilter: (value: string) => void;
+    searchApplied: string;
     sorting: Array<{
         id: string;
         desc: boolean;

package/dist/types/components/DataTable/ui-local/TableReorderList.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import './ui-local.css';
+interface TableReorderListProps<T> {
+    items: readonly T[];
+    getKey: (item: T) => string;
+    getItemLabel: (item: T) => string;
+    onReorder?: (items: T[]) => void;
+    renderItem: (item: T, dragHandle: React.ReactNode) => React.ReactNode;
+    maxHeight?: string;
+    className?: string;
+}
+export declare function TableReorderList<T>({ items, getKey, getItemLabel, onReorder, renderItem, maxHeight, className }: TableReorderListProps<T>): React.JSX.Element;
+export {};

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

@@ -7,7 +7,8 @@ export { Tabs as SmartTabs } from '../Tabs';
 export { DropdownMenu as SmartDropdownMenu } from '../DropdownMenu';
 export { Dialog as SmartDialog } from '../Dialog';
 export { Badge as SmartBadge } from '../Badge';
+export { ReorderList } from '../ReorderList';
 export { ReactModal } from './ui-local/ReactModal';
-export { DragAndDropList } from './ui-local/DragAndDropList';
+export { TableReorderList } from './ui-local/TableReorderList';
 export { AutoHeight } from './ui-local/AutoHeight';
 export { DateRangePicker } from './ui-local/DateRangePicker';

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

@@ -2,10 +2,17 @@ import { type DataTableColumn, type DataTableView, type DataTableFlashColor } fr
 export interface CellChange {
     direction: 'up' | 'down' | 'changed';
     newValue?: any;
+    seq: number;
+    duration: number;
 }
-export declare const FLASH_COLOR_MAP: Record<DataTableFlashColor, {
+export declare function flashCssColors(color: DataTableFlashColor): {
     bg: string;
     text: string;
-}>;
-export declare function resolveFlashColor(change: CellChange, column: DataTableColumn, config: DataTableView): DataTableFlashColor;
-export declare function useDataChangeTracker(data: any[], rowKey: string | undefined, columns: DataTableColumn[]): Map<string, Map<string, CellChange>>;
+};
+export declare function resolveFlashColor(change: Pick<CellChange, 'direction' | 'newValue'>, column: DataTableColumn, config: DataTableView): DataTableFlashColor;
+export declare function changeDirection<T>(column: DataTableColumn<T>, next: unknown, previous: unknown, row: T): CellChange['direction'] | null;
+export declare const FLASH_DURATION = 1500;
+export declare function useDataChangeTracker(data: any[], rowKey: string | undefined, columns: DataTableColumn[], opts?: {
+    enabled?: boolean;
+    duration?: number;
+}): ReadonlyMap<string, ReadonlyMap<string, CellChange>>;

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

@@ -1,15 +1,28 @@
 import type { UIFormat } from '../../core/types';
 import { type ColumnTextContext } from './columnValue';
-import { type DataTableView, type DataTableColumn, type UseTableReturn, type DataTableInitialState } from './types';
+import { type ColumnDef } from '@tanstack/react-table';
+import { type HeldRows } from './data/rowModels';
+import { type DataTableView, type DataTableColumn, type DataTableFilterGroup, type UseTableReturn, type DataTableInitialState } from './types';
 import { type DataTableLabels } from './labels';
+export interface SearchText {
+    text: string;
+    folded: string;
+    ascii?: boolean;
+}
+export declare function searchText(text: string): SearchText;
+export declare function rankText(cell: SearchText | string, value: string): import("@tanstack/match-sorter-utils").RankingInfo;
 export declare function rowMatchesSearch<TData>(row: TData, columns: DataTableColumn<TData>[], search: string, ctx?: ColumnTextContext): boolean;
+export declare function buildColumnDefs<TData>(columns: DataTableColumn<TData>[], ctx: ColumnTextContext, isDesc?: (columnId: string) => boolean): ColumnDef<TData, any>[];
 export interface UseTableOptions {
     serverMode?: boolean;
     rowCount?: number;
     initialState?: DataTableInitialState;
     defaultPageSize?: number;
+    pageSizeOptions?: number[];
     labels?: DataTableLabels;
     format?: UIFormat;
     customPaging?: boolean;
+    heldRows?: HeldRows;
+    treeFilter?: (data: any[], filterGroup: DataTableFilterGroup, search: string) => any[];
 }
 export declare function useTable<TData = any>(data: TData[], config: DataTableView<TData>, options?: UseTableOptions): UseTableReturn<TData>;

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

@@ -7,6 +7,7 @@ export interface VirtualOptions {
 }
 export interface ScrollApi {
     scrollToIndex: (index: number) => void;
+    scrollToKey?: (key: string) => boolean;
 }
 export declare const DEFAULT_OVERSCAN = 8;
 export declare const DEFAULT_ROW_ESTIMATE = 44;

package/dist/types/components/DatePicker/PeriodGrid.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { IsoPeriod, PeriodGridView } from '../../core/logic';
+export interface PeriodGridProps {
+    view: PeriodGridView;
+    label: string;
+    multi?: boolean;
+    cellId: (period: IsoPeriod) => string;
+    cellText: (period: IsoPeriod) => string;
+    cellLabel: (period: IsoPeriod) => string;
+    onPick: (period: IsoPeriod) => void;
+}
+export declare const PeriodGrid: React.FC<PeriodGridProps>;
+export default PeriodGrid;

package/dist/types/components/DatePicker/PeriodPicker.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { DatePickerBaseProps, DateRangeValue, FieldChangeEvent, FieldHandle, FieldKeyboardConfig } from '../../core/types';
+import { type PeriodMode } from '../../core/logic';
+export declare const BOX_KEYBOARD: FieldKeyboardConfig;
+export type PeriodPickerProps = DatePickerBaseProps & {
+    mode: PeriodMode;
+    range?: boolean;
+    value?: string | DateRangeValue;
+    onChange?: (event: FieldChangeEvent<string | DateRangeValue>) => void;
+    onApply?: (value: string | DateRangeValue) => void;
+};
+declare const PeriodPicker: React.ForwardRefExoticComponent<DatePickerBaseProps & {
+    mode: PeriodMode;
+    range?: boolean;
+    value?: string | DateRangeValue;
+    onChange?: (event: FieldChangeEvent<string | DateRangeValue>) => void;
+    onApply?: (value: string | DateRangeValue) => void;
+} & React.RefAttributes<FieldHandle>>;
+export default PeriodPicker;

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

@@ -1,4 +1,4 @@
 export { default as DatePicker } from './DatePicker';
 export { default as Calendar } from './Calendar';
 export type { CalendarProps } from './Calendar';
-export type { DatePickerProps, DatePickerBaseProps, DatePickerSingleProps, DatePickerRangeProps, DateRangeValue, DateDisplayFormat, DateTextOrder, } from '../../core/types';
+export type { DatePickerProps, DatePickerBaseProps, DatePickerSingleProps, DatePickerRangeProps, DateRangeValue, DatePickerMode, DateDisplayFormat, DateTextOrder, } from '../../core/types';

package/dist/types/components/Dialog/dialogSlots.d.ts

@@ -0,0 +1,9 @@
+export type DialogSlotName = 'header' | 'footer';
+export interface DialogSlots {
+    headerEl: HTMLElement | null;
+    footerEl: HTMLElement | null;
+    claim: (slot: DialogSlotName) => () => void;
+}
+export declare const DialogSlotsContext: import("react").Context<DialogSlots | null>;
+export declare const useDialogSlots: () => DialogSlots | null;
+export declare function useDialogSlotClaim(slots: DialogSlots | null, slot: DialogSlotName, active: boolean): void;