@dcs-tech/ui 0.10.0 → 0.11.0

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

@@ -0,0 +1,60 @@
+import { type TreeExpansion, type TreeIndex } from '../../../core/logic';
+import { type ColumnTextContext } from '../columnValue';
+import type { DisplayItem } from '../grouping/groupModel';
+import type { DataTableColumn, DataTableFilterGroup, DataTableTreeDataConfig } from '../types';
+export interface TreeConfig<T> {
+    getChildren?: (row: T) => T[] | null | undefined;
+    parentField?: string;
+    defaultExpanded: boolean | number;
+    filterMode: 'ancestors' | 'matches';
+    totals: 'leaves' | 'all';
+    selectChildren: boolean;
+    exportLevel: 'column' | 'indent';
+    hasChildren?: (row: T) => boolean;
+}
+export declare function resolveTreeConfig<T>(cfg: DataTableTreeDataConfig<T> | undefined, rowKey: string | undefined): TreeConfig<T> | null;
+export declare function createTreeRowSearch<T>(columns: DataTableColumn<T>[], ctx: ColumnTextContext): (row: T, value: string) => boolean;
+export interface TreeMoved<T> {
+    rows: T[];
+    nodes: T[];
+    parentOf: ReadonlyMap<string, string | null>;
+}
+export declare function useTreeSource<T>(opts: {
+    config: TreeConfig<T> | null;
+    rows: T[];
+    rowKey: string | undefined;
+    serverMode: boolean;
+    columns: DataTableColumn<T>[];
+    text: ColumnTextContext;
+    viewId: string;
+    extraParents?: ReadonlyMap<string, string>;
+    moved?: TreeMoved<T> | null;
+}): {
+    on: boolean;
+    index: TreeIndex<T> | null;
+    idOf: (r: T) => string;
+    nodes: T[];
+    treeFilter: ((data: T[], group: DataTableFilterGroup, value: string) => T[]) | undefined;
+    openForMatches: () => ReadonlySet<string>;
+    flatMatches: () => boolean;
+    expansion: TreeExpansion;
+    toggle: (id: string, shownOpen: boolean) => void;
+    open: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    reopenMatches: () => void;
+    descendants: (id: string) => string[];
+};
+export type TreeSource<T> = ReturnType<typeof useTreeSource<T>>;
+export declare function useTreeLines<R extends {
+    id: string;
+}>(tree: TreeSource<any>, rows: R[] | null, opts: {
+    status?: (id: string) => 'loading' | 'error' | 'done' | undefined;
+    canLoad?: (row: R) => boolean;
+}): {
+    lines: DisplayItem[] | null;
+    ordered: () => {
+        row: R;
+        depth: number;
+    }[] | null;
+};

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';
@@ -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,6 +392,8 @@ 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';
@@ -220,9 +401,10 @@ export interface DataTableSummaryFunnelCard<TData = any> extends DataTableSummar
     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];
@@ -272,6 +454,8 @@ export type DataTableSummaryCardRequest = {
     field: string;
     part: DataTableSummaryPart;
     within?: string;
+    sum?: string;
+    where?: string;
 } | {
     key: string;
     id: string;
@@ -280,6 +464,10 @@ export type DataTableSummaryCardRequest = {
     period: DataTableSummaryPeriod;
     count: number;
     split?: string;
+    sum?: string;
+    where?: string;
+    from?: string;
+    to?: string;
 } | {
     key: string;
     id: string;
@@ -497,6 +685,7 @@ export interface DataTableToolbarAction {
     display?: 'icon' | 'label' | 'icon-label';
     tooltip?: string;
     disabled?: boolean;
+    priority?: number;
     authorize?: () => boolean;
     onClick: () => void;
 }
@@ -646,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';
@@ -792,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> {
@@ -804,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> {
@@ -887,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;
@@ -897,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>;
@@ -921,6 +1122,11 @@ export interface DataTableView<TData = any> {
     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>;
@@ -959,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;
@@ -966,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>;
@@ -994,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>;
@@ -1008,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>;
@@ -1026,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;
@@ -1044,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>;
@@ -1088,6 +1351,8 @@ export interface DataTableDisplayPrefs {
     showActions: boolean;
     actionDisplayMode: DataTableActionDisplay;
     actionDisplayModeCard: DataTableActionDisplay;
+    maxVisibleActions?: number;
+    maxVisibleActionsCard?: number;
     summaryTop: boolean;
     summaryBottom: boolean;
 }
@@ -1106,6 +1371,8 @@ export interface DataTableViewPrefs {
     filterRow?: boolean;
     grouping?: string[];
     summary?: DataTableSummaryPrefs;
+    pinnedRows?: DataTableRowPins;
+    pivot?: DataTablePivotState;
 }
 export interface ContextMenuState {
     visible: boolean;
@@ -1127,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/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,8 +1,18 @@
 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;
@@ -12,5 +22,7 @@ export interface UseTableOptions {
     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/EventCalendar/EventCalendar.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import type { CalendarDateInput, CalendarEvent, CalendarEventChange, CalendarViewType } from '../../core/types';
+import { type IsoDay } from '../../core/logic';
+export interface EventCalendarRenderInfo {
+    place: 'grid' | 'time' | 'list';
+    allDay: boolean;
+    multiDay: boolean;
+    timeText: string;
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+}
+export interface EventCalendarProps<T extends CalendarEvent = CalendarEvent> {
+    events: readonly T[];
+    view?: CalendarViewType;
+    defaultView?: CalendarViewType;
+    onViewChange?: (view: CalendarViewType) => void;
+    views?: readonly CalendarViewType[];
+    date?: CalendarDateInput;
+    defaultDate?: CalendarDateInput;
+    onDateChange?: (date: IsoDay) => void;
+    month?: CalendarDateInput;
+    defaultMonth?: CalendarDateInput;
+    onMonthChange?: (month: IsoDay) => void;
+    weekStart?: number;
+    maxEventRows?: number;
+    maxAllDayRows?: number;
+    fixedWeeks?: boolean;
+    slotMinutes?: number;
+    dayStartHour?: number;
+    dayEndHour?: number;
+    scrollToHour?: number;
+    today?: CalendarDateInput;
+    locale?: string;
+    onEventClick?: (event: T) => void;
+    onDayClick?: (day: IsoDay) => void;
+    onSlotClick?: (dateTime: string) => void;
+    editable?: boolean;
+    onEventChange?: (change: CalendarEventChange<T>) => void;
+    canChange?: (event: T, start: string, end: string | undefined, allDay: boolean) => boolean;
+    renderEvent?: (event: T, info: EventCalendarRenderInfo) => React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    'aria-label'?: string;
+}
+declare function EventCalendar<T extends CalendarEvent = CalendarEvent>({ events, view: viewProp, defaultView, onViewChange, views, date: dateProp, defaultDate, onDateChange, month: monthProp, defaultMonth, onMonthChange, weekStart: weekStartProp, maxEventRows, maxAllDayRows, fixedWeeks, slotMinutes: slotProp, dayStartHour, dayEndHour, scrollToHour, today: todayProp, locale: localeProp, onEventClick, onDayClick, onSlotClick, editable: editableProp, onEventChange, canChange, renderEvent, className, style, 'aria-label': ariaLabel, }: EventCalendarProps<T>): React.ReactElement;
+export default EventCalendar;

package/dist/types/components/EventCalendar/eventParts.d.ts

@@ -0,0 +1,10 @@
+import type React from 'react';
+import type { CalendarEvent } from '../../core/types';
+import { type EventCalendarText, type PlacedCalendarEvent } from '../../core/logic';
+import type { UILabels } from '../UIProvider/UILabelsContext';
+export declare const PREVIEW_KEY = "\0ec-preview";
+export declare const colorStyle: (event: CalendarEvent) => React.CSSProperties;
+export declare function eventWhen(item: PlacedCalendarEvent<CalendarEvent>, text: EventCalendarText, L: UILabels['eventCalendar']): string;
+export declare function eventName(item: PlacedCalendarEvent<CalendarEvent>, text: EventCalendarText, L: UILabels['eventCalendar']): string;
+export declare function eventTail(item: PlacedCalendarEvent<CalendarEvent>, text: EventCalendarText, L: UILabels['eventCalendar']): string;
+export declare const cx: (...names: Array<string | false | null | undefined>) => string;

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

@@ -0,0 +1,3 @@
+export { default as EventCalendar } from './EventCalendar';
+export type { EventCalendarProps, EventCalendarRenderInfo } from './EventCalendar';
+export type { CalendarEvent, CalendarEventColor, CalendarDateInput, CalendarViewType, CalendarEventChange } from '../../core/types';