@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/data/common/row-number-columns.d.ts

@@ -0,0 +1,17 @@
+import { ColumnDefIf } from '../tablemodel/column/column-def.if.js';
+
+/**
+ * 1 if the first column is a {@link RowNumberColumnDef}, otherwise 0 – the offset of the built-in columns that are
+ * bound to "the first column": the {@link CheckboxColumnDef}, the tree arrow and the checkbox of
+ * `showCheckboxWihoutExtraColumn` sit at this index (behind the row numbers).
+ *
+ * @param {ColumnDefIf[] | undefined} columnDefs - the column definitions of the table model
+ * @returns {0 | 1} the number of leading row number columns
+ *
+ * @example
+ * const firstDataColumn = getLeadingRowNumberColumnCount(tableModel.getColumnDefs());
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare function getLeadingRowNumberColumnCount(columnDefs: ColumnDefIf[] | undefined): 0 | 1;

package/lib/table/data/common/row-number-options.d.ts

@@ -0,0 +1,19 @@
+import { RowNumberMode, RowNumberOptionsIf } from './row-number-options.if.js';
+
+/**
+ * The default options of the row number column: numbers of the current view, no thousands separators, header `"#"`,
+ * not exported, at least 36 px wide.
+ *
+ * @example
+ * const columnDef = new RowNumberColumnDef({ ...new RowNumberOptions(), headerLabel: "" });
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare class RowNumberOptions implements RowNumberOptionsIf {
+    mode: RowNumberMode;
+    format: (rowNumber: number) => string;
+    headerLabel: string;
+    exported: boolean;
+    minWidthInPx: number;
+}

package/lib/table/data/common/row-number-options.if.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How a {@link RowNumberColumnDef} counts:
+ * - `"display"` (default): the position in the current view – 1, 2, 3 … also after sorting and filtering
+ *   (like the row headers of a spreadsheet).
+ * - `"original"`: the position in the unsorted, unfiltered rows (`getAllRows()` of the body model) – the number stays
+ *   with its row. Body models without `getAllRows()` (tree, own area models) count like `"display"`.
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export type RowNumberMode = "display" | "original";
+/**
+ * Options of the row number column ({@link RowNumberColumnDef}). Pass any subset – to
+ * `new RowNumberColumnDef({ … })` or as `rowNumbersVisible: { … }` to {@link TableFactory.createTableModel}.
+ * Defaults: {@link RowNumberOptions}.
+ *
+ * @example
+ * const tableModel = TableFactory.createTableModel({
+ *   rows: orders,
+ *   rowNumbersVisible: { mode: "original", format: n => n.toLocaleString("en-US"), exported: true }
+ * });
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export interface RowNumberOptionsIf {
+    /** `"display"` (default) or `"original"`, see {@link RowNumberMode}. */
+    mode: RowNumberMode;
+    /**
+     * The text of a number. Default `String(n)` – no thousands separators (`"2000000"`).
+     * The column width is measured with the text of the largest number, so the text should not get shorter for
+     * larger numbers.
+     *
+     * @example
+     * const options: Partial<RowNumberOptionsIf> = { format: n => n.toLocaleString("de-DE") }; // "2.000.000"
+     */
+    format: (rowNumber: number) => string;
+    /** Text of the header cell. Default `"#"` (an empty header cell has no accessible name). */
+    headerLabel: string;
+    /** `true`: {@link TableApi.copyToClipboard} and {@link TableApi.downloadExcel} contain the numbers. Default `false`. */
+    exported: boolean;
+    /** The column is never narrower than this (px). Default 36. */
+    minWidthInPx: number;
+}

package/lib/table/data/options/table-options.d.ts

@@ -12,6 +12,9 @@ import { ShortcutActionIdMapping } from '../../action/shortcut-actionid-mapping.
 import { HeaderGroupOptions } from './header-group-options.js';
 import { AriaTextsIf } from '../../aria/aria-texts.if.js';
 import { OverlayOptionsIf } from './overlay-options.if.js';
+import { RowDragOptionsIf } from '../../row-drag/row-drag-options.if.js';
+import { FillHandleOptionsIf } from '../../fill/fill-handle-options.if.js';
+import { BatchEditOptionsIf } from '../../batch-edit/batch-edit-options.if.js';
 
 /**
  * All default options of a table – see {@link TableOptionsIf} for the meaning of each field.
@@ -80,4 +83,7 @@ export declare class TableOptions implements TableOptionsIf {
     ariaTexts?: Partial<AriaTextsIf>;
     /** Texts and behaviour of the "Loading…" / "No rows" overlays; missing fields use {@link OverlayOptions}. @since 1.1.92 */
     overlayOptions?: Partial<OverlayOptionsIf>;
+    rowDragOptions?: Partial<RowDragOptionsIf>;
+    fillHandle?: boolean | Partial<FillHandleOptionsIf>;
+    batchEdit?: boolean | Partial<BatchEditOptionsIf>;
 }

package/lib/table/data/options/table-options.if.d.ts

@@ -1,3 +1,6 @@
+import { RowDragOptionsIf } from '../../row-drag/row-drag-options.if.js';
+import { FillHandleOptionsIf } from '../../fill/fill-handle-options.if.js';
+import { BatchEditOptionsIf } from '../../batch-edit/batch-edit-options.if.js';
 import { DefaultRowHeightsIf } from './default-row-heights.if.js';
 import { TreeOptionsIf } from './tree-options.if.js';
 import { FilterFunction } from '../common/filter-function.js';
@@ -317,6 +320,47 @@ export interface TableOptionsIf {
      * @since 1.1.92
      */
     overlayOptions?: Partial<OverlayOptionsIf>;
+    /**
+     * Row drag: managed or events only, multi-row drag, tree drop, auto-scroll (see {@link RowDragOptionsIf}). The drag
+     * handles come from {@link ColumnDefIf.rowDrag}. Fields you leave out keep their default ({@link RowDragOptions}).
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   rowDragOptions: { managed: false },   // only events – e.g. the server decides
+     * };
+     *
+     * @since 1.1.95
+     */
+    rowDragOptions?: Partial<RowDragOptionsIf>;
+    /**
+     * The fill handle: a small square at the bottom right corner of the selected range. Dragging it fills the
+     * neighbouring cells (copy, or a series: 1, 2, 3 …, dates, `Item 1` → `Item 2`); ⌥/Alt switches between series and
+     * copy. Keyboard: Ctrl/⌘+D fills down, Ctrl/⌘+R fills right. Needs a selection model of the type `"range"`;
+     * only editable cells are filled. `true` = defaults ({@link FillHandleOptions}).
+     *
+     * @example
+     * const selectionModel = new SelectionModel("range", "multi");   // one model – not a new one per call
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   getSelectionModel: () => selectionModel,
+     *   fillHandle: true,
+     * };
+     *
+     * @since 1.1.96
+     */
+    fillHandle?: boolean | Partial<FillHandleOptionsIf>;
+    /**
+     * Batch edit always on: edited and filled values are collected (marked `ge-table-cell-pending`) and written with
+     * {@link TableApi.commitBatchEdit} or discarded with {@link TableApi.cancelBatchEdit}. Without it, start a batch
+     * edit with {@link TableApi.startBatchEdit} (it ends with commit or cancel).
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = { ...new TableOptions(), batchEdit: true };
+     *
+     * @since 1.1.96
+     */
+    batchEdit?: boolean | Partial<BatchEditOptionsIf>;
     /**
      * The state the table starts with: column layout, sorting, tree, checked and selected rows … – e.g. loaded from
      * your server ({@link TableApi.getState}, {@link EventListenerIf.onStateChanged}). A state stored by

package/lib/table/data/tablemodel/areamodel/abstract-area-model.d.ts

@@ -7,6 +7,7 @@ import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if.js';
 import { FilterFunction } from '../../common/filter-function.js';
 import { SortItem } from '../../common/sort-item.js';
 import { HasDefaultRowHeightIf } from './has-default-row-height-if.js';
+import { ColumnValues } from '../../../calc/column-values.js';
 
 /** @category Area models */
 export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDefaultRowHeightIf {
@@ -14,6 +15,8 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     protected columnDefs: ColumnDefIf[];
     defaultRowHeight: number;
     rowSelectionModel: CheckboxModelIf<any> | undefined;
+    private columnValuesInstance?;
+    private calcTextRenderer?;
     protected cellRenderers: (CellRendererIf | undefined)[];
     protected yPositions: number[];
     constructor(areaIdent: AreaIdent, columnDefs?: ColumnDefIf[], defaultRowHeight?: number);
@@ -48,4 +51,67 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     protected setPropertyValue(o: any, props: string[], value: any): boolean;
     protected arrayMove(arr: any[], fromIndex: number, toIndex: number): any[];
     private calcYPositions;
+    /**
+     * True if a column of this model with this property is calculated (`valueGetter` or `formula`).
+     *
+     * @param {string} property - the property of the column
+     * @returns {boolean} whether its values are computed
+     *
+     * @example
+     * tableModel.getBodyModel().isCalculatedProperty?.("total");   // true
+     *
+     * @since 1.1.95
+     */
+    isCalculatedProperty(property: string): boolean;
+    /**
+     * The value of a column for a row object – the computed value of a calculated column, otherwise the property
+     * (path). A `TreeRow` is unwrapped. The table API offers it as {@link TableApi.getRowValue}.
+     *
+     * @param {any} row - a row object (or `TreeRow`)
+     * @param {string} property - the property of the column
+     * @returns {unknown} the value
+     *
+     * @example
+     * const body = tableModel.getBodyModel() as AreaModelObjectArray<Item>;
+     * body.getRowValue({ price: 25, quantity: 10 }, "total");   // 250
+     *
+     * @since 1.1.95
+     */
+    getRowValue(row: any, property: string): unknown;
+    /**
+     * True if the model has calculated or „Show values as“ columns – their cells depend on other cells
+     * (the table redraws them after `updateCells`).
+     *
+     * @returns {boolean} whether derived columns exist
+     * @since 1.1.95
+     */
+    hasDerivedColumns(): boolean;
+    /**
+     * True if the cells of a column depend on other cells (calculated or „Show values as“).
+     *
+     * @param {string} property - the property of the column
+     * @returns {boolean} whether the column is derived
+     * @since 1.1.95
+     */
+    isDerivedProperty(property: string): boolean;
+    /** The resolver of calculated values of this model (created on first use). @internal */
+    protected getColumnValues(): ColumnValues;
+    /** Drops the cached aggregates and the getter lookup of calculated columns. */
+    protected invalidateColumnValues(): void;
+    /** The value of a property path – overridden by the models with their own path semantics. */
+    protected readPropertyPath(row: any, property: string): unknown;
+    /** The rows of column aggregates in formulas (`SUM([total])`): the filtered row objects. */
+    protected getAggregationSourceForValues(): {
+        signal: unknown;
+        length: number;
+        rows: () => ArrayLike<unknown>;
+    };
+    /** Writes an edited value of a calculated column through its `valueSetter`; without one: rejected. */
+    protected setCalculatedValue(row: any, columnDef: ColumnDefIf, value: any): boolean;
+    /** The text of a cell of a calculated / „Show values as“ column; `undefined` for a normal column. */
+    protected getCalculatedText(property: string | undefined, value: unknown): string | undefined;
+    /** The renderer of a „Show values as“ column without an own renderer: the text of `getTextValueAt`. */
+    protected getCalculatedRenderer(property: string | undefined): CellRendererIf | undefined;
+    /** The CSS class and tooltip of an error value of a formula. */
+    protected addCalculatedClasses(classes: string[], property: string | undefined, value: () => unknown): string[];
 }

package/lib/table/data/tablemodel/areamodel/aggregate-footer-options.if.d.ts

@@ -0,0 +1,73 @@
+import { AggregateSpecMap } from '../../../aggregation/aggregate-spec.if.js';
+import { AreaModelIf } from './area-model.if.js';
+
+/**
+ * One total row of an {@link AreaModelAggregateFooter}: the aggregates by column property and an optional label.
+ *
+ * @example
+ * const sumRow: AggregateFooterRowIf<Order> = { label: "Sum", aggregates: { quantity: "sum", total: "sum" } };
+ * const avgRow: AggregateFooterRowIf<Order> = {
+ *   label: (rowCount, results) => `Ø of ${rowCount} orders`,
+ *   aggregates: { total: { aggregator: "avg", format: v => `${(v as number).toFixed(2)} €` } }
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregateFooterRowIf<T = any> {
+    /** Key = property of the column that shows the result (a key without a column is only in `getResults()`). */
+    aggregates: AggregateSpecMap<T>;
+    /**
+     * Text in the label column (always set as text, never as HTML). Default: `"6 rows"` – or, in a footer with
+     * several rows whose aggregates all use the same built-in aggregator, its word (`"Sum"`, `"Average"`, `"Min"` …).
+     */
+    label?: string | ((rowCount: number, results: Record<string, unknown>) => string);
+}
+/**
+ * The options of an {@link AreaModelAggregateFooter} (and of `TableFactory.createTableModel({ footerAggregates })`).
+ *
+ * @example
+ * const options: AggregateFooterOptionsIf<Order> = {
+ *   rows: [
+ *     { label: "Sum", aggregates: { quantity: "sum", total: "sum" } },
+ *     { label: "Average", aggregates: { quantity: "avg", total: "avg" } }
+ *   ],
+ *   labelProperty: "customer",   // the labels go into the customer column
+ *   rowHeight: 36
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregateFooterOptionsIf<T = any> {
+    /** One footer row per entry. */
+    rows: AggregateFooterRowIf<T>[];
+    /** The column of the labels (property). Default: the first data column without an aggregate in that row. */
+    labelProperty?: string;
+    /** Height of the footer rows in px. Default 34 (the factory uses `defaultRowHeights.footer`). */
+    rowHeight?: number;
+    /**
+     * Which rows are aggregated: `"filtered"` (default) – the rows the body shows (after `externalFilterFunction`;
+     * in a tree all leaves that pass the filter, expanded or not); `"all"` – all rows, the filter is ignored.
+     */
+    source?: "filtered" | "all";
+    /** An own source of rows (instead of the body model's rows), e.g. the data of a server response. */
+    getRows?: (bodyModel: AreaModelIf) => ArrayLike<T>;
+}
+/**
+ * The short and the full forms of a footer configuration:
+ * - `{ total: "sum" }` – one row ({@link AggregateSpecMap}),
+ * - `[{ label: "Sum", aggregates: … }, …]` – several rows ({@link AggregateFooterRowIf}),
+ * - `{ rows: […], labelProperty, rowHeight, source, getRows }` – everything ({@link AggregateFooterOptionsIf}).
+ *
+ * @example
+ * const oneRow: AggregateFooterConfig<Order> = { quantity: "sum", total: "sum" };
+ * const twoRows: AggregateFooterConfig<Order> = [
+ *   { label: "Sum", aggregates: { total: "sum" } },
+ *   { label: "Max", aggregates: { total: "max" } }
+ * ];
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregateFooterConfig<T = any> = AggregateSpecMap<T> | AggregateFooterRowIf<T>[] | AggregateFooterOptionsIf<T>;

package/lib/table/data/tablemodel/areamodel/area-model-aggregate-footer.d.ts

@@ -0,0 +1,150 @@
+import { AreaModel } from './area-model.js';
+import { AreaModelIf } from './area-model.if.js';
+import { HasDefaultRowHeightIf } from './has-default-row-height-if.js';
+import { ColumnDefIf } from '../column/column-def.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { AggregateFooterConfig, AggregateFooterOptionsIf } from './aggregate-footer-options.if.js';
+import { ResolvedAggregateSpec } from '../../../aggregation/aggregate-internals.js';
+
+interface AggregationSource {
+    /** changes when the rows change (identity) – undefined: only invalidateDerivedValues() */
+    signal: unknown;
+    /** the number of rows, cheap (part of the cache key) – undefined: not known without computing the rows */
+    length?: number;
+    /** the rows (objects) – or, for models without row objects, the number of rows; called on a cache miss only */
+    getRows(): ArrayLike<unknown> | number;
+}
+/**
+ * A ready-made footer with totals (sum, average, count, …) that follow filter and sorting – without an own
+ * {@link AreaModel}. One or more total rows; every aggregate belongs to the column with the same **property**
+ * (column order, row numbers and the checkbox column don't matter). The easiest way is the factory option
+ * `footerAggregates` of {@link TableFactory.createTableModel}.
+ *
+ * - **Data**: the rows the body shows (`getFilteredRows()`), in a tree all leaves the filter keeps (expanded or not),
+ *   in other models every row via `getValueAt` of the column. Options `source: "all"` and `getRows` change that.
+ * - **Cells**: the value is the raw result (a number stays a number – Excel export, own footer renderers); the text is
+ *   formatted (`format` of the spec, otherwise {@link formatAggregateValue}). A footer renderer of the column
+ *   (`rendererMap.footer`) gets the raw value; without it the {@link AggregateCellRenderer} writes the text.
+ * - **Label**: `"6 rows"` (or the row's `label`) in the first data column without an aggregate, or in `labelProperty`;
+ *   screen readers announce it as row header.
+ * - **Cache**: computed once per change of the data, not per repaint or scroll frame. The table drops the cache when
+ *   it filters, sorts, edits, gets `updateCells()` or `tableApi.repaint()` / `repaintHard()` – after changing row
+ *   objects yourself call `tableApi.repaint()`, as for the cells.
+ *
+ * @example
+ * // one line: totals of quantity and total – the label "100,000 rows" goes into the first column without aggregate
+ * const tableModel = TableFactory.createTableModel({
+ *   rows: orders,
+ *   columnDefs,
+ *   footerAggregates: { quantity: "sum", total: "sum" }
+ * });
+ *
+ * @example
+ * // two total rows with own labels, an own body model
+ * const footer = new AreaModelAggregateFooter<Order>(() => tableModel.getBodyModel(), columnDefs, [
+ *   { label: "Sum", aggregates: { quantity: "sum", total: "sum" } },
+ *   { label: (rowCount: number) => `Ø of ${rowCount}`, aggregates: { quantity: "avg", total: "avg" } }
+ * ]);
+ * const tableModel = TableFactory.createTableModel({ rows: orders, columnDefs, footerAreaModel: footer });
+ *
+ * @example
+ * // read the results, e.g. for a title
+ * const footer = tableModel.getAreaModel("footer") as AreaModelAggregateFooter<Order>;
+ * const { total } = footer.getResults();           // { total: 27481033.5, … }
+ *
+ * @see {@link aggregateColumns} (the same without a table), {@link TableApi.getSelectionAggregates} (selected cells)
+ * @see Training: [Footer totals](https://gui.expert/training/footer-totals/)
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare class AreaModelAggregateFooter<T = any> extends AreaModel implements HasDefaultRowHeightIf {
+    private readonly columnDefs;
+    /** Marker (works across copies of the core): {@link isAreaModelAggregateFooter}. */
+    readonly type = "AreaModelAggregateFooter";
+    /** Height of the footer rows in px (`rowHeight` of the options, default 34). */
+    defaultRowHeight: number;
+    private readonly getBody;
+    private readonly options;
+    private readonly footerRows;
+    private readonly textRenderer;
+    private cache?;
+    /**
+     * @param {AreaModelIf | (() => AreaModelIf)} body - the body model, or a function that returns it (if the footer is
+     *        created before the table model, e.g. `() => tableModel.getBodyModel()`)
+     * @param {ColumnDefIf[]} columnDefs - the column definitions of the table (the same array – columns are found by property)
+     * @param {AggregateFooterConfig<T>} config - `{ total: "sum" }` (one row), `[{ label, aggregates }, …]` (several rows)
+     *        or full {@link AggregateFooterOptionsIf}
+     */
+    constructor(body: AreaModelIf | (() => AreaModelIf), columnDefs: ColumnDefIf[], config: AggregateFooterConfig<T>);
+    /** The full options of a short configuration. */
+    static toOptions<T>(config: AggregateFooterConfig<T>): AggregateFooterOptionsIf<T>;
+    getRowCount(): number;
+    getRowHeight(_rowIndex: number): number;
+    getConstantRowHeight(): number | undefined;
+    /**
+     * Drops the cached results – the next cell read computes them again ({@link AreaModelIf.invalidateDerivedValues}).
+     * The table calls it when it filters, sorts, edits, gets `updateCells()` and on `tableApi.repaint()` / `repaintHard()`.
+     *
+     * @example
+     * order.total = 99;                                 // changed outside the table
+     * tableApi.repaint();                               // the cells and the footer show it
+     */
+    invalidateDerivedValues(): void;
+    /**
+     * The results of a footer row by key (also of keys without a column).
+     *
+     * @param {number} [rowIndex=0] - the footer row
+     * @returns {Record<string, unknown>} key → result (`{}` for a row that does not exist); do not modify it
+     *
+     * @example
+     * const footer = tableModel.getAreaModel("footer") as AreaModelAggregateFooter<Order>;
+     * document.title = `${formatAggregateValue(footer.getResults().total)} € in ${footer.getAggregationRowCount()} orders`;
+     */
+    getResults(rowIndex?: number): Record<string, unknown>;
+    /**
+     * The number of aggregated rows (e.g. the filtered body rows; in a tree the leaves).
+     *
+     * @returns {number} the number of rows the results are based on
+     */
+    getAggregationRowCount(): number;
+    /**
+     * Whether a cell shows the label of its footer row (the table gives it `role="rowheader"`).
+     *
+     * @param {number} rowIndex - footer row
+     * @param {number} columnIndex - column (model index)
+     * @returns {boolean} true for the label cell
+     */
+    isLabelCell(rowIndex: number, columnIndex: number): boolean;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getTextValueAt(rowIndex: number, columnIndex: number): string;
+    /**
+     * The renderer of a cell: for a result the footer renderer of the column (it gets the raw value), otherwise – and for
+     * the label – an {@link AggregateCellRenderer} that writes {@link getTextValueAt} as text.
+     */
+    getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    /** The label column of a footer row, -1 for none. */
+    protected getLabelColumnIndex(rowIndex: number): number;
+    /** The label text of a footer row. */
+    protected getLabel(rowIndex: number): string;
+    /**
+     * The rows to aggregate: `getRows` of the options, the (filtered) rows of an object body, the leaves of a tree, or –
+     * for models without row objects – the row count.
+     * @internal
+     */
+    protected getSource(): AggregationSource;
+    /**
+     * The getter of a spec for a model without row objects: a property with a column → `getValueAt` of that column;
+     * a function or a path without column → applied to `getRowByIndex(r)`.
+     * @internal
+     */
+    protected createIndexGetter(body: AreaModelIf, spec: ResolvedAggregateSpec<T>): ((rowIndex: number) => unknown) | undefined;
+    /**
+     * A spec whose value is the property of a calculated column of the body (`footerAggregates: { total: "sum" }` with
+     * `total` = `price * quantity`) sums the computed values, not the (missing) property of the row (since 1.1.95).
+     */
+    private withCalculatedValues;
+    private compute;
+}
+export {};

package/lib/table/data/tablemodel/areamodel/area-model-array-of-arrays.d.ts

@@ -2,6 +2,7 @@ import { AbstractAreaModel } from './abstract-area-model.js';
 import { AreaIdent } from '../area-ident.type.js';
 import { ColumnDefIf } from '../column/column-def.if.js';
 import { FilterFunction } from '../../common/filter-function.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
 
 /**
  * Represents a model for an area containing a two-dimensional array of data.
@@ -25,6 +26,29 @@ export declare class AreaModelArrayOfArrays<T> extends AbstractAreaModel<T[][]>
      * @since 1.1.92
      */
     getUnfilteredRowCount(): number;
+    /**
+     * Row drag: true if the rows can be moved (no filter hides a row, target `"before"` / `"after"` a row).
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows
+     * @param {RowDropTargetIf} target - the drop target
+     * @returns {boolean} true if {@link moveRows} would move them
+     * @since 1.1.95
+     */
+    canMoveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: moves the rows – in place in the displayed rows and in {@link arr}.
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows
+     * @param {RowDropTargetIf} target - the drop target (display index before the move)
+     * @returns {boolean} true if moved
+     *
+     * @example
+     * const model = new AreaModelArrayOfArrays("body", [["a"], ["b"], ["c"]], 30);
+     * model.moveRows([0], { rowIndex: 2, position: "after" });   // b, c, a
+     *
+     * @since 1.1.95
+     */
+    moveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
     getValueAt(rowIndex: number, columnIndex: number): any;
     setValue(rowIndex: number, columnIndex: number, value: any): boolean;
     getRowByIndex(rowIndex: number): any;

package/lib/table/data/tablemodel/areamodel/area-model-cell-groups.d.ts

@@ -15,7 +15,7 @@ import { TableHeaderGroupStateIf } from '../../../state/table-state.if.js';
 /** @category Header groups */
 export declare class AreaModelCellGroups implements AreaModelIf {
     readonly areaIdent: AreaIdent;
-    readonly groups: CellGroupIf[];
+    groups: CellGroupIf[];
     columnDefs: ColumnDefIf[];
     readonly defaultRowHeight: number;
     private headerGroupOptions;
@@ -80,6 +80,23 @@ export declare class AreaModelCellGroups implements AreaModelIf {
      * @since 1.1.92
      */
     setGroupClosed(id: string, closed: boolean): ColumnDefIf[] | undefined;
+    /**
+     * Replaces the header groups (e.g. a pivot table with other column keys): builds the header rows again and returns
+     * the column definitions in header order – existing definitions with the same property are kept (width, classes,
+     * renderers), their visibility follows the (collapsed) groups. Repaint the table afterwards (a pivot table does all of
+     * this in {@link TableApi.setPivotConfig}).
+     *
+     * @param {CellGroupIf[]} groups - the new groups; every column is a leaf with a `property`
+     * @param {ColumnDefIf[]} [columnDefs] - definitions to use for these properties (default: the current ones)
+     * @returns {ColumnDefIf[]} the column definitions, one per leaf, in header order
+     * @example
+     * const header = tableApi.getTableModel().getAreaModel("header") as AreaModelCellGroups;
+     * const columnDefs = header.setGroups([
+     *   { data: "Customer", children: [{ data: "Name", property: "name" }, { data: "City", property: "city" }] }
+     * ]);
+     * @since 1.1.94
+     */
+    setGroups(groups: CellGroupIf[], columnDefs?: ColumnDefIf[]): ColumnDefIf[];
     /** The toggleable groups by id (header order). */
     private getToggleGroups;
     /**

package/lib/table/data/tablemodel/areamodel/area-model-object-array.d.ts

@@ -5,6 +5,10 @@ import { FilterFunction } from '../../common/filter-function.js';
 import { SorterService } from '../../../service/sorter.service.js';
 import { SortItem } from '../../common/sort-item.js';
 import { ObjectArrayHolderIf } from './object-array-holder.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { DerivedValuesChangeIf } from './derived-values-change.if.js';
+import { ShowValuesAsIf } from '../../../calc/show-values-as.type.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
 
 /**
  * @class AreaModelObjectArray
@@ -171,6 +175,8 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * @internal
      */
     protected sorterService: SorterService;
+    /** Cached „Show values as“ values per property (cleared on filter, sorting and invalidation). */
+    private showValuesCache;
     /**
      * Creates an instance of AreaModelObjectArray.
      *
@@ -280,6 +286,36 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * @since 1.1.92
      */
     getUnfilteredRowCount(): number;
+    /**
+     * Row drag: true if the rows can be moved – no filter hides a row and the target is a row of this model
+     * (`"before"` / `"after"`).
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows
+     * @param {RowDropTargetIf} target - the drop target
+     * @returns {boolean} true if {@link moveRows} would move them
+     *
+     * @example
+     * bodyAreaModel.canMoveRows([2], { rowIndex: 6, position: "after" });   // true without a filter
+     *
+     * @since 1.1.95
+     */
+    canMoveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: moves the rows in the display order and writes that order back to {@link getAllRows} – **in place**
+     * (like `Array.prototype.sort`: with `TableFactory.createTableModel({ rows })` your array has the new order).
+     * Works only without a hiding filter ({@link canMoveRows}). The table repaints after a drop; from code use
+     * `tableApi.moveRows()`.
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows
+     * @param {RowDropTargetIf} target - the drop target (display index before the move)
+     * @returns {boolean} true if moved
+     *
+     * @example
+     * bodyAreaModel.moveRows([2], { rowIndex: 6, position: "after" });   // row 3 becomes row 7
+     *
+     * @since 1.1.95
+     */
+    moveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
     /**
      * Gets the value at the specified row and column indices.
      * This method handles tree rows and nested properties.
@@ -302,6 +338,35 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * }
      */
     getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * The text of a cell: for a „Show values as“ column the formatted value (`"66.7%"`), for a formula error its code;
+     * otherwise like before (`'' + value`).
+     *
+     * @param {number} rowIndex - the row
+     * @param {number} columnIndex - the column
+     * @returns {string} the text
+     */
+    getTextValueAt(rowIndex: number, columnIndex: number): string;
+    /** A „Show values as“ column without an own body renderer shows the formatted text. */
+    getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    /** The message of a formula error as tooltip. */
+    getTooltipAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * Drops derived values: cached aggregates of formulas and „Show values as“ (called by the table on filter,
+     * sorting, editing, `updateCells` and `api.repaint()`).
+     *
+     * @param {DerivedValuesChangeIf} [_change] - the changed rows (not used)
+     * @since 1.1.95
+     */
+    invalidateDerivedValues(_change?: DerivedValuesChangeIf): void;
+    /** „Show values as“ of one cell; the reference are the filtered rows in display order. */
+    protected applyShowValuesAs(rowIndex: number, property: string, value: unknown, options: ShowValuesAsIf): unknown;
+    protected readPropertyPath(t: any, property: string): unknown;
+    protected getAggregationSourceForValues(): {
+        signal: unknown;
+        length: number;
+        rows: () => ArrayLike<unknown>;
+    };
     /**
      * Retrieves the filtered and sorted rows from the dataset.
      * These rows are used for rendering the table.
@@ -565,6 +630,11 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * const sortedRows = [...this.getFilteredRows()].sort(comparator);
      */
     protected genericFlatTableSortComparator(property: string, f: number): (a: T, b: T) => number;
+    /**
+     * The value of a row for a sort pass: a calculated column is computed once per row (memo for this pass, not
+     * 2·n·log n times); formula errors sort last (as `undefined`).
+     */
+    protected createSortValueReader(property: string): (row: T) => unknown;
     /**
      * Recursively gets a value from an object using an array of property names.
      * This is a helper method used by `getValueByT` to access nested properties.