@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/row-drag/row-drag-service.d.ts

@@ -0,0 +1,130 @@
+import { TableScope } from '../table-scope.js';
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { RowDropTargetIf } from './row-drop-target.if.js';
+import { RowDragOptionsIf } from './row-drag-options.if.js';
+
+/**
+ * Whether a body cell shows a drag handle: `"none"`, `"enabled"`, or `"disabled"` (managed drag while the table is
+ * sorted or filtered).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type RowDragHandleState = "none" | "enabled" | "disabled";
+/**
+ * Row drag of one table (`tableScope.rowDragService`): drag handles ({@link ColumnDefIf.rowDrag}), pointer drag with
+ * ghost, drop marker and auto-scroll, the keyboard alternative (`MOVE_ROW_UP` / `MOVE_ROW_DOWN`) and the managed move.
+ * Use {@link TableApi.moveRows}, {@link TableApi.isRowDragging} and {@link TableApi.cancelRowDrag} instead.
+ *
+ * Pointer Events (mouse, touch, pen) – only on the drag handle; its `pointerdown` is prevented, so the mouse handler
+ * of the table (range selection, column drag) never sees it.
+ *
+ * @category Internals
+ * @since 1.1.95
+ */
+export declare class RowDragService {
+    private readonly tableScope;
+    private pending?;
+    private session?;
+    private sessionAbortController?;
+    private ghost?;
+    private indicator?;
+    private autoScrollFrame;
+    private suppressClick;
+    private warnedUnsupported;
+    constructor(tableScope: TableScope);
+    /** The options of this table ({@link TableOptionsIf.rowDragOptions} + defaults). */
+    get options(): RowDragOptionsIf;
+    /** true while rows are dragged with the pointer. */
+    isDragging(): boolean;
+    /** true if the row is one of the dragged rows (it is painted dimmed). */
+    isDragSourceRow(rowIndex: number): boolean;
+    /**
+     * Why a managed drag is not possible right now: `"sorted"` (a column has the sort state asc/desc), `"filtered"`
+     * (a filter hides rows) – `undefined` if it is possible or the drag is unmanaged.
+     */
+    getBlockReason(): "sorted" | "filtered" | undefined;
+    /**
+     * The drag handle of a body cell: none (no `rowDrag`, a group or pivot row, a managed drag the model cannot do),
+     * enabled or disabled (managed + sorted/filtered).
+     */
+    getHandleState(rowIndex: number, columnDef: ColumnDefIf | undefined, areaModel: AreaModelIf): RowDragHandleState;
+    /**
+     * Adds the drag handle to a rendered body cell (called by the render pass for columns with `rowDrag`).
+     *
+     * @param {HTMLDivElement} cell - the cell div
+     * @param {RowDragHandleState} state - from {@link getHandleState}
+     */
+    decorateCell(cell: HTMLDivElement, state: RowDragHandleState): void;
+    private onPointerDown;
+    private listenToDocument;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerCancel;
+    private onKeyDown;
+    private onClickCapture;
+    /** Starts the drag after the threshold – false if the listener vetoed it. */
+    private startPointerDrag;
+    /** Computes the drop target from the pointer position, reports a change, moves ghost and marker, auto-scrolls. */
+    private updateTarget;
+    private autoScrollStep;
+    /**
+     * Speed in px per frame (negative = up): a quadratic ramp inside the zone at the top/bottom edge of the body, full
+     * speed above (header) and below (footer) the body.
+     */
+    private calcAutoScrollSpeed;
+    /** The row under the pointer and the position (before/after/inside) – computed, not read from the DOM. */
+    private computeTarget;
+    private isValidTarget;
+    private drop;
+    /**
+     * Cancels a running drag (Escape, `pointercancel`, {@link TableApi.cancelRowDrag}, destroy): `onRowDragEnd` with the
+     * type `"cancel"`, nothing is moved.
+     */
+    cancel(originalEvent?: PointerEvent | KeyboardEvent): void;
+    /** Ends the pointer session: listeners, ghost, marker, auto-scroll. */
+    private stopListening;
+    /** Releases everything (TableScope.destroy). A running drag is cancelled. */
+    destroy(): void;
+    private createDragElements;
+    private getGhostText;
+    private renderDragElements;
+    /** The rows' width (fixed columns + center columns), at most the visible width – the marker ends with the rows. */
+    private getMarkerWidth;
+    /**
+     * Moves rows in the model (managed), repaints, keeps focus and selection on the moved rows and announces the new
+     * position.
+     *
+     * @param {number[]} rowIndices - display indices
+     * @param {RowDropTargetIf} target - drop target
+     * @param {boolean} reselect - select the moved rows again (multi-row drag)
+     * @returns {number} the new display index of the first moved row, -1 if nothing moved
+     */
+    moveRows(rowIndices: number[], target: RowDropTargetIf, reselect?: boolean): number;
+    private findDisplayIndices;
+    /**
+     * `MOVE_ROW_UP` / `MOVE_ROW_DOWN`: moves the focused row (or the selected rows, if it is one of them) one position.
+     * Trees: among the siblings.
+     *
+     * @param {-1 | 1} direction - up or down
+     * @returns {boolean} true if the key was used (a row with a drag handle has the focus)
+     */
+    moveByKeyboard(direction: -1 | 1): boolean;
+    private getFlatKeyboardTarget;
+    private getTreeKeyboardTarget;
+    /** The dragged rows for a grabbed row: all rows with a selection if it is one of them (multiRow), else this one. */
+    getDragRowIndices(rowIndex: number): number[];
+    private getRows;
+    /** Index of the first column whose drag handle is shown for the row, -1 if none. */
+    private getHandleColumnIndex;
+    /** The state of the handle of a row that has one (see {@link getHandleColumnIndex}). */
+    private getHandleStateOfRow;
+    /** true if a column has the sort state asc or desc (the header shows the arrow). */
+    private isSorted;
+    private isManaged;
+    private canModelMove;
+    private createEvent;
+    private announceNotPossible;
+    private texts;
+}

package/lib/table/row-drag/row-drop-target.if.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Where dragged rows are dropped, relative to the row under the drop marker:
+ * `"before"` / `"after"` that row, or `"inside"` it (it becomes the last child – trees only).
+ *
+ * @example
+ * const target: RowDropTargetIf = { rowIndex: 7, position: "before" };   // between row 7 and row 8 (1-based)
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type RowDropPosition = "before" | "after" | "inside";
+/**
+ * The drop target of a row drag ({@link GeRowDragEvent.target}, {@link TableApi.moveRows}).
+ *
+ * `rowIndex` is the display index (body row index) of the target row **before** the rows are moved.
+ *
+ * @example
+ * // move the rows 2 and 3 behind the last row
+ * tableApi.moveRows([2, 3], { rowIndex: tableApi.getDisplayedRowCount() - 1, position: "after" });
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export interface RowDropTargetIf {
+    /** Display index of the row next to (or under) the drop marker – before the move. */
+    rowIndex: number;
+    /** Before or after that row, or inside it (tree: becomes its last child). */
+    position: RowDropPosition;
+}

package/lib/table/rowgroup/group-rows-internals.d.ts

@@ -0,0 +1,14 @@
+import { RowGroup } from './row-group.js';
+import { ResolvedRowGroupField } from './row-group-internals.js';
+import { ResolvedAggregateSpec } from '../aggregation/aggregate-internals.js';
+
+/** {@link groupRows} with resolved levels. @internal */
+export declare function groupRowsResolved<T>(rows: ArrayLike<T>, fields: ResolvedRowGroupField<T>[], emptyLabel: string): RowGroup<T>[];
+/** {@link aggregateRowGroups} with resolved specs. @internal */
+export declare function aggregateRowGroupsResolved<T>(groups: RowGroup<T>[], specs: ResolvedAggregateSpec<T>[], accept?: (sourceIndex: number) => boolean): Record<string, unknown>;
+/** The totals: the merged states of the given groups. @internal */
+export declare function totalsOf<T>(groups: RowGroup<T>[], specs: ResolvedAggregateSpec<T>[]): Record<string, unknown>;
+/** Aggregates the rows of a group of the last level. @internal */
+export declare function computeLeaf<T>(group: RowGroup<T>, specs: ResolvedAggregateSpec<T>[], accept?: (i: number) => boolean): void;
+/** A group above the last level: merges the states of its sub-groups (they stay unchanged). @internal */
+export declare function mergeChildren<T>(group: RowGroup<T>, specs: ResolvedAggregateSpec<T>[]): void;

package/lib/table/rowgroup/group-rows-options.if.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Options of {@link groupRows}.
+ *
+ * @example
+ * const groups = groupRows(orders, ["country"], { emptyLabel: "(no country)" });
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export interface GroupRowsOptionsIf {
+    /** The label of the group of empty keys (`null`, `undefined`, `""`). Default `"(empty)"`. */
+    emptyLabel?: string;
+}

package/lib/table/rowgroup/group-rows.d.ts

@@ -0,0 +1,48 @@
+import { RowGroupField } from './row-group-field.type.js';
+import { GroupRowsOptionsIf } from './group-rows-options.if.js';
+import { AggregateSpecMap } from '../aggregation/aggregate-spec.if.js';
+import { RowGroup } from './row-group.js';
+
+/**
+ * Groups rows by one or more levels – the engine behind {@link AreaModelRowGroups} (and pivot tables). One pass over
+ * the rows with nested `Map`s: keys are compared as values (`1` and `"1"` are different groups, two dates of the same
+ * time one group); `null`, `undefined` and `""` form one group (label `"(empty)"`), which is always last. Groups are
+ * ordered by the `order` of their level (default ascending); the rows of a group stay in source order. The rows are
+ * not changed.
+ *
+ * Aggregates are filled by {@link aggregateRowGroups}.
+ *
+ * @param {ArrayLike<T>} rows - the rows
+ * @param {RowGroupField<T>[]} groupBy - the levels, top first: property paths, functions or {@link RowGroupFieldIf}
+ * @param {GroupRowsOptionsIf} [options] - e.g. the label of empty keys
+ * @returns {RowGroup<T>[]} the groups of the top level (empty for no levels or no rows)
+ *
+ * @example
+ * const groups = groupRows(sales, ["region", "produkt"]);
+ * groups[0].label;                  // "Nord"
+ * groups[0].children[0].getRows();  // the rows of Nord › A
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function groupRows<T = any>(rows: ArrayLike<T>, groupBy: RowGroupField<T>[], options?: GroupRowsOptionsIf): RowGroup<T>[];
+/**
+ * Computes the aggregates of all groups ({@link RowGroupIf.results}) and their row counts ({@link RowGroupIf.count}).
+ * A group of the last level aggregates its rows; every group above **merges** the states of its sub-groups – an
+ * average stays the average of all rows (sum and count are merged), never the average of averages.
+ *
+ * @param {RowGroup<T>[]} groups - the top-level groups of {@link groupRows}
+ * @param {AggregateSpecMap<T>} aggregations - key → aggregator (`{ umsatz: "sum" }`, see {@link AggregateSpecMap})
+ * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count (index into the source rows)
+ * @returns {Record<string, unknown>} the totals over all groups
+ *
+ * @example
+ * const groups = groupRows(sales, ["region", "produkt"]);
+ * const totals = aggregateRowGroups(groups, { umsatz: "avg" });
+ * groups[0].results.umsatz;   // 90 – Nord: (100 + 50 + 120) / 3, not the mean of A (110) and B (50)
+ * totals.umsatz;              // 75
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function aggregateRowGroups<T = any>(groups: RowGroup<T>[], aggregations: AggregateSpecMap<T>, accept?: (sourceIndex: number) => boolean): Record<string, unknown>;

package/lib/table/rowgroup/row-group-column-def.d.ts

@@ -0,0 +1,26 @@
+import { ColumnDef } from '../data/tablemodel/column/column-def.js';
+import { RowGroupColumnOptionsIf } from './row-group-column-options.if.js';
+
+/**
+ * The group column of a row grouping: arrows, indentation and the group labels (`"Nord (3)"`). Created by
+ * {@link RowGroupFactory.createTableModel}; the column is sortable (by group key) and not editable. Its property is
+ * {@link RowGroupColumnDef.PROPERTY} – sort and state refer to it like to any column.
+ *
+ * @example
+ * const tableModel = RowGroupFactory.createTableModel<Sale>({ rows: sales, columnDefs, groupBy: ["region"] });
+ * const groupColumn = tableModel.getColumnDefs()?.find(isRowGroupColumnDef);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare class RowGroupColumnDef extends ColumnDef {
+    /** The property of the group column. */
+    static readonly PROPERTY = "RowGroupColumn";
+    /** Marker for {@link isRowGroupColumnDef} (works across copies of the core). */
+    readonly type = "RowGroupColumnDef";
+    /** The options with defaults. */
+    readonly options: RowGroupColumnOptionsIf;
+    /** True if the header follows the grouping (no own `headerLabel`). */
+    readonly autoHeaderLabel: boolean;
+    constructor(options?: Partial<RowGroupColumnOptionsIf>);
+}

package/lib/table/rowgroup/row-group-column-options.if.d.ts

@@ -0,0 +1,27 @@
+import { SizeIf } from '../data/common/size.if.js';
+import { RowGroupIf } from './row-group.if.js';
+
+/**
+ * Options of the group column ({@link RowGroupColumnDef}) – the column with the arrows and the group labels.
+ *
+ * @example
+ * RowGroupFactory.createTableModel<Sale>({
+ *   rows: sales, columnDefs, groupBy: ["region"],
+ *   groupColumn: { headerLabel: "Region", width: px160, label: g => `${g.label} – ${g.count} sales` }
+ * });
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export interface RowGroupColumnOptionsIf<T = any> {
+    /** The header text. Default: the names of the levels, e.g. `"Region › Produkt"` (follows {@link TableApi.setRowGroupBy}). */
+    headerLabel?: string;
+    /** The width. Default 220 px. */
+    width: SizeIf;
+    /** Show the number of rows behind the key: `"Nord (3)"`. Default true. */
+    showCount: boolean;
+    /** An own label of a group row (text, never HTML). Default: `"<key> (<count>)"`. */
+    label?: (group: RowGroupIf<T>) => string;
+    /** Fix the column on the left (it comes behind row numbers and the checkbox column). Default true. */
+    fixed: boolean;
+}

package/lib/table/rowgroup/row-group-detail-row.d.ts

@@ -0,0 +1,8 @@
+import { TreeRow } from '../data/common/tree-row.js';
+import { TreeRowIf } from '../data/common/tree-row-if.js';
+
+/** A detail row: a tree row with the index of its object in the source rows. */
+export declare class RowGroupDetailRow<T> extends TreeRow<T> {
+    readonly sourceIndex: number;
+    constructor(data: T, parent: TreeRowIf<any> | undefined, deep: number, sourceIndex: number);
+}

package/lib/table/rowgroup/row-group-field.type.d.ts

@@ -0,0 +1,56 @@
+import { ValueAccessor } from '../aggregation/value-accessor.type.js';
+
+/**
+ * The order of the groups of one level: ascending (`"asc"`, the default), descending, in the order the keys first
+ * appear in the rows (`"insertion"`), or an own comparison of two keys. Empty keys (`null`, `undefined`, `""`) are
+ * always last.
+ *
+ * @example
+ * const months: RowGroupOrder = (a, b) => MONTHS.indexOf(a as string) - MONTHS.indexOf(b as string);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export type RowGroupOrder = "asc" | "desc" | "insertion" | ((a: unknown, b: unknown) => number);
+/**
+ * One level of a row grouping in full form: where the key of a row comes from and how the groups of the level are
+ * named and ordered. The short form is just the {@link ValueAccessor} (`"region"` or a function).
+ *
+ * @example
+ * // year › month from a date, newest year first, month names as labels
+ * const groupBy: RowGroupField<Order>[] = [
+ *   { name: "year", label: "Year", value: o => new Date(o.date).getFullYear(), order: "desc" },
+ *   { name: "month", label: "Month", value: o => new Date(o.date).getMonth(), format: m => MONTHS[m as number] }
+ * ];
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export interface RowGroupFieldIf<T = any> {
+    /** The key of a row: a property path (`"region"`, `"address.city"`) or a function (computed keys). */
+    value: ValueAccessor<T>;
+    /**
+     * The id of the level – part of the group ids that remember expanded groups ({@link RowGroupIf.id}).
+     * Default: the property path; for a function `"level<N>"` (give functions a name if you switch between them).
+     */
+    name?: string;
+    /** The name of the level, e.g. in the header of the group column. Default: the header label of the column with this property, otherwise the name. */
+    label?: string;
+    /** The text of a key in the group label. Default: the key as text, dates as date (en-US), empty keys `emptyLabel`. Text only – never HTML. */
+    format?: (key: unknown) => string;
+    /** The order of the groups of this level. Default `"asc"`. */
+    order?: RowGroupOrder;
+}
+/**
+ * One level of a row grouping: a property path (`"region"`), a function (`o => o.date.getFullYear()`) or the full form
+ * {@link RowGroupFieldIf}.
+ *
+ * @example
+ * const groupBy: RowGroupField<Sale>[] = ["region", s => s.produkt.toUpperCase()];
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export type RowGroupField<T = any> = ValueAccessor<T> | RowGroupFieldIf<T>;

package/lib/table/rowgroup/row-group-internals.d.ts

@@ -0,0 +1,31 @@
+import { RowGroupField } from './row-group-field.type.js';
+
+/** A level of a grouping, resolved for a pass over the rows. */
+export interface ResolvedRowGroupField<T = any> {
+    name: string;
+    /** the given label (undefined: the factory takes the column header) */
+    label?: string;
+    /** the property path, undefined for a function */
+    path?: string;
+    getKey: (row: T) => unknown;
+    format?: (key: unknown) => string;
+    /** the order of the groups (empty keys last) */
+    compare: (a: unknown, b: unknown) => number;
+}
+/** The key of the group of empty keys (`null`, `undefined`, `""`). */
+export declare const EMPTY_GROUP_KEY: null;
+/** `null`, `undefined` and `""` form one group. */
+export declare function isEmptyGroupKey(key: unknown): boolean;
+/**
+ * The natural order of two non-empty group keys: numbers, dates (by time), booleans (false first), text (natural,
+ * "A2" before "A10"); keys of different types by type in this order.
+ */
+export declare function compareGroupKeys(a: unknown, b: unknown): number;
+export declare function resolveRowGroupField<T>(field: RowGroupField<T>, level: number): ResolvedRowGroupField<T>;
+export declare function resolveRowGroupFields<T>(groupBy: RowGroupField<T>[] | undefined): ResolvedRowGroupField<T>[];
+/** The key as text with its type – part of the group id (`1` and `"1"` differ, dates by time). */
+export declare function typedGroupKey(key: unknown): string;
+/** The default text of a group key. */
+export declare function defaultGroupKeyLabel(key: unknown, emptyLabel: string): string;
+/** The level labels of a grouping, e.g. for the header of the group column. */
+export declare function rowGroupLevelLabels<T>(fields: ResolvedRowGroupField<T>[], headerOf: (path: string) => string | undefined): string[];

package/lib/table/rowgroup/row-group-layout.d.ts

@@ -0,0 +1,13 @@
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { RowGroupField } from './row-group-field.type.js';
+
+/** The header text of the group column for these levels, e.g. "Region › Produkt". */
+export declare function rowGroupHeaderLabel(groupBy: RowGroupField[], columnDefs: ColumnDefIf[]): string;
+/**
+ * Adapts the columns of a row grouping to its current levels: hides the columns of the grouped properties (and shows
+ * the ones it hid before that are no longer grouped) and sets the header of the group column.
+ *
+ * @returns true if the body is a row grouping
+ */
+export declare function updateRowGroupLayout(tableModel: TableModelIf): boolean;

package/lib/table/rowgroup/row-group-model-options.if.d.ts

@@ -0,0 +1,39 @@
+import { RowGroupField } from './row-group-field.type.js';
+import { AggregateSpecMap } from '../aggregation/aggregate-spec.if.js';
+import { RowGroupIf } from './row-group.if.js';
+import { RowGroupColumnOptionsIf } from './row-group-column-options.if.js';
+
+/**
+ * Which groups are expanded: all (`true`), none (`false`), the levels above a number (`1` = the top level is open, its
+ * sub-groups are closed; `0` = all closed), or a function per group.
+ *
+ * @example
+ * const onlyNorth: RowGroupExpanded<Sale> = group => group.path[0] === "Nord";
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export type RowGroupExpanded<T = any> = boolean | number | ((group: RowGroupIf<T>) => boolean);
+/**
+ * Options of an {@link AreaModelRowGroups} (the factory {@link RowGroupFactory.createTableModel} fills them).
+ *
+ * @example
+ * const body = new AreaModelRowGroups<Sale>(sales, columnDefs, { groupBy: ["region"], aggregations: { umsatz: "sum" } });
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export interface RowGroupModelOptionsIf<T = any> {
+    /** The levels, top first. An empty list shows the rows without groups. */
+    groupBy: RowGroupField<T>[];
+    /** The aggregates of the group rows; the key is the property of the column that shows it (`{ umsatz: "sum" }`). */
+    aggregations?: AggregateSpecMap<T>;
+    /** Which groups are expanded at the start and in new paths after regrouping. Default true. */
+    expanded?: RowGroupExpanded<T>;
+    /** The label of the group of empty keys (`null`, `undefined`, `""`). Default `"(empty)"`. */
+    emptyLabel?: string;
+    /** Label options of the group column (`showCount`, `label`). */
+    groupColumn?: Partial<RowGroupColumnOptionsIf<T>>;
+    /** Hide the columns of the grouped properties (their values are in the group column). Default true. */
+    hideGroupedColumns?: boolean;
+}

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

@@ -0,0 +1,51 @@
+import { RowGroupIf } from './row-group.if.js';
+
+/**
+ * A group of a row grouping (see {@link RowGroupIf}). Created by {@link groupRows} and {@link AreaModelRowGroups} –
+ * you don't create groups yourself.
+ *
+ * @example
+ * const groups = groupRows(sales, ["region"]);
+ * aggregateRowGroups(groups, { umsatz: "sum" });
+ * groups.map(g => `${g.label}: ${g.results.umsatz}`);   // ["Nord: 270", "Süd: 180"]
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare class RowGroup<T = any> implements RowGroupIf<T> {
+    readonly key: unknown;
+    readonly label: string;
+    readonly level: number;
+    readonly field: string;
+    readonly path: readonly unknown[];
+    readonly parent: RowGroup<T> | undefined;
+    /** @internal the source rows */
+    readonly source: ArrayLike<T>;
+    /** Marker for {@link isRowGroup}. */
+    readonly type = "RowGroup";
+    readonly children: RowGroup<T>[];
+    count: number;
+    results: Record<string, unknown>;
+    /** @internal indices into the source rows (last level only), in source order */
+    readonly sourceIndices: number[];
+    /** @internal aggregation states (one per spec), kept for merging and partial updates */
+    states: unknown[];
+    /** @internal the filter of the last aggregation (source index → kept) */
+    accept?: (sourceIndex: number) => boolean;
+    /** @internal parts of the id: level name + typed key per level */
+    readonly idParts: [string, string][];
+    constructor(key: unknown, label: string, level: number, field: string, path: readonly unknown[], parent: RowGroup<T> | undefined, 
+    /** @internal the source rows */
+    source: ArrayLike<T>, typedKey: string);
+    /** A stable id from level names and keys, e.g. `rowgroup:[["region","s:Nord"]]`. */
+    get id(): string;
+    /** True for a group of the last level (it holds rows, no sub-groups). */
+    isLeaf(): boolean;
+    getRows(filtered?: boolean): T[];
+    /**
+     * The source indices of all rows of the group (and its sub-groups), group by group.
+     * @internal
+     */
+    collectIndices(filtered: boolean, ret: number[]): number[];
+}

package/lib/table/rowgroup/row-group.if.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A group of a row grouping – the `data` of a group row in an {@link AreaModelRowGroups} and the result of
+ * {@link groupRows}. Groups of the last level hold the rows; groups above hold sub-groups.
+ *
+ * @example
+ * // the group of a clicked row
+ * const group = model.getRowGroup(rowIndex);
+ * if (group) console.log(group.path, group.count, group.results.umsatz);   // ["Nord", "A"], 2, 220
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export interface RowGroupIf<T = any> {
+    /** Marker for {@link isRowGroup} (works across copies of the core). */
+    readonly type: "RowGroup";
+    /** The key of the group, as the rows have it (`null` for the group of empty keys: `null`, `undefined`, `""`). */
+    readonly key: unknown;
+    /** The key as text (`format` of the level, otherwise the default text). */
+    readonly label: string;
+    /** The level, 0 = top. */
+    readonly level: number;
+    /** The name of the level ({@link RowGroupFieldIf.name}). */
+    readonly field: string;
+    /** The keys from the top level down to this group. */
+    readonly path: readonly unknown[];
+    /**
+     * A stable id built from the level names and keys – the same data give the same id (persistence of expanded groups).
+     * Keys that are objects or symbols get an id per page load only (they can't be stored).
+     */
+    readonly id: string;
+    /** The parent group, undefined on the top level. */
+    readonly parent: RowGroupIf<T> | undefined;
+    /** The sub-groups, empty on the last level. */
+    readonly children: RowGroupIf<T>[];
+    /** The number of rows in the group (after the filter). */
+    readonly count: number;
+    /** The aggregates of the group by key (after the filter), e.g. `{ umsatz: 270 }`. */
+    readonly results: Record<string, unknown>;
+    /**
+     * The rows of the group and of all sub-groups, in the order of the grouped view: sub-group by sub-group, the rows of a
+     * group in source order – or sorted, after the table sorted them.
+     *
+     * @param {boolean} [filtered=true] - only the rows the filter keeps
+     * @returns {T[]} a new array
+     */
+    getRows(filtered?: boolean): T[];
+}

package/lib/table/selection/selection-aggregator.d.ts

@@ -0,0 +1,37 @@
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { SelectionModelIf } from './selection-model.if.js';
+import { SelectionAggregatesIf } from '../aggregation/selection-aggregates.if.js';
+
+/**
+ * Computes count, sum, average, minimum and maximum of the selected body cells ({@link SelectionAggregatesIf}) – what
+ * {@link TableApi.getSelectionAggregates} returns, e.g. for a status bar under the table.
+ *
+ * Counted are the selected cells of the visible data columns (no row numbers, no checkbox column); the numbers are the
+ * cell values (`getValueAt`) of type `number`. Negative ranges (Ctrl/⌘-click) are respected. A selection whose ranges
+ * cover more than {@link maxCells} cells is not computed (`capped: true`).
+ *
+ * @example
+ * SelectionAggregator.maxCells = 5_000_000;            // allow bigger selections
+ * const a = new SelectionAggregator().aggregate(tableModel, selectionModel);
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare class SelectionAggregator {
+    /**
+     * Upper limit for the cells of the selected ranges (Ctrl+A on millions of rows). Like
+     * {@link CopyService.maxCopyCells}: above it nothing is computed.
+     *
+     * @example
+     * SelectionAggregator.maxCells = 2_000_000;
+     */
+    static maxCells: number;
+    /**
+     * @param {TableModelIf} tableModel - the table model (body rows, columns, visibility)
+     * @param {SelectionModelIf | undefined} selectionModel - the selection; none → all zero
+     * @returns {SelectionAggregatesIf} the aggregates of the selected cells
+     */
+    aggregate(tableModel: TableModelIf, selectionModel: SelectionModelIf | undefined): SelectionAggregatesIf;
+    /** The visible data columns between c1 and c2 (no hidden, row number or checkbox columns). */
+    private dataColumns;
+}

package/lib/table/selection/selection-service.d.ts

@@ -51,6 +51,13 @@ export declare class SelectionService implements OnActionTriggeredIf {
      */
     onMouseClicked(evt: GeMouseEvent, _previousEvt: GeMouseEvent | undefined): boolean;
     onActionTriggered(actionId: ActionId): boolean;
+    /** True if the column is a row number column ({@link RowNumberColumnDef}). */
+    private isRowNumberColumn;
+    /** A click on the header cell of the row numbers: everything (selection types "row" and "range"). */
+    private selectAllByRowNumberHeader;
+    /** Selection type "range", click on a row number: the whole row – new, toggled (Ctrl/⌘) or removed (Ctrl/⌘+Alt). */
+    private clickRowNumber;
+    private static isRangeSelection;
     /** Speaks a message for screen readers – only if the selection model can select anything. */
     private announce;
     /** Runs `fn` so that all selection changes in it reach the table's listener as ONE onSelectionChanged event. */

package/lib/table/service/convenience-dom.service.d.ts

@@ -26,6 +26,11 @@ export interface AddColumnDivPara {
     sortState?: SortState;
     /** Accessible name of the row checkbox (`showCheckboxWihoutExtraColumn`), e.g. "Select row 5". @since 1.1.91 */
     checkboxAriaLabel?: string;
+    /**
+     * Index of the first data column – the column of the checkbox of `showCheckboxWihoutExtraColumn` and of the tree
+     * label. 0, behind a {@link RowNumberColumnDef} 1. Default 0. @since 1.1.93
+     */
+    firstDataColumnIndex?: number;
 }
 /** @category DOM */
 export declare class ConvenienceDomService {

package/lib/table/service/excel-service.d.ts

@@ -24,6 +24,8 @@ import { ExcelServiceIf } from './excel-service.if.js';
  * @category Export & clipboard
  */
 export declare class ExcelService implements ExcelServiceIf {
+    /** Understands cells `{ value, numberFormat }` ({@link ExcelFormattedValueIf}), since 1.1.95. */
+    readonly supportsNumberFormats = true;
     /**
      * Downloads a matrix data as an Excel file.
      *
@@ -44,6 +46,10 @@ export declare class ExcelService implements ExcelServiceIf {
     createExcelBlob(matrix: Array<Array<any>>, author?: string): Promise<Blob>;
     private generateMap;
     private getX1WorksheetsSheet1Xml;
+    /** Number format → cell style index (1-based; 0 = default), filled by withNumberFormats() before the sheet is written. */
+    private numberFormatStyles;
+    /** Adds one cell style per number format used in the matrix (`<numFmts>` + `<cellXfs>`); unchanged without formats. */
+    private withNumberFormats;
     private escapeXml;
     private getCellAddress;
     /**