@guiexpert/table 1.1.94 → 1.1.96

package/lib/table/calc/value-getter.type.d.ts

@@ -0,0 +1,36 @@
+import { ValueGetterContextIf } from './value-getter-context.if.js';
+
+/**
+ * Computes the value of a calculated column from the row (`ColumnDefIf.valueGetter`). The row is the data object
+ * (in a tree the `TreeRow.data`). The data is not changed – sorting, filter (`tableApi.getRowValue`), copy, Excel and
+ * totals use the computed value.
+ *
+ * Keep it fast and free of side effects: it runs for every visible cell on each render (values are not cached) and
+ * once per row for sorting and totals.
+ *
+ * @example
+ * const total: ValueGetter<Item> = row => row.price * row.quantity;
+ * ColumnDef.create({ property: "total", headerLabel: "Total", valueGetter: total });
+ *
+ * @typeParam T - the row type
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ValueGetter<T = any> = (row: T, context: ValueGetterContextIf) => unknown;
+/**
+ * Writes an edited value of a calculated column back into the row (`ColumnDefIf.valueSetter`). Without a setter a
+ * calculated column cannot be edited. Return `false` to reject the value.
+ *
+ * @example
+ * // "total" is price × quantity – editing the total changes the price
+ * const setTotal: ValueSetter<Item> = (row, value) => {
+ *   const total = Number(value);
+ *   if (!Number.isFinite(total) || !row.quantity) return false;
+ *   row.price = total / row.quantity;
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ValueSetter<T = any> = (row: T, value: unknown) => boolean | void;

package/lib/table/data/common/event/ge-batch-edit-event.d.ts

@@ -0,0 +1,46 @@
+import { CellChangeIf } from '../../../batch-edit/cell-change.if.js';
+
+/**
+ * What happened in a batch edit: `"start"` ({@link TableApi.startBatchEdit}), `"change"` (values were marked or a
+ * value was set back), `"commit"` (written), `"cancel"` (discarded).
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export type GeBatchEditEventType = "start" | "change" | "commit" | "cancel";
+/**
+ * Reported by {@link EventListenerIf.onBatchEditChanged}: the pending changes of a batch edit changed – e.g. to enable
+ * a "Save" button.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onBatchEditChanged = (evt: GeBatchEditEvent) => {
+ *   saveButton.disabled = evt.pendingCount === 0 || evt.invalidCount > 0;
+ *   discardButton.disabled = evt.pendingCount === 0;
+ * };
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export declare class GeBatchEditEvent {
+    /** What happened. */
+    readonly type: GeBatchEditEventType;
+    /** The cells of this step (`"commit"`: the written cells, `"cancel"`: the discarded ones). */
+    readonly changes: CellChangeIf[];
+    /** The number of pending cells after this step. */
+    readonly pendingCount: number;
+    /** The number of pending cells with an invalid value. */
+    readonly invalidCount: number;
+    private readonly pendingProvider;
+    constructor(
+    /** What happened. */
+    type: GeBatchEditEventType, 
+    /** The cells of this step (`"commit"`: the written cells, `"cancel"`: the discarded ones). */
+    changes: CellChangeIf[], 
+    /** The number of pending cells after this step. */
+    pendingCount: number, 
+    /** The number of pending cells with an invalid value. */
+    invalidCount: number, pendingProvider?: () => CellChangeIf[]);
+    /** All pending changes after this step (computed when read – it scans the shown rows once). */
+    get pendingChanges(): CellChangeIf[];
+}

package/lib/table/data/common/event/ge-model-change-event.d.ts

@@ -1,9 +1,13 @@
 import { GeCellIndices } from './ge-cell-indices.js';
+import { CellChangeIf, CellChangeSource } from '../../../batch-edit/cell-change.if.js';
 
 /**
  * Reported by {@link EventListenerIf.onModelChanged} after cells were edited: the row and column indices
  * of the changed cells. The new values are already written into the area model.
  *
+ * Since 1.1.96 the event comes **once per change** – an edit, a fill (fill handle, Ctrl/⌘+D), a commit of a batch
+ * edit or {@link TableApi.applyCellChanges} – with all cells, and {@link changes} tells old and new values.
+ *
  * @example
  * override onModelChanged(evt: GeModelChangeEvent): void {
  *   for (const { rowIndex } of evt.cells) {
@@ -19,6 +23,28 @@ import { GeCellIndices } from './ge-cell-indices.js';
  */
 export declare class GeModelChangeEvent {
     cells: GeCellIndices[];
-    constructor(cells: GeCellIndices[]);
+    /**
+     * The changed cells with row object, property, old and new value (since 1.1.96; `undefined` for events created by
+     * own code with the old constructor).
+     */
+    changes?: CellChangeIf<any>[] | undefined;
+    /** What changed the cells: `"edit"`, `"fill"`, `"commit"` or `"api"` (since 1.1.96). */
+    source?: CellChangeSource | undefined;
+    constructor(cells: GeCellIndices[], 
+    /**
+     * The changed cells with row object, property, old and new value (since 1.1.96; `undefined` for events created by
+     * own code with the old constructor).
+     */
+    changes?: CellChangeIf<any>[] | undefined, 
+    /** What changed the cells: `"edit"`, `"fill"`, `"commit"` or `"api"` (since 1.1.96). */
+    source?: CellChangeSource | undefined);
+    /**
+     * An event for a change set (since 1.1.96): `cells` from the row and column indices of the changes.
+     *
+     * @param {CellChangeIf[]} changes - the changed cells
+     * @param {CellChangeSource} source - what changed them
+     * @returns {GeModelChangeEvent} the event
+     */
+    static createForChanges(changes: CellChangeIf[], source: CellChangeSource): GeModelChangeEvent;
     static createSingle(rowIndex: number, columnIndex: number): GeModelChangeEvent;
 }

package/lib/table/data/common/event/ge-row-drag-event.d.ts

@@ -0,0 +1,89 @@
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+
+/**
+ * Phase of a row drag: `"start"` (the pointer moved past the threshold, or a move key), `"move"` (the drop target
+ * changed), `"end"` (dropped) or `"cancel"` (Escape, `pointercancel`, `tableApi.cancelRowDrag()`, destroy).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type GeRowDragEventType = "start" | "move" | "end" | "cancel";
+/**
+ * What started the drag: the pointer (mouse, touch, pen) on a drag handle, or the keyboard
+ * (`MOVE_ROW_UP` / `MOVE_ROW_DOWN`, Ctrl+Alt+↑/↓).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type GeRowDragSource = "pointer" | "keyboard";
+/**
+ * A row drag ({@link EventListenerIf.onRowDragStart}, {@link EventListenerIf.onRowDragMove},
+ * {@link EventListenerIf.onRowDragEnd}).
+ *
+ * Call {@link preventDefault} to veto: in `"start"` no drag happens, in `"move"` the target is invalid (no drop
+ * marker, no drop). In managed mode `"end"` comes after the move (`moved`, `toIndex` = the real position).
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onRowDragEnd = (evt: GeRowDragEvent<Order>) => {
+ *   if (evt.moved) {
+ *     const ids = evt.rows.map(order => order.id);
+ *     void fetch("/api/orders/move", { method: "POST", body: JSON.stringify({ ids, toIndex: evt.toIndex }) });
+ *   }
+ * };
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare class GeRowDragEvent<T = any> {
+    /** Phase of the drag. */
+    readonly type: GeRowDragEventType;
+    /** Pointer or keyboard. */
+    readonly source: GeRowDragSource;
+    /** The dragged row objects (tree: the `TreeRow`s) in display order. */
+    readonly rows: T[];
+    /** Display indices of the dragged rows when the drag started (ascending). */
+    readonly rowIndices: number[];
+    /** The current drop target – `undefined` if there is none (invalid, vetoed, outside the table). */
+    readonly target: RowDropTargetIf | undefined;
+    /**
+     * Flat tables: display index of the first dragged row after the drop (`0` = first row), `-1` without target.
+     * Trees: `-1` before the move; in a managed `"end"` the index the row really got.
+     */
+    toIndex: number;
+    /** true if the pointer is outside the table – e.g. over an own drop zone of the page. */
+    readonly outside: boolean;
+    /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
+    readonly managed: boolean;
+    /** The browser event behind this event (pointer or keyboard). */
+    readonly originalEvent?: PointerEvent | KeyboardEvent | undefined;
+    /** true if the moved rows changed in the table (managed mode, `"end"`, not prevented). */
+    moved: boolean;
+    private prevented;
+    constructor(
+    /** Phase of the drag. */
+    type: GeRowDragEventType, 
+    /** Pointer or keyboard. */
+    source: GeRowDragSource, 
+    /** The dragged row objects (tree: the `TreeRow`s) in display order. */
+    rows: T[], 
+    /** Display indices of the dragged rows when the drag started (ascending). */
+    rowIndices: number[], 
+    /** The current drop target – `undefined` if there is none (invalid, vetoed, outside the table). */
+    target: RowDropTargetIf | undefined, 
+    /**
+     * Flat tables: display index of the first dragged row after the drop (`0` = first row), `-1` without target.
+     * Trees: `-1` before the move; in a managed `"end"` the index the row really got.
+     */
+    toIndex: number, 
+    /** true if the pointer is outside the table – e.g. over an own drop zone of the page. */
+    outside: boolean, 
+    /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
+    managed: boolean, 
+    /** The browser event behind this event (pointer or keyboard). */
+    originalEvent?: PointerEvent | KeyboardEvent | undefined);
+    /** true after {@link preventDefault}. */
+    get defaultPrevented(): boolean;
+    /** Veto: no drag (`"start"`), invalid target (`"move"`); no effect in `"end"` and `"cancel"`. */
+    preventDefault(): void;
+}

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/area-model-aggregate-footer.d.ts

@@ -140,6 +140,11 @@ export declare class AreaModelAggregateFooter<T = any> extends AreaModel impleme
      * @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-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.

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

@@ -1,4 +1,5 @@
 import { AreaModelTree } from './area-model-tree.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
 import { ColumnDefIf } from '../column/column-def.if.js';
 import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { FilterFunction } from '../../common/filter-function.js';
@@ -179,6 +180,36 @@ export declare class AreaModelPivot<T = any> extends AreaModelTree<any> {
      */
     getCellSourceRows(rowIndex: number, columnIndex: number): T[];
     getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * The value of a pivot cell as shown: the aggregate, or with „Show values as“ ({@link PivotValueIf.showValuesAs})
+     * its share of the row total, column total, grand total or parent row.
+     *
+     * @param {RowGroupIf<T> | undefined} group - the row group; `undefined` = all rows (the total row)
+     * @param {PivotColumnInfoIf} info - the column ({@link getColumnInfo})
+     * @returns {unknown} the shown value, `undefined` for an empty cell
+     *
+     * @example
+     * const body = (tableModel as PivotTableModel).getPivotBody();
+     * body.getShownValue(body.getRowGroup(0), body.getColumnInfo(2)!);   // 0.4 – 40 % of the row
+     *
+     * @since 1.1.95
+     */
+    getShownValue(group: RowGroupIf<T> | undefined, info: PivotColumnInfoIf): unknown;
+    /**
+     * Row drag: `false` – the table does not move rows of a pivot table itself (pivot rows are aggregates). With
+     * `rowDragOptions.managed: false` the app gets the events and decides.
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    canMoveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: does nothing (see {@link canMoveRows}).
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    moveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
     getTextValueAt(rowIndex: number, columnIndex: number): string;
     /** Value columns: the {@link AggregateCellRenderer} (text node); the group column: none (label as text). */
     getCellRenderer(_rowIndex: number, columnIndex: number): CellRendererIf | undefined;

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

@@ -1,4 +1,6 @@
 import { AreaModelTree } from './area-model-tree.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { TreeRowIf } from '../../common/tree-row-if.js';
 import { ColumnDefIf } from '../column/column-def.if.js';
 import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { FilterFunction } from '../../common/filter-function.js';
@@ -230,7 +232,23 @@ export declare class AreaModelRowGroups<T = any> extends AreaModelTree<any> {
      * });
      */
     batch(fn: () => void): boolean;
-    getValueAt(rowIndex: number, columnIndex: number): any;
+    /** Group rows: the label resp. the aggregate of the column; detail rows: the value of the row (calculated or path). */
+    protected getRawValueOfRow(row: TreeRowIf<any>, property: string): any;
+    /**
+     * Row drag: `false` – the table does not move rows of a grouped table itself (group rows are built from the data, a change of group means changing data). With
+     * `rowDragOptions.managed: false` the app gets the events and decides.
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    canMoveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: does nothing (see {@link canMoveRows}).
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    moveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
     getTextValueAt(rowIndex: number, columnIndex: number): string;
     /** Group rows: the {@link AggregateCellRenderer} for aggregates, no renderer otherwise; detail rows: the column's. */
     getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
@@ -295,6 +313,10 @@ export declare class AreaModelRowGroups<T = any> extends AreaModelTree<any> {
      */
     invalidateDerivedValues(change?: DerivedValuesChangeIf): void;
     /** After sorting the tree rows: the groups (`getGroups()`, `children`) in display order. */
+    /** An aggregate over a calculated column (key or value = its property) uses the computed value. */
+    private withCalculatedValue;
+    /** A grouping level on a calculated column groups by the computed value. */
+    private withCalculatedKeys;
     private syncGroupOrder;
     /** The label of a group row in the group column. */
     protected getGroupLabel(group: RowGroup<T>): string;