@guiexpert/table 1.1.93 → 1.1.96

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

@@ -6,6 +6,10 @@ import { FilterFunction } from '../../common/filter-function.js';
 import { SorterService } from '../../../service/sorter.service.js';
 import { SortItem } from '../../common/sort-item.js';
 import { TreeRowIf } from '../../common/tree-row-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';
 
 /**
  * Represents a  tree-based table model.
@@ -57,6 +61,8 @@ export declare class AreaModelTree<S> extends AbstractAreaModel<TreeRow<S>> {
     private lastPredictFn?;
     /** `row.keep` was set for the current filter (it depends on the filter and the data, not on expand/collapse). */
     private keepMarked;
+    /** „Show values as“: shown value per row and property (cleared on filter, sorting and invalidation). */
+    private showValuesCache;
     constructor(areaIdent: AreaIdent, rows: TreeRowIf<S>[], defaultRowHeight: number, columnDefs?: ColumnDefIf[]);
     changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
     /**
@@ -106,6 +112,20 @@ export declare class AreaModelTree<S> extends AbstractAreaModel<TreeRow<S>> {
      * @since 1.1.91
      */
     getDisplayedChildren(row: TreeRowIf<S>): TreeRowIf<S>[];
+    /**
+     * The leaves (rows without children) of the whole tree, depth-first in the current order – independent of the
+     * expanded state. Used for totals: collapsing a node does not change them, and parent rows are not counted twice.
+     *
+     * @param {boolean} [filtered=true] - only the leaves the active filter keeps (`externalFilterChanged`); `false`: all
+     * @returns {TreeRowIf<S>[]} a new array
+     *
+     * @example
+     * const treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+     * const total = aggregate(treeModel.getLeafRows(), row => row.data.total, "sum");
+     *
+     * @since 1.1.94
+     */
+    getLeafRows(filtered?: boolean): TreeRowIf<S>[];
     /**
      * The displayed rows: all parents expanded and accepted by the active filter, in display order.
      *
@@ -122,7 +142,84 @@ export declare class AreaModelTree<S> extends AbstractAreaModel<TreeRow<S>> {
      * @since 1.1.92
      */
     getUnfilteredRowCount(): number;
+    /**
+     * Row drag: true if the rows can be moved to the target – no filter hides a displayed row, and the target is none of
+     * the dragged rows and no descendant of them (no cycle). `"before"` / `"after"` = sibling of the target row,
+     * `"inside"` = last child.
+     *
+     * @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
+     * const treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+     * treeModel.canMoveRows([0], { rowIndex: 1, position: "inside" });   // false if row 1 is a child of row 0
+     *
+     * @since 1.1.95
+     */
+    canMoveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: moves tree rows (with their children) in front of / behind the target row (siblings) or into it
+     * (`"inside"`: last children, the target is expanded) – in place in {@link rows} and the `children` arrays;
+     * `parent` and `deep` follow. See {@link canMoveRows}.
+     *
+     * @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 treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+     * treeModel.moveRows([3], { rowIndex: 0, position: "inside" });
+     * tableApi.repaintHard();   // or simply tableApi.moveRows([3], { rowIndex: 0, position: "inside" })
+     *
+     * @since 1.1.95
+     */
+    moveRows(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /** The topmost tree rows of the display indices (children travel with their parent). */
+    private getDragRows;
     getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * The value of a tree row for a property – before „Show values as“: the computed value of a calculated column,
+     * otherwise the property (path) of `row.data`. Subclasses (row groups) return their aggregates for group rows.
+     *
+     * @param {TreeRowIf<S>} row - the tree row
+     * @param {string} prop - the property of the column
+     * @returns {any} the raw value
+     * @since 1.1.95
+     */
+    protected getRawValueOfRow(row: TreeRowIf<S>, prop: string): 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 here)
+     * @since 1.1.95
+     */
+    invalidateDerivedValues(_change?: DerivedValuesChangeIf): void;
+    /**
+     * „Show values as“ of one tree row: percentages of the column total relate to the (filtered) leaf rows,
+     * `percentOfParentTotal`, `runningTotal`, `differenceFromPrevious` and `rank` to the displayed siblings.
+     */
+    protected applyShowValuesAs(row: TreeRowIf<S>, property: string, value: unknown, options: ShowValuesAsIf): unknown;
+    protected readPropertyPath(t: any, property: string): unknown;
+    protected getAggregationSourceForValues(): {
+        signal: unknown;
+        length: number;
+        rows: () => ArrayLike<unknown>;
+    };
     getRowHeight(_rowIndex: number): number;
     /**
      * All rows share `defaultRowHeight` – unless a subclass overrides `getRowHeight()`, then row heights may

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

@@ -1,3 +1,5 @@
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { DerivedValuesChangeIf } from './derived-values-change.if.js';
 import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { CheckedType } from '../../common/checked-type.js';
 import { CheckboxModelIf } from '../../../checkbox/checkbox-model.if.js';
@@ -280,6 +282,98 @@ export interface AreaModelIf {
      * @since 1.1.92
      */
     getUnfilteredRowCount?(): number;
+    /**
+     * Optional (row drag, managed mode): true if the rows can be moved to the target – e.g. false for a node dropped
+     * into its own child, or while a filter hides rows. Without {@link moveRows} the table cannot move rows itself.
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows (ascending)
+     * @param {RowDropTargetIf} target - the drop target (display index before the move)
+     * @returns {boolean} true if {@link moveRows} would move them
+     *
+     * @example
+     * class TasksBodyModel extends AreaModel {
+     *   tasks: string[] = ["Write", "Test", "Ship"];
+     *   override getRowCount(): number { return this.tasks.length; }
+     *   override getValueAt(rowIndex: number): any { return this.tasks[rowIndex]; }
+     *   canMoveRows(rowIndices: number[], target: RowDropTargetIf): boolean { return target.position !== "inside"; }
+     *   moveRows(rowIndices: number[], target: RowDropTargetIf): boolean {
+     *     return moveArrayItems(this.tasks, rowIndices, getInsertBeforeIndex(target)) > -1;
+     *   }
+     * }
+     *
+     * @since 1.1.95
+     */
+    canMoveRows?(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Optional (row drag, managed mode): moves the rows to the target in the model – the table calls it on a drop and
+     * for `tableApi.moveRows()`, then repaints. Implemented by `AreaModelObjectArray`, `AreaModelArrayOfArrays` and
+     * `AreaModelTree` (in place in their row arrays). See {@link canMoveRows} for an example.
+     *
+     * @param {number[]} rowIndices - display indices of the dragged rows (ascending)
+     * @param {RowDropTargetIf} target - the drop target (display index before the move)
+     * @returns {boolean} true if the rows were moved
+     *
+     * @since 1.1.95
+     */
+    moveRows?(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Optional: drops cached, derived values (e.g. the totals of an {@link AreaModelAggregateFooter}). The table calls
+     * it for all three areas when data may have changed: filter, sorting, editing, `updateCells()` and the public
+     * `tableApi.repaint()` / `repaintHard()` – not on scrolling or internal repaints.
+     *
+     * After an edit and `updateCells()` the table passes `change` (since 1.1.94): the area and the displayed rows that
+     * changed – a model may recompute only what depends on them ({@link AreaModelRowGroups} recomputes the groups of
+     * these rows). Without `change` anything may have changed.
+     *
+     * @example
+     * class CachedTotalsFooter extends AreaModel {
+     *   private total?: number;
+     *   constructor(private readonly body: AreaModelObjectArray<Order>) {
+     *     super();
+     *     this.areaIdent = "footer";
+     *   }
+     *   invalidateDerivedValues(): void { this.total = undefined; }
+     *   override getRowCount(): number { return 1; }
+     *   override getValueAt(_row: number, _col: number): any {
+     *     return this.total ??= this.body.getFilteredRows().reduce((sum, o) => sum + o.total, 0);
+     *   }
+     * }
+     *
+     * @since 1.1.94
+     */
+    invalidateDerivedValues?(change?: DerivedValuesChangeIf): void;
+    /**
+     * Optional: true for a cell that names its row (a label such as "Nord" or "Total") – the table gives it
+     * `role="rowheader"` instead of `gridcell`, so screen readers announce it with the row.
+     *
+     * @example
+     * class LabeledBody extends AreaModel {
+     *   isRowHeaderCell(_rowIndex: number, columnIndex: number): boolean { return columnIndex === 0; }
+     * }
+     *
+     * @since 1.1.94
+     */
+    isRowHeaderCell?(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Optional: true if the column with this property is calculated (`ColumnDefIf.valueGetter` / `formula`).
+     * Implemented by the object-array, tree, row-group and pivot models.
+     *
+     * @example
+     * tableModel.getBodyModel().isCalculatedProperty?.("total");   // true
+     *
+     * @since 1.1.95
+     */
+    isCalculatedProperty?(property: string): boolean;
+    /**
+     * Optional: the value of a column for a row object – computed for a calculated column, otherwise the property
+     * path ({@link TableApi.getRowValue}). Implemented by the object-array, tree, row-group and pivot models.
+     *
+     * @example
+     * tableModel.getBodyModel().getRowValue?.({ price: 25, quantity: 10 }, "total");   // 250
+     *
+     * @since 1.1.95
+     */
+    getRowValue?(row: any, property: string): unknown;
     /**
      * Returns the value of the cell at the specified row and column indices.
      * This is one of the most important methods in the area model, as it provides

package/lib/table/data/tablemodel/areamodel/derived-values-change.if.d.ts

@@ -0,0 +1,30 @@
+import { AreaIdent } from '../area-ident.type.js';
+
+/**
+ * What changed when the table calls {@link AreaModelIf.invalidateDerivedValues} after an edit or
+ * {@link TableApi.updateCells}: the area and the displayed rows. A model may use it to recompute only what depends on
+ * these rows (a row grouping recomputes the path of the changed row only). Without it everything may have changed.
+ *
+ * @example
+ * class MyModel extends AreaModel {
+ *   private readonly dirtyRows = new Set<number>();
+ *   private allDirty = true;
+ *
+ *   invalidateDerivedValues(change?: DerivedValuesChangeIf): void {
+ *     if (change?.area === "body") {
+ *       change.rowIndices.forEach(r => this.dirtyRows.add(r));   // only these rows
+ *     } else {
+ *       this.allDirty = true;                                      // anything may have changed
+ *     }
+ *   }
+ * }
+ *
+ * @since 1.1.94
+ * @category Area models
+ */
+export interface DerivedValuesChangeIf {
+    /** The area whose values changed. */
+    area: AreaIdent;
+    /** The changed rows (indices of the displayed rows at the time of the change). */
+    rowIndices: number[];
+}

package/lib/table/data/tablemodel/column/column-def.d.ts

@@ -1,5 +1,5 @@
 import { SizeIf } from '../../common/size.if.js';
-import { ColumnDefIf, ValueRowSortComparator } from './column-def.if.js';
+import { CellValidator, ColumnDefIf, RowDragColumnOption, ValueRowSortComparator } from './column-def.if.js';
 import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { AreaObjectMapType } from '../../common/area-map.type.js';
 import { AreaObjectMap } from '../../common/area-map.js';
@@ -7,6 +7,9 @@ import { BooleanFunction } from '../../common/boolean-function.js';
 import { SortState } from '../../common/sort-state.type.js';
 import { GetEditRenderer } from '../../../renderer/edit/edit-cell-renderer.type.js';
 import { editInputPipe } from '../../../renderer/edit/edit-input-pipe.if.js';
+import { ValueGetter, ValueSetter } from '../../../calc/value-getter.type.js';
+import { ShowValuesAsConfig } from '../../../calc/show-values-as.type.js';
+import { FormulaOptionsIf } from '../../../formula/formula-options.if.js';
 
 /**
  * The column definition – see {@link ColumnDefIf} for all fields.
@@ -52,6 +55,17 @@ export declare class ColumnDef implements ColumnDefIf {
     editInputPipe?: editInputPipe | undefined;
     isVisible: BooleanFunction;
     visible: boolean;
+    /** A calculated column, see {@link ColumnDefIf.valueGetter}. */
+    valueGetter?: ValueGetter;
+    /** Writes an edited calculated value back, see {@link ColumnDefIf.valueSetter}. */
+    valueSetter?: ValueSetter;
+    /** „Show values as“, see {@link ColumnDefIf.showValuesAs}. */
+    showValuesAs?: ShowValuesAsConfig;
+    /** The formula of a formula column, see {@link ColumnDefIf.formula}. */
+    formula?: string;
+    rowDrag?: RowDragColumnOption;
+    /** Checks edited values, see {@link ColumnDefIf.validate} (since 1.1.96). */
+    validate?: CellValidator;
     constructor(property: string, headerLabel: string, width?: SizeIf, classes?: AreaObjectMapType<string[]>, rendererMap?: AreaObjectMapType<CellRendererIf>, minWidth?: SizeIf, maxWidth?: SizeIf, sortable?: BooleanFunction | undefined, sortComparator?: ValueRowSortComparator | undefined, sortState?: SortState | undefined, sortStatesOrder?: SortState[] | undefined, sortIconVisible?: BooleanFunction | undefined, editable?: BooleanFunction | undefined, getEditRenderer?: GetEditRenderer | undefined, editInputPipe?: editInputPipe | undefined, isVisible?: BooleanFunction);
     static bodyRenderer(bodyRenderer: CellRendererIf): AreaObjectMap<CellRendererIf>;
     /**
@@ -109,5 +123,21 @@ export declare class ColumnDef implements ColumnDefIf {
         getEditRenderer?: GetEditRenderer;
         /** Converts the editor text before it is stored, e.g. `editInputPipeForNumber`. */
         editInputPipe?: editInputPipe;
+        /** A calculated column: `(row, context) => value` (since 1.1.95). */
+        valueGetter?: ValueGetter;
+        /** Makes a calculated column editable (since 1.1.95). */
+        valueSetter?: ValueSetter;
+        /** „Show values as“: `"percentOfColumnTotal"`, `"rank"` … (since 1.1.95). */
+        showValuesAs?: ShowValuesAsConfig;
+        /**
+         * A formula column, e.g. `"[price] * [quantity] * 1.19"` – compiled once into the `valueGetter` (since 1.1.95,
+         * see {@link compileFormula}). Takes precedence over `valueGetter`.
+         */
+        formula?: string;
+        /** Own functions of the formula (since 1.1.95). */
+        formulaOptions?: FormulaOptionsIf;
+        rowDrag?: RowDragColumnOption;
+        /** Checks edited values: a message for an invalid value (since 1.1.96). */
+        validate?: CellValidator;
     }): ColumnDefIf;
 }

package/lib/table/data/tablemodel/column/column-def.if.d.ts

@@ -5,6 +5,8 @@ import { BooleanFunction } from '../../common/boolean-function.js';
 import { SortState } from '../../common/sort-state.type.js';
 import { GetEditRenderer } from '../../../renderer/edit/edit-cell-renderer.type.js';
 import { editInputPipe } from '../../../renderer/edit/edit-input-pipe.if.js';
+import { ValueGetter, ValueSetter } from '../../../calc/value-getter.type.js';
+import { ShowValuesAsConfig } from '../../../calc/show-values-as.type.js';
 
 /**
  * Represents a function that compares two values for sorting purposes.
@@ -116,4 +118,88 @@ export interface ColumnDefIf {
     getEditRenderer?: GetEditRenderer;
     /** Converts the text of the editor before it is written into the model, e.g. {@link editInputPipeForNumber}. */
     editInputPipe?: editInputPipe;
+    /**
+     * A calculated column: computes the value from the row instead of reading `property` (the data stays unchanged).
+     * Sorting, filter ({@link TableApi.getRowValue}), copy, Excel, totals (`footerAggregates`) and row groups use the
+     * computed value. `property` stays the id of the column (state, `footerAggregates`, other formulas).
+     * Without a {@link ColumnDefIf.valueSetter} the column cannot be edited.
+     *
+     * Supported by the models of `TableFactory.createTableModel({ rows })`, trees, row groups (not by array-of-arrays
+     * models; an own `AreaModel` calls it itself).
+     *
+     * @example
+     * ColumnDef.create({ property: "total", headerLabel: "Total", sortable: TrueFn,
+     *                    valueGetter: (o: Item) => o.price * o.quantity })
+     *
+     * @see Training: [Columns with ColumnDef](https://gui.expert/training/column-definitions/)
+     * @since 1.1.95
+     */
+    valueGetter?: ValueGetter;
+    /**
+     * Makes a calculated column editable: writes the edited value back into the row (return `false` to reject).
+     *
+     * @example
+     * valueSetter: (o: Item, v: unknown) => { o.price = Number(v) / o.quantity; }
+     *
+     * @since 1.1.95
+     */
+    valueSetter?: ValueSetter;
+    /**
+     * Shows the numbers of the column differently without changing the data: share of the column total, running
+     * total, rank … (see {@link ShowValuesAs}). Change it at runtime with {@link TableApi.setShowValuesAs}.
+     *
+     * @example
+     * ColumnDef.create({ property: "total", headerLabel: "Share", showValuesAs: "percentOfColumnTotal" })
+     *
+     * @since 1.1.95
+     */
+    showValuesAs?: ShowValuesAsConfig;
+    /**
+     * The formula of a formula column (`ColumnDef.create({ formula })` compiles it into the `valueGetter`), e.g.
+     * `"[price] * [quantity] * 1.19"`. Informational – change it with {@link TableApi.setColumnFormula}.
+     *
+     * @since 1.1.95
+     */
+    formula?: string;
+    /**
+     * Row drag: the body cells of this column get a drag handle (`true`, or a function that decides per row – e.g. no
+     * handle for locked rows). Dragging the handle moves the row (see {@link TableOptionsIf.rowDragOptions}); the keyboard
+     * alternative is Ctrl+Alt+↑/↓. `TableFactory.createTableModel({ rows, rowDrag: true })` sets it on the first data
+     * column.
+     *
+     * @example
+     * ColumnDef.create({ property: "title", headerLabel: "Task", rowDrag: (task: { locked: boolean }) => !task.locked })
+     *
+     * @since 1.1.95
+     */
+    rowDrag?: RowDragColumnOption;
+    /**
+     * Checks an edited, filled or pasted value (after `editInputPipe`): return a message for an invalid value,
+     * `undefined` for a valid one. Batch edit: invalid values are marked (`ge-table-cell-invalid`, the message as
+     * tooltip) and block {@link TableApi.commitBatchEdit}; otherwise an invalid value is not written.
+     *
+     * @example
+     * ColumnDef.create({
+     *   property: "price", headerLabel: "Price", editable: TrueFn, editInputPipe: editInputPipeForNumber,
+     *   validate: (value: unknown) => typeof value === "number" && value >= 0 ? undefined : "A price is a number ≥ 0",
+     * })
+     *
+     * @since 1.1.96
+     */
+    validate?: CellValidator;
 }
+/**
+ * {@link ColumnDefIf.validate}: a message for an invalid value, `undefined` (or `null`, `""`) for a valid one.
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export type CellValidator<T = any> = (value: unknown, row: T) => string | undefined | null | void;
+/**
+ * {@link ColumnDefIf.rowDrag}: `true` = every row has a drag handle in this column, a function decides per row
+ * (`row` = the row object, a `TreeRow` in a tree; `rowIndex` = display index).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type RowDragColumnOption = boolean | ((row: any, rowIndex: number) => boolean);

package/lib/table/event-adapter.d.ts

@@ -5,6 +5,8 @@ import { EventListenerIf } from './event-listener.if.js';
 import { SelectionModelIf } from './selection/selection-model.if.js';
 import { FocusModelIf } from './focus/focus-model.if.js';
 import { GeStateChangeEvent } from './data/common/event/ge-state-change-event.js';
+import { GeBatchEditEvent } from './data/common/event/ge-batch-edit-event.js';
+import { GeRowDragEvent } from './data/common/event/ge-row-drag-event.js';
 
 /**
  * Empty implementation of {@link EventListenerIf} – extend it and override only the events you need.
@@ -33,4 +35,9 @@ export declare class EventAdapter implements EventListenerIf {
     onFocusChanged(_model: FocusModelIf): void;
     /** @since 1.1.92 */
     onStateChanged(_evt: GeStateChangeEvent): void;
+    onRowDragStart(_evt: GeRowDragEvent): void;
+    onRowDragMove(_evt: GeRowDragEvent): void;
+    onRowDragEnd(_evt: GeRowDragEvent): void;
+    /** @since 1.1.96 */
+    onBatchEditChanged(_evt: GeBatchEditEvent): void;
 }

package/lib/table/event-listener.if.d.ts

@@ -2,6 +2,8 @@ import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
 import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
 import { GeScrollEvent } from './data/common/event/ge-scroll-event.js';
 import { GeStateChangeEvent } from './data/common/event/ge-state-change-event.js';
+import { GeRowDragEvent } from './data/common/event/ge-row-drag-event.js';
+import { GeBatchEditEvent } from './data/common/event/ge-batch-edit-event.js';
 import { SelectionModelIf } from './selection/selection-model.if.js';
 import { FocusModelIf } from './focus/focus-model.if.js';
 import { EventFocusChangedListenerIf } from './focus/event-focus-changed-listener.if.js';
@@ -63,4 +65,34 @@ export interface EventListenerIf extends EventFocusChangedListenerIf, EventSelec
      * @since 1.1.92
      */
     onStateChanged?(evt: GeStateChangeEvent): void;
+    /**
+     * Optional: a row drag started (drag handle moved past the threshold, or Ctrl+Alt+↑/↓). `evt.preventDefault()`
+     * cancels it. See {@link GeRowDragEvent}.
+     *
+     * @since 1.1.95
+     */
+    onRowDragStart?(evt: GeRowDragEvent): void;
+    /**
+     * Optional: the drop target of a row drag changed (not on every pixel). `evt.preventDefault()` marks the target as
+     * invalid (no drop marker, no drop).
+     *
+     * @since 1.1.95
+     */
+    onRowDragMove?(evt: GeRowDragEvent): void;
+    /**
+     * Optional: a row drag ended – `evt.type` is `"end"` (dropped; `evt.moved` = the table moved the rows) or `"cancel"`.
+     * Managed: called after the move (`evt.toIndex` = the real position). Save the new order here; to veto a drop, call
+     * `evt.preventDefault()` in {@link onRowDragMove}.
+     *
+     * @since 1.1.95
+     */
+    onRowDragEnd?(evt: GeRowDragEvent): void;
+    /**
+     * The pending changes of a batch edit changed: values were marked, set back, written or discarded
+     * ({@link TableApi.startBatchEdit}, {@link TableOptionsIf.batchEdit}). Optional.
+     *
+     * @param {GeBatchEditEvent} evt - type, cells of this step, number of pending and invalid cells
+     * @since 1.1.96
+     */
+    onBatchEditChanged?(evt: GeBatchEditEvent): void;
 }

package/lib/table/factory/pivot-factory.d.ts

@@ -0,0 +1,63 @@
+import { PivotTableModelParaIf } from './pivot-table-model-para.if.js';
+import { PivotTableModel } from '../pivot/pivot-table-model.js';
+
+/**
+ * Creates pivot tables: rows grouped by row fields (a hierarchy with subtotals), the values of column fields as
+ * columns (several fields = a multi-row header), aggregated values in the cells, total column and total row.
+ * MIT-licensed, no dependencies – at ag-Grid this is an Enterprise feature.
+ *
+ * The configuration has the form of a row grouping ({@link RowGroupFactory}): fields are property paths, functions
+ * (e.g. the quarter of a date) or {@link RowGroupFieldIf} with label, format and order; values use the aggregators of
+ * {@link Aggregators} (`sum`, `avg`, `count` …) or your own {@link AggregatorIf}. Subtotals and totals are merged from
+ * aggregation states – an average is always the average of the rows.
+ *
+ * Filter with `externalFilterFunction` (it gets your source objects, before the aggregation), sort by clicking a value
+ * column, export with `downloadExcel()`, and pivot again at runtime with {@link TableApi.setPivotConfig}.
+ *
+ * @example
+ * // case 1: regions × months, sum of umsatz, total column and total row
+ * const tableModel = PivotFactory.createTableModel<Sale>({
+ *   rows: sales,
+ *   rowFields: ["region"],
+ *   columnFields: [{ value: "monat", order: "insertion" }],
+ *   values: ["umsatz"]
+ * });
+ * // Region | Jan | Feb | Total
+ * // Nord   | 150 | 120 |   270
+ * // Süd    |  80 | 100 |   180
+ * // Total  | 230 | 220 |   450
+ *
+ * @example
+ * // countries › cities × years, revenue, all groups closed; pivot by another field with a select
+ * const tableModel = PivotFactory.createTableModel<Order>({
+ *   rows: orders,
+ *   rowFields: ["country", "city"],
+ *   columnFields: [{ name: "year", label: "Year", value: o => new Date(o.date).getFullYear() }],
+ *   values: [{ value: "total", label: "Revenue" }],
+ *   expanded: 0
+ * });
+ * select.addEventListener("change", () => tableApi.setPivotConfig({ columnFields: [select.value] }));
+ *
+ * @see Training: [Pivot tables](https://gui.expert/training/pivot-tables/)
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotFactory {
+    /**
+     * Creates the table model of a pivot table (see the class description).
+     *
+     * @param {PivotTableModelParaIf<T>} p - rows, row fields, column fields, values, options
+     * @returns {PivotTableModel<T>} the table model – a {@link TableModelIf}
+     *
+     * @example
+     * // case 3: the average – Jan total is 230 / 3 = 76.67, not the mean of the region averages (77.5)
+     * const tableModel = PivotFactory.createTableModel<Sale>({
+     *   rows: sales, rowFields: ["region"], columnFields: ["monat"],
+     *   values: [{ value: "umsatz", aggregator: "avg" }]
+     * });
+     */
+    static createTableModel<T = any>(p: PivotTableModelParaIf<T>): PivotTableModel<T>;
+    /** The pivot part of the parameters. */
+    private static toConfig;
+}

package/lib/table/factory/pivot-table-model-para.if.d.ts

@@ -0,0 +1,44 @@
+import { TableOptionsIf } from '../data/options/table-options.if.js';
+import { DefaultRowHeightsIf } from '../data/options/default-row-heights.if.js';
+import { GetT } from '../data/common/get-t.js';
+import { SelectionModelIf } from '../selection/selection-model.if.js';
+import { RowNumberOptionsIf } from '../data/common/row-number-options.if.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { RowGroupColumnOptionsIf } from '../rowgroup/row-group-column-options.if.js';
+import { PivotConfigIf } from '../pivot/pivot-config.if.js';
+
+/**
+ * Parameters of {@link PivotFactory.createTableModel}: the rows, the pivot ({@link PivotConfigIf}) and the look of the
+ * table.
+ *
+ * @example
+ * const para: PivotTableModelParaIf<Sale> = {
+ *   rows: sales,
+ *   rowFields: ["region", "produkt"],
+ *   columnFields: [{ value: "monat", order: "insertion" }],
+ *   values: ["umsatz"],
+ *   emptyText: "–",
+ *   valueColumnWidth: px80
+ * };
+ * const tableModel = PivotFactory.createTableModel(para);
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotTableModelParaIf<T = any> extends PivotConfigIf<T> {
+    /** The source rows (not changed). */
+    rows: T[];
+    /** The group column (arrows and row labels): header, width, `showCount` (default false), own label, fixed (default true). */
+    groupColumn?: Partial<RowGroupColumnOptionsIf<T>>;
+    /** The width of a value column. Default 100 px. */
+    valueColumnWidth?: SizeIf;
+    /** Row numbers in front of the group column (counted per displayed row). */
+    rowNumbersVisible?: boolean | Partial<RowNumberOptionsIf>;
+    /** Options of the table (row heights, selection model …). */
+    tableOptions?: TableOptionsIf;
+    /** Row heights of header, body and footer. Default: `tableOptions.defaultRowHeights`. */
+    defaultRowHeights?: DefaultRowHeightsIf;
+    /** Selection model factory. Default: `tableOptions.getSelectionModel`. */
+    getSelectionModel?: GetT<SelectionModelIf>;
+}

package/lib/table/factory/row-group-factory.d.ts

@@ -0,0 +1,70 @@
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { RowGroupTableModelParaIf } from './row-group-table-model-para.if.js';
+
+/**
+ * Creates a table model that groups flat rows: one row per group with an arrow, a label (`"Nord (3)"`) and
+ * aggregates per column, below it the sub-groups or the original rows – plus a total row. MIT-licensed, no
+ * dependencies, built on the tree table ({@link AreaModelRowGroups}).
+ *
+ * What the factory does:
+ * - puts a {@link RowGroupColumnDef} (arrows, labels) behind row numbers and checkbox column and fixes it on the left;
+ * - hides the columns of grouped properties (`hideGroupedColumns`), their values are in the group column;
+ * - builds the body ({@link AreaModelRowGroups}) and a total row from the `aggregations` ({@link AreaModelAggregateFooter}).
+ *
+ * Regroup at runtime with {@link TableApi.setRowGroupBy}; filter, sort, edit and export as in any table.
+ *
+ * @example
+ * // R1: sales by region, sum of umsatz, total row
+ * const tableModel = RowGroupFactory.createTableModel<Sale>({
+ *   rows: sales,
+ *   columnDefs,
+ *   groupBy: ["region"],
+ *   aggregations: { umsatz: "sum" }
+ * });
+ * // ▾ Nord (3) … 270 · A Jan 100 · B Jan 50 · A Feb 120 · ▾ Süd (3) … 180 · … · footer "6 rows" … 450
+ *
+ * @example
+ * // two levels, all groups closed, regroup with a select
+ * const tableModel = RowGroupFactory.createTableModel<Order>({
+ *   rows: orders, columnDefs, groupBy: ["country", "city"],
+ *   aggregations: { quantity: "sum", total: "sum" }, expanded: 0
+ * });
+ * select.addEventListener("change", () => tableApi.setRowGroupBy(select.value.split(",")));
+ *
+ * @see Training: [Row grouping](https://gui.expert/training/row-grouping/)
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare class RowGroupFactory {
+    /**
+     * Creates the table model of a row grouping (see the class description).
+     *
+     * @param {RowGroupTableModelParaIf<T>} p - rows, levels, columns, aggregations, options
+     * @returns {TableModelIf} the table model – its body is an {@link AreaModelRowGroups}
+     *
+     * @example
+     * const tableModel = RowGroupFactory.createTableModel<Sale>({
+     *   rows: sales, columnDefs, groupBy: ["region", "produkt"], aggregations: { umsatz: "avg" }
+     * });
+     * const body = tableModel.getBodyModel() as AreaModelRowGroups<Sale>;
+     * body.getGroups()[0].results.umsatz;   // 90 – Nord, the average of its three rows
+     */
+    static createTableModel<T = any>(p: RowGroupTableModelParaIf<T>): TableModelIf;
+    /**
+     * Hides the columns of the grouped properties (and shows the ones that are no longer grouped) and sets the header of
+     * the group column – after `body.setGroupBy(…)`. {@link TableApi.setRowGroupBy} calls it for you.
+     *
+     * @param {TableModelIf} tableModel - a table model of {@link createTableModel}
+     * @returns {boolean} false if the body is no row grouping
+     *
+     * @example
+     * const body = tableModel.getBodyModel() as AreaModelRowGroups<Sale>;
+     * body.setGroupBy(["produkt"]);
+     * RowGroupFactory.updateLayout(tableModel);
+     * tableApi.recalcWrappers();
+     * tableApi.repaintHard();
+     */
+    static updateLayout(tableModel: TableModelIf): boolean;
+    private static footerConfig;
+}