@dcs-tech/ui 0.9.0 → 0.11.0

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

@@ -1,14 +1,19 @@
 import React, { type ReactNode } from 'react';
 import type { RowPressHandlers } from '../rows/rowPress';
-import type { ListParts, RowParts } from './rowParts';
+import type { RowParts } from './rowParts';
 import { type ScrollApi, type VirtualOptions } from '../virtual/useVirtualLines';
+import { type MotionItem } from '../motion/useRowMotion';
+import type { RowChangesOptions } from '../motion/rowChanges';
 export interface CardRow {
     id: string;
-    parts: RowParts;
-    list: ListParts | null;
+    original: unknown;
+    index: number;
     selected: boolean;
     selectable: boolean;
 }
+export declare function useRowLines(rows: CardRow[], linesProp: CardLine[] | undefined): CardLine[];
+export declare function withoutLeavingLines(items: Array<MotionItem<CardLine>>): Array<MotionItem<CardLine>>;
+export declare function useKeyOrder<L>(lines: L[], keyOf: (line: L | undefined, at: number) => string): object;
 export type CardLine = {
     kind: 'row';
     key: string;
@@ -20,12 +25,13 @@ export type CardLine = {
     level: number;
     expanded?: boolean;
 };
-export interface MotionOptions {
+export interface MotionOptions extends Partial<RowChangesOptions> {
     enabled: boolean;
     resetKey: string | undefined;
 }
 interface CardViewProps {
     rows: CardRow[];
+    partsOf: (row: CardRow) => RowParts;
     lines?: CardLine[];
     checkboxes: boolean;
     onToggle: (id: string) => void;
@@ -40,11 +46,25 @@ interface CardViewProps {
     virtual?: VirtualOptions | null;
     scrollApi?: React.MutableRefObject<ScrollApi | null>;
     motion?: MotionOptions;
+    renderLead?: (id: string) => ReactNode;
 }
 export declare function CardContent({ parts, open }: {
     parts: RowParts;
     open: boolean;
 }): React.JSX.Element;
+interface CardChunk {
+    key: string;
+    lines: Array<MotionItem<CardLine>>;
+}
+interface CardChunks {
+    list: CardChunk[];
+    order: object;
+    shown: Array<MotionItem<CardLine>>;
+    perLine: number;
+    chunkOf: Int32Array;
+    placeIn: Int32Array;
+}
+export declare function chunkLines(shown: Array<MotionItem<CardLine>>, perLine: number, before: CardChunks | null): CardChunks;
 export declare function cardsPerLine(width: number, minCard: number, gap?: number): number;
-export declare function CardView({ rows, lines: linesProp, checkboxes, onToggle, press, renderActions, allExpanded, minCardWidth, focusable, activeKey, placeholder, loading, virtual, scrollApi, motion }: CardViewProps): React.JSX.Element;
+export declare function CardView({ rows, partsOf, lines: linesProp, checkboxes, onToggle, press, renderActions, allExpanded, minCardWidth, focusable, activeKey, placeholder, loading, virtual, scrollApi, motion, renderLead }: CardViewProps): React.JSX.Element;
 export default CardView;

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

@@ -15,6 +15,7 @@ export declare function sameFields<K extends string>(set: FieldSet<K>, a: Fields
 export declare function unplacedColumns<K extends string>(set: FieldSet<K>, fields: Fields<K>, columns: DataTableColumn[]): DataTableColumn[];
 export declare function placeField<K extends string>(set: FieldSet<K>, fields: Fields<K>, key: string, part: K | null, opts?: {
     replace?: boolean;
+    index?: number;
 }): Fields<K>;
 export declare function partForAdd<K extends string>(set: FieldSet<K>, fields: Fields<K>): K | null;
 export declare const isCardFields: (value: unknown) => value is Partial<DataTableCardFields>;

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

@@ -34,5 +34,6 @@ export declare function RowAvatar({ text, size }: {
 }): React.JSX.Element;
 export declare function rowParts<T>(row: T, index: number, fields: DataTableCardFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>, labels: CellTextLabels): RowParts;
 export declare function listParts<T>(row: T, index: number, fields: DataTableListFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>, labels: CellTextLabels): ListParts;
+export declare function partsCache<T, P>(build: (row: T, index: number) => P): (row: T, index: number) => P;
 export declare function sampleRowParts<T>(fields: DataTableCardFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>): RowParts;
 export declare function sampleListParts<T>(fields: DataTableListFields, byKey: Map<string, DataTableColumn<T>>, avatar: AvatarOption<T>): ListParts;

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { CellRangeFigureId } from '../../../core/logic';
+import type { CellRangeStore } from './cellRangeStore';
+import type { CellRangeSummary } from './useCellSelection';
+import './cellSelection.css';
+interface CellRangeBarProps {
+    store: CellRangeStore;
+    summary: (limit?: number) => CellRangeSummary | null | 'large';
+    figures: CellRangeFigureId[];
+    rowsVersion: unknown;
+    onCopy?: () => void;
+    onClear: () => void;
+    onMenu?: () => void;
+}
+export declare const CellRangeBar: React.NamedExoticComponent<CellRangeBarProps>;
+export {};

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

@@ -0,0 +1,18 @@
+export interface RangeCorner {
+    row: string;
+    col: string;
+}
+export interface StoredRange {
+    start: RangeCorner;
+    end: RangeCorner;
+}
+export type RangePhase = 'drag' | 'done';
+export interface CellRangeStore {
+    get: () => readonly StoredRange[];
+    phase: () => RangePhase;
+    touch: () => boolean;
+    set: (ranges: readonly StoredRange[], phase: RangePhase, touch?: boolean) => void;
+    subscribe: (fn: (phase: RangePhase) => void) => () => void;
+}
+export declare const sameCorner: (a: RangeCorner, b: RangeCorner) => boolean;
+export declare function createCellRangeStore(): CellRangeStore;

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

@@ -0,0 +1,2 @@
+import { type CellRect } from '../../../core/logic';
+export declare function paintRanges(root: ParentNode, rects: readonly CellRect[], rowIndex: (key: string, near?: number) => number, painted: ReadonlySet<HTMLElement>, handles?: CellRect | null): Set<HTMLElement>;

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

@@ -0,0 +1,63 @@
+import type React from 'react';
+import { type RefObject } from 'react';
+import { type CellRangeFigureId, type CellRangeFigures } from '../../../core/logic';
+import type { DisplayItem } from '../grouping/groupModel';
+import type { DataTableCellPaste, DataTableCellRange, DataTableCellSelectionConfig } from '../types';
+import { type CellRangeStore } from './cellRangeStore';
+export interface ResolvedCellSelection {
+    multiRange: boolean;
+    copyHeaders: boolean;
+    figures: CellRangeFigureId[];
+    onCellRangesChange?: (ranges: DataTableCellRange[]) => void;
+    onCellsPaste?: (event: {
+        cells: DataTableCellPaste[];
+    }) => void;
+}
+export declare function resolveCellSelection(cfg: boolean | DataTableCellSelectionConfig | undefined): ResolvedCellSelection | null;
+export interface CellRangeSummary {
+    cells: number;
+    rows: number;
+    columns: number;
+    ranges: number;
+    figures: CellRangeFigures;
+}
+export interface CellSelectionHost<R> {
+    config: ResolvedCellSelection | null;
+    areaRef: RefObject<HTMLElement | null>;
+    items: DisplayItem<R>[];
+    columns: string[];
+    rowId: (row: R) => string;
+    original: (row: R) => unknown;
+    valueOf: (row: R, column: string) => unknown;
+    isNumber: (column: string) => boolean;
+    textOf: (row: R, column: string) => string;
+    headerOf: (column: string) => string;
+    canCopy: boolean;
+    copy: (text: string, cells: number) => void;
+    selectRows: (ids: string[]) => void;
+    pasted: (cells: number) => void;
+    activeKey: string | null;
+    activeCol: number;
+    resetKey?: string;
+}
+export interface CellKeyContext {
+    key: string;
+    col: number;
+    row: boolean;
+    focus: (key: string, col: number) => void;
+}
+export declare function useCellSelection<R>(host: CellSelectionHost<R>): {
+    enabled: boolean;
+    store: CellRangeStore;
+    onKey: (e: React.KeyboardEvent, at: CellKeyContext) => boolean;
+    getCellRanges: () => DataTableCellRange[];
+    clearCellRanges: () => void;
+    summary: (limit?: number) => CellRangeSummary | null | "large";
+    copyRanges: () => void;
+    pasteText: (text: string) => boolean;
+    ownsLongPress: (t: EventTarget | null) => boolean;
+    lastCell: () => {
+        row: R;
+        column: string;
+    } | null;
+};

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

@@ -0,0 +1,27 @@
+export interface ListDelta<E> {
+    readonly removed: readonly E[];
+    readonly removedAt: readonly number[];
+    readonly added: readonly E[];
+    readonly addedAt: readonly number[];
+}
+export declare const NO_CHANGE: ListDelta<never>;
+export declare const deltaSize: (d: ListDelta<unknown>) => number;
+export declare function recordListDelta<E>(next: readonly E[], before: readonly E[], delta: ListDelta<E>): void;
+export declare function listDeltaBetween<E>(next: readonly E[], before: readonly E[] | null | undefined): ListDelta<E> | null;
+export declare function composeDeltas<E>(ab: ListDelta<E>, bc: ListDelta<E>): ListDelta<E>;
+export declare function placesIn<T>(list: readonly T[], wanted: readonly T[]): number[];
+export declare function patchList<E, O>(before: readonly O[], delta: ListDelta<E>, make: (element: E, at: number) => O): O[];
+export declare function mapDelta<E, O>(delta: ListDelta<E>, before: readonly O[], out: readonly O[]): ListDelta<O>;
+export declare function deltaOfElements<E>(before: readonly E[], next: readonly E[], removed: readonly E[], added: readonly E[]): ListDelta<E>;
+export interface MappedList<E, O> {
+    source: readonly E[] | null;
+    out: O[];
+}
+export declare function newMappedList<E, O>(): MappedList<E, O>;
+export declare function mapList<E, O>(cache: MappedList<E, O>, source: readonly E[], make: (element: E, at: number) => O, opts?: {
+    reuse?: boolean;
+}): O[];
+export declare function patchFilteredList<T>(before: {
+    data: readonly T[];
+    out: T[];
+}, data: readonly T[], delta: ListDelta<T>, test: (element: T) => boolean, known: WeakMap<object, boolean>): T[] | null;

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

@@ -0,0 +1,3 @@
+export declare function markRowsChangedFrom(next: readonly unknown[], from: readonly unknown[]): void;
+export declare function markRowsTakenFrom(next: readonly unknown[], from: readonly unknown[]): void;
+export declare function rowObjectsUnchanged(next: readonly unknown[], before: readonly unknown[]): boolean;

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

@@ -0,0 +1,9 @@
+import { type RowData, type RowModel, type Table } from '@tanstack/react-table';
+export declare function getReusingCoreRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+export declare function getPatchingFilteredRowModel<TData extends RowData>(): (table: Table<TData>) => () => RowModel<TData>;
+export type HeldRows = ReadonlyMap<string, string | null>;
+export declare function placeHeldRows<R extends {
+    id: string;
+}>(rows: R[], held: HeldRows | null | undefined): R[];
+export declare function getMergingSortedRowModel<TData extends RowData>(getHeld?: () => HeldRows | null | undefined): (table: Table<TData>) => () => RowModel<TData>;
+export declare function mergeSorted<T>(a: T[], b: T[], compare: (x: T, y: T) => number): T[];

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

@@ -0,0 +1,9 @@
+import type { DataTableRowTransaction } from '../types';
+export declare const TRANSACTION_WAIT_MS = 50;
+export declare function mergeRowTransactions<T>(txs: Array<DataTableRowTransaction<T>>): Array<DataTableRowTransaction<T>>;
+export interface RowTransactionResult {
+    added: string[];
+    updated: string[];
+    removed: string[];
+}
+export declare function applyRowTransaction<T>(rows: T[], tx: DataTableRowTransaction<T>, rowKey: string | undefined, out?: RowTransactionResult): T[];

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

@@ -1,4 +1,5 @@
-import type { DataTableDataSource, DataTableQuery } from '../types';
+import type { DataTableDataSource, DataTableQuery, DataTableRowTransaction } from '../types';
+import { type RowTransactionResult } from './rowTransaction';
 export interface ServerDataState<TData> {
     rows: TData[];
     total: number;
@@ -7,6 +8,7 @@ export interface ServerDataState<TData> {
     fetching: boolean;
     error: unknown;
     refetch: () => void;
+    applyTransaction: (tx: DataTableRowTransaction<TData>, rowKey: string | undefined) => RowTransactionResult | null;
     tick: number;
 }
 export declare function filterPartOf(q: DataTableQuery): {

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

@@ -1,6 +1,7 @@
 import { type DataTableView, type DataTablePaginationConfig, type DataTableSortingConfig, type DataTableFilteringConfig, type DataTableSelectionConfig, type DataTableFilterGroup, type DataTableExportConfig, type DataTableExportFormat } from './types';
 export declare const DEFAULT_PAGE_SIZE = 25;
 export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
+export declare const DEFAULT_SERVER_PAGE_SIZES: number[];
 export declare const DEFAULT_PAGINATION: DataTablePaginationConfig;
 export declare const DEFAULT_SORTING: DataTableSortingConfig;
 export declare const DEFAULT_FILTERING: DataTableFilteringConfig;
@@ -8,6 +9,9 @@ export declare const DEFAULT_EXPORT_FORMATS: DataTableExportFormat[];
 export declare const DEFAULT_SELECTION: DataTableSelectionConfig;
 export declare function createEmptyFilterGroup(): DataTableFilterGroup;
 export declare function resolvePagination(config: DataTableView): DataTablePaginationConfig | false;
+export declare function fitPageSize(pageSize: number, options: number[] | undefined): number;
+export declare function offeredPageSizes(options: number[] | undefined, inUse: Array<number | undefined>, defaults?: number[]): number[];
+export declare function paramsKey(params: Record<string, unknown> | undefined): string;
 export declare function resolveSorting(config: DataTableView): DataTableSortingConfig | false;
 export declare function resolveFiltering(config: DataTableView): DataTableFilteringConfig | false;
 export declare function resolveExport(config: DataTableView): DataTableExportConfig | false;

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

@@ -1,4 +1,5 @@
-import type { DataTableCellStyle, DataTableColumn, DataTableExportFormat } from '../types';
+import type { DataTableCellStyle, DataTableColumn, DataTableColumnGroup, DataTableExportFormat } from '../types';
+import type { XlsxHeaderGroupRow } from '../../../core/types';
 import { type ColumnTextContext } from '../columnValue';
 import type { ColumnMeta } from './exportEngine';
 export interface ExportRowsForFormat {
@@ -10,4 +11,6 @@ export interface ExportRowsForFormat {
     totals: Record<string, any> | null;
 }
 export declare function uniqueHeaders(names: string[]): string[];
-export declare function exportRowsFor<TData>(format: DataTableExportFormat, data: TData[], columns: DataTableColumn<TData>[], visibleKeys: string[], ctx: ColumnTextContext, totalKeys?: string[], totalLabel?: string): ExportRowsForFormat;
+export declare function exportRowsFor<TData>(format: DataTableExportFormat, data: TData[], columns: DataTableColumn<TData>[], visibleKeys: string[], ctx: ColumnTextContext, totalKeys?: string[], totalLabel?: string, inTotals?: (row: TData) => boolean): ExportRowsForFormat;
+export declare function exportHeaderGroups(groups: DataTableColumnGroup[] | undefined, keys: readonly string[]): XlsxHeaderGroupRow[];
+export declare function withPinnedExportRows(data: ExportRowsForFormat, top: ExportRowsForFormat | null, bottom: ExportRowsForFormat | null): ExportRowsForFormat;

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

@@ -1,4 +1,6 @@
-import type { FileTask, PdfTaskFonts, XlsxWorkbookSpec } from '../../../core/types';
+import type { FileTask, PdfTaskFonts, XlsxHeaderGroupRow, XlsxWorkbookSpec } from '../../../core/types';
+export type ExportHeaderGroups = XlsxHeaderGroupRow[];
+export declare function headerGroupCells(groups: XlsxHeaderGroupRow, width: number): string[];
 import { type DataTableExportFormat, type DataTableExportMetadata, type DataTableXlsxStyle, type DataTablePdfConfig, type DataTableColumn, type DataTableCellStyle, type DataTableExportSummary } from '../types';
 export { autoFormatValue, prepareExportRows, buildBusinessMeta } from './exportRows';
 export { formatContextLine, formatMetadataLines } from './exportContext';
@@ -13,7 +15,7 @@ export interface ColumnMeta {
     cellStyle?: (value: any, row: any) => DataTableCellStyle | undefined;
 }
 export declare function buildColumnMeta(columns: DataTableColumn[], headers: string[]): ColumnMeta[];
-export declare function generateCSV(headers: string[], rows: Record<string, any>[], totals?: Record<string, any> | null, summary?: DataTableExportSummary | null, metadata?: DataTableExportMetadata, subtitle?: string): Blob;
+export declare function generateCSV(headers: string[], rows: Record<string, any>[], totals?: Record<string, any> | null, summary?: DataTableExportSummary | null, metadata?: DataTableExportMetadata, subtitle?: string, headerGroups?: ExportHeaderGroups): Blob;
 type XlsxConfig = {
     totals?: Record<string, any> | null;
     summary?: DataTableExportSummary | null;
@@ -23,6 +25,7 @@ type XlsxConfig = {
     cellStyles?: Record<string, DataTableCellStyle>[];
     metadata?: DataTableExportMetadata;
     subtitle?: string;
+    headerGroups?: ExportHeaderGroups;
 };
 export declare function buildTableXlsxSpec(headers: string[], rows: Record<string, any>[], config?: XlsxConfig): XlsxWorkbookSpec;
 export declare function generateXLSX(headers: string[], rows: Record<string, any>[], config?: XlsxConfig): Promise<Blob>;
@@ -54,6 +57,7 @@ export declare function generateTablePDFTask(headers: string[], rows: Record<str
     metadata?: DataTableExportMetadata;
     fontFor?: PdfFontFor;
     fonts?: PdfTaskFonts;
+    headerGroups?: ExportHeaderGroups;
 }): TablePdfTask;
 export { rawDataToBlob, downloadBlob, shareFile, openPreview, executeFileAction, getExtension, getFormatLabel, } from '../vendor';
 export declare function generateXML(headers: string[], rows: Record<string, any>[], config?: {
@@ -83,4 +87,5 @@ export declare function buildExportBlob(format: DataTableExportFormat, headers:
         name: string;
         url?: string;
     };
+    headerGroups?: ExportHeaderGroups;
 }): Promise<Blob>;

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

@@ -1,7 +1,9 @@
 import { type DataTableColumn, type DataTableExportTemplate, type DataTableExportFormat, type DataTableExportAction, type DataTableExportSettings, type DataTableActiveFilter, type DataTableExportResult, type DataTableExportConfig, type DataTablePdfConfig, type DataTableExportSummary, type DataTableExportTemplatePrefs, type DataTableExportOptions, type DataTableAllRowsResult, type DataTableAuthorize, type DataTableSelection } from '../types';
 import type { DataTableExportOptionValues } from '../types';
+import type { DataTableColumnGroup } from '../types';
 import type { ColumnTextContext } from '../columnValue';
 import { type DataTableLabels } from '../labels';
+import { type TreeLevelLook, type TreeLevels } from '../tree/treeExport';
 interface UseTableExportOptions<TData> {
     columns: DataTableColumn<TData>[];
     exportConfig?: DataTableExportConfig<TData>;
@@ -23,11 +25,25 @@ interface UseTableExportOptions<TData> {
     templatePrefs?: DataTableExportTemplatePrefs;
     exportOptions?: DataTableExportOptions;
     authorize?: DataTableAuthorize;
-    loadAllRows?: (format: DataTableExportFormat, action: DataTableExportAction, params?: Record<string, unknown>) => Promise<DataTableAllRowsResult<TData>>;
+    loadAllRows?: (format: DataTableExportFormat, action: DataTableExportAction, params?: Record<string, unknown>) => Promise<ExportRowsLoad<TData>>;
     labels?: DataTableLabels;
     locale?: string;
     text?: ColumnTextContext;
+    columnGroups?: DataTableColumnGroup[];
+    pinnedRows?: {
+        top?: TData[];
+        bottom?: TData[];
+    };
+    tree?: {
+        look: TreeLevelLook;
+        totals: 'leaves' | 'all';
+        levels?: TreeLevels<TData>;
+    };
 }
+export type ExportRowsLoad<TData> = DataTableAllRowsResult<TData> & {
+    levels?: TreeLevels<TData>;
+    treePartial?: boolean;
+};
 interface UseTableExportReturn {
     hasExport: boolean;
     hasQuickExport: boolean;

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

@@ -1,6 +1,7 @@
 import { type DataTableFilterCondition, type DataTableFilterGroup, type DataTableColumn } from '../types';
 export declare const FILTER_ROW_ID_PREFIX = "filter-row:";
 export type FilterRowKind = 'text' | 'number' | 'date' | 'select' | 'boolean';
+export declare const FILTER_ROW_MIN_WIDTH: Partial<Record<FilterRowKind, number>>;
 export type FilterRowValue = {
     kind: 'text';
     text: string;

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

@@ -24,6 +24,9 @@ export type DisplayItem<R = any> = {
     key: string;
     row: R;
     depth: number;
+    pinned?: 'top' | 'bottom';
+    app?: boolean;
+    tree?: TreeLineState;
 } | {
     kind: 'more';
     key: string;
@@ -37,6 +40,14 @@ export type DisplayItem<R = any> = {
     node: GroupNode<R>;
     status: 'loading' | 'error';
 };
+export interface TreeLineState {
+    hasChildren: boolean;
+    expanded: boolean;
+    status?: 'loading' | 'error';
+}
+export declare function rowItemOf(row: {
+    id: string;
+}): DisplayItem;
 export interface GroupLabels {
     yes: string;
     no: string;

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

@@ -1,5 +1,5 @@
 export { default as DataTable } from './DataTable';
-export type { DataTableProps, DataTableView, DataTableColumn, DataTableColumnType, DataTableNumberFormat, DataTableComponentProps, DataTableRowAction, DataTableFilterGroup, DataTableFilterCondition, DataTableActiveFilter, DataTableSingleRowView, DataTableSingleRowField, DataTableSingleRowAction, DataTableSelectionConfig, DataTableSelectionShow, DataTablePaginationConfig, DataTableSortingConfig, DataTableFilteringConfig, DataTableQuickFilter, DataTableQuickFilterMode, DataTableSavedFilter, DataTableSavedFilterIssue, DataTableViewPrefs, DataTableExportFormat, DataTableExportAction, DataTableExportTemplate, DataTableQuickExport, DataTableExportConfig, DataTableXlsxStyle, DataTablePdfConfig, DataTableExportGenerator, DataTableExportResult, DataTableExportResultStatus, DataTableExportGeneratorResult, DataTableFilenameContext, DataTableExportMeta, DataTableExportContext, DataTableExportSettings, DataTableExportPrefs, DataTableExportMetadata, DataTableExportSummary, DataTableExportSummaryTable, DataTableExportOptions, DataTableFileNameAs, DataTablePdfFonts, DataTablePdfPageSize, DataTablePdfOrientation, DataTablePdfFontSize, DataTablePdfMargins, DataTableSummaryConfig, DataTableSummaryCard, DataTableSummaryValueCard, DataTableSummaryRatioCard, DataTableSummaryBreakdownCard, DataTableSummaryTrendCard, DataTableSummaryFunnelCard, DataTableSummaryFunnelStep, DataTableSummaryValueTrend, DataTableSummaryPeriod, DataTableSummaryTrendChart, DataTableSummaryValueChart, DataTableSummaryRatioChart, DataTableSummaryAnyChart, DataTableSummaryCardRequest, DataTableSummaryPeriodCount, DataTableSummaryFigure, DataTableSummarySubline, DataTableSummaryStrip, DataTableSummaryChart, DataTableSummaryWidth, DataTableSummaryShow, DataTableSummaryPart, DataTableSummaryUserCard, DataTableSummaryPrefs, DataTableExportSummaryMode, DataTableSummaryPlacement, DataTableSummaryRequest, DataTableSummaryBucket, DataTableSummaryBreakdown, DataTableSummaryFigures, DataTableLicense, DataTableFlashColor, DataTableFlashColors, DataTableCellFlashStyle, DataTableCellStyle, DataTableLayout, DataTableCardFields, DataTableCardField, DataTableListFields, DataTableListField, DataTableRowMenuConfig, DataTableRowMenuItem, DataTableRowMenuBuiltIn, DataTableRowMenuIconAction, DataTableDetailMode, DataTableDetailContext, DataTableDetailRenderer, DataTableDisplayPrefs, DataTableDensity, DataTableFontSize, DataTableColumnWidth, DataTableActionDisplay, DataTableQuery, DataTableDataSource, DataTableRowsResult, DataTableAllRowsResult, DataTableCounts, DataTableInitialState, DataTableApi, DataTablePersistence, DataTableGate, DataTableAuthorize, DataTableManagePrefs, DataTableManageList, DataTableViewsPrefs, DataTableExportTemplatePrefs, DataTableBulkAction, DataTableBulkActionContext, DataTableBulkActionResult, DataTableBulkConfirm, DataTableSelection, DataTableColumnPinning, DataTablePinningConfig, DataTableKeyboardConfig, DataTableShortcut, DataTableVirtualizeConfig, DataTableGroupingConfig, DataTableGroupPathItem, DataTableGroupResult, DataTableGroupSummaryContext, DataTableViewState, DataTableSharedView, DataTableShareAudience, DataTableSharing, } from './types';
+export type { DataTableProps, DataTableView, DataTableColumn, DataTableColumnType, DataTableNumberFormat, DataTableComponentProps, DataTableRowAction, DataTableFilterGroup, DataTableFilterCondition, DataTableActiveFilter, DataTableSingleRowView, DataTableSingleRowField, DataTableSingleRowAction, DataTableSelectionConfig, DataTableSelectionShow, DataTablePaginationConfig, DataTableSortingConfig, DataTableFilteringConfig, DataTableQuickFilter, DataTableQuickFilterMode, DataTableSavedFilter, DataTableSavedFilterIssue, DataTableViewPrefs, DataTableExportFormat, DataTableExportAction, DataTableExportTemplate, DataTableQuickExport, DataTableExportConfig, DataTableXlsxStyle, DataTablePdfConfig, DataTableExportGenerator, DataTableExportResult, DataTableExportResultStatus, DataTableExportGeneratorResult, DataTableFilenameContext, DataTableExportMeta, DataTableExportContext, DataTableExportSettings, DataTableExportPrefs, DataTableExportMetadata, DataTableExportSummary, DataTableExportSummaryTable, DataTableExportOptions, DataTableFileNameAs, DataTablePdfFonts, DataTablePdfPageSize, DataTablePdfOrientation, DataTablePdfFontSize, DataTablePdfMargins, DataTableSummaryConfig, DataTableSummaryCard, DataTableSummaryValueCard, DataTableSummaryRatioCard, DataTableSummaryBreakdownCard, DataTableSummaryTrendCard, DataTableSummaryFunnelCard, DataTableSummaryFunnelStep, DataTableSummaryValueFigure, DataTableSummarySum, DataTableSummaryRowFilter, DataTableSummaryRange, DataTableSummaryCardHeight, DataTableSummaryValueTrend, DataTableSummaryPeriod, DataTableSummaryTrendChart, DataTableSummaryValueChart, DataTableSummaryRatioChart, DataTableSummaryAnyChart, DataTableSummaryCardRequest, DataTableSummaryPeriodCount, DataTableSummaryFigure, DataTableSummarySubline, DataTableSummaryStrip, DataTableSummaryChart, DataTableSummaryWidth, DataTableSummaryShow, DataTableSummaryPart, DataTableSummaryUserCard, DataTableSummaryPrefs, DataTableExportSummaryMode, DataTableSummaryPlacement, DataTableSummaryRequest, DataTableSummaryBucket, DataTableSummaryBreakdown, DataTableSummaryFigures, DataTableLicense, DataTableFlashColor, DataTableFlashColors, DataTableRowChanges, DataTableCellFlashStyle, DataTableCellStyle, DataTableLayout, DataTableCardFields, DataTableCardField, DataTableListFields, DataTableListField, DataTableRowMenuConfig, DataTableRowMenuItem, DataTableRowMenuBuiltIn, DataTableRowMenuIconAction, DataTableDetailMode, DataTableDetailContext, DataTableDetailRenderer, DataTableDisplayPrefs, DataTableDensity, DataTableFontSize, DataTableColumnWidth, DataTableActionDisplay, DataTableQuery, DataTableDataSource, DataTableRowsResult, DataTableAllRowsResult, DataTableExportTreeRequest, DataTableCounts, DataTableInitialState, DataTableApi, DataTableTransactionResult, DataTableTransactionOptions, DataTableRowTransaction, DataTablePersistence, DataTableGate, DataTableAuthorize, DataTableManagePrefs, DataTableManageList, DataTableViewsPrefs, DataTableExportTemplatePrefs, DataTableBulkAction, DataTableBulkActionContext, DataTableBulkActionResult, DataTableBulkConfirm, DataTableToolbarAction, DataTableSelection, DataTableColumnPinning, DataTablePinningConfig, DataTableColumnGroup, DataTableRowPinSide, DataTableRowPinningConfig, DataTableRowPins, DataTableCellSelectionConfig, DataTableCellRange, DataTableCellRangeFigure, DataTableCellPaste, DataTableRowDragConfig, DataTableRowOrderChange, DataTableTreeDataConfig, DataTablePivotConfig, DataTablePivotState, DataTablePivotValue, DataTablePivotTotals, DataTablePivotAggregate, DataTablePivotAggFn, DataTablePivotAggregation, DataTablePivotRequest, DataTablePivotResult, DataTablePivotCell, DataTablePivotKey, DataTableKeyboardConfig, DataTableShortcut, DataTableVirtualizeConfig, DataTableGroupingConfig, DataTableGroupPathItem, DataTableGroupResult, DataTableGroupSummaryContext, DataTableViewState, DataTableSharedView, DataTableShareAudience, DataTableSharing, } from './types';
 export { isFilterGroup, CARD_FIELD_LIMITS, LIST_FIELD_LIMITS, SUMMARY_PLACEMENTS_MAX, SUMMARY_SHOWS, SUMMARY_STRIPS, SUMMARY_TREND_COUNTS, SUMMARY_TREND_COUNT_BOUNDS, SUMMARY_KIND_CHARTS, SUMMARY_USER_CARDS_MAX, SUMMARY_WIDTHS } from './types';
 export { DEFAULT_DATA_TABLE_LABELS } from './labels';
 export type { DataTableLabels, DataTableLabelKey } from './labels';

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

@@ -8,7 +8,10 @@ interface ShortcutsDialogProps {
     grouping: boolean;
     actions: ShortcutListEntry[];
     table: ShortcutListEntry[];
+    cells?: {
+        paste: boolean;
+    };
     onClose: () => void;
 }
-export declare function ShortcutsDialog({ builtIns, grouping, actions, table, onClose }: ShortcutsDialogProps): React.JSX.Element;
+export declare function ShortcutsDialog({ builtIns, grouping, actions, table, cells, onClose }: ShortcutsDialogProps): React.JSX.Element;
 export default ShortcutsDialog;

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

@@ -9,6 +9,7 @@ export interface GridKeyboardHost<R = any, T = any> {
     shortcuts: boolean;
     layout: DataTableLayout;
     items: DisplayItem<R>[];
+    lineOffset?: number;
     columns: string[];
     activeKey: string | null;
     activeCol: number;
@@ -16,6 +17,7 @@ export interface GridKeyboardHost<R = any, T = any> {
     rowId: (row: R) => string;
     original: (row: R) => T;
     openRow: (row: R) => void;
+    followOpen?: boolean;
     toggleRow: (row: R) => void;
     toggleGroup: (key: string) => void;
     toggleGroupSelection: (node: GroupNode<R>) => boolean;
@@ -30,6 +32,12 @@ export interface GridKeyboardHost<R = any, T = any> {
     runTableShortcut: (s: DataTableShortcut<T>, row: T | null) => void;
     page: (delta: 1 | -1) => boolean;
     openHelp: () => void;
+    cellKeys?: (e: React.KeyboardEvent, at: {
+        key: string;
+        col: number;
+        row: boolean;
+        focus: (key: string, col: number) => void;
+    }) => boolean;
 }
 export declare function useGridKeyboard<R, T>(host: GridKeyboardHost<R, T>, areaRef: RefObject<HTMLElement | null>, scrollApi: MutableRefObject<ScrollApi | null>): {
     onKeyDown: (e: React.KeyboardEvent) => void;