@guiexpert/table 1.1.93 → 1.1.94

package/lib/table/pivot/pivot-value.type.d.ts

@@ -0,0 +1,67 @@
+import { ValueAccessor } from '../aggregation/value-accessor.type.js';
+import { AggregatorRef } from '../aggregation/aggregator-name.type.js';
+import { AggregatorIf } from '../aggregation/aggregator.if.js';
+
+/**
+ * One value of a pivot table in full form: where the value of a row comes from, how it is aggregated, and how its
+ * columns are named. The short form is just the {@link ValueAccessor} (`"umsatz"` = the sum of umsatz).
+ *
+ * @example
+ * const revenue: PivotValueIf<Order> = { value: "total", label: "Revenue" };                  // sum
+ * const orders: PivotValueIf<Order> = { value: "id", aggregator: "count", label: "Orders" };
+ * const avgPrice: PivotValueIf<Order> = {
+ *   value: o => o.total / o.quantity, aggregator: "avg", label: "Avg. price",
+ *   format: v => v === undefined ? "" : `${(v as number).toFixed(2)} €`
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotValueIf<T = any> {
+    /** The value of a row: a property path (`"umsatz"`, `"order.total"`) or a function. */
+    value: ValueAccessor<T>;
+    /** A built-in aggregator by name (`"sum"`, `"avg"`, `"count"` …) or an own {@link AggregatorIf}. Default `"sum"`. */
+    aggregator?: AggregatorRef;
+    /**
+     * The id of the value – part of the column properties and the name in {@link PivotResult.getValue}.
+     * Default: `"<aggregator>(<path>)"`, e.g. `"sum(umsatz)"`; for a function `"<aggregator>(value<N>)"`.
+     */
+    name?: string;
+    /** The header of its columns (with several values). Default: the name. Text only – never HTML. */
+    label?: string;
+    /** The text of a result in a cell. Default: numbers with at most two decimals (`"1,234.5"`). Excel gets the raw value. */
+    format?: (result: unknown) => string;
+}
+/**
+ * A value of a pivot table: a property path or function (summed) or the full form {@link PivotValueIf}.
+ *
+ * @example
+ * const values: PivotValue<Sale>[] = ["umsatz", { value: "umsatz", aggregator: "count", label: "Count" }];
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export type PivotValue<T = any> = ValueAccessor<T> | PivotValueIf<T>;
+/**
+ * A value of a pivot table as the table uses it: name, label, aggregator and format resolved
+ * ({@link PivotResult.values}, {@link PivotColumnInfoIf.value}).
+ *
+ * @example
+ * const pivotBody = pivotModel.getPivotBody();
+ * pivotBody.getResult().values.map(v => v.name);   // ["sum(umsatz)"]
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotValueInfoIf {
+    /** The id ({@link PivotValueIf.name}). */
+    readonly name: string;
+    /** The header label. */
+    readonly label: string;
+    /** The aggregator. */
+    readonly aggregator: AggregatorIf;
+    /** The format of a result, if one was given. */
+    readonly format?: (result: unknown) => string;
+}

package/lib/table/render-scope.d.ts

@@ -8,6 +8,7 @@ import { RendererCleanupFnType } from './renderer/renderer-cleanup-fn.type.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
 import { SideIdent } from './data/side-ident.type.js';
 import { DivScope } from './data/div-scope.type.js';
+import { DerivedValuesChangeIf } from './data/tablemodel/areamodel/derived-values-change.if.js';
 import { AreaModelIf } from './data/tablemodel/areamodel/area-model.if.js';
 import { ArgsAdjustColumnsToRowParentParams } from './data/common/args-adjust-columns-to-row-parent-params.js';
 import { ArgsRenderCellDiv } from './data/common/args-render-cell-div.js';
@@ -116,6 +117,15 @@ export declare class RenderScope extends EleScope {
      * @return {void}
      */
     repaint(): void;
+    /**
+     * Drops cached, derived values of the area models ({@link AreaModelIf.invalidateDerivedValues}, e.g. the totals of an
+     * {@link AreaModelAggregateFooter}) – called where data may have changed (filter, sorting, editing, `updateCells`,
+     * the public `tableApi.repaint()` / `repaintHard()`), not on scrolling.
+     *
+     * @param {DerivedValuesChangeIf} [change] - the changed rows of an edit or `updateCells()` (models may recompute less)
+     * @since 1.1.94
+     */
+    invalidateAggregates(change?: DerivedValuesChangeIf): void;
     /**
      * Repaints the UI by resetting the size of the wrapper div,
      * adjusting the containers and rows, and performing additional adjustments
@@ -183,6 +193,16 @@ export declare class RenderScope extends EleScope {
      * @returns {void}
      */
     updateCells(events: TableCellUpdateEventIf[], repaintAll?: boolean): void;
+    /**
+     * After `updateCells()` without a repaint: draws the rendered aggregate cells of the group rows of a row grouping
+     * again (they follow the changed rows; labels and counts don't change – a moved row repaints the whole table).
+     */
+    protected rerenderGroupRowCells(): void;
+    /**
+     * After `updateCells()` without a repaint: draws the rendered cells of a footer with cached totals again (only if the
+     * footer implements {@link AreaModelIf.invalidateDerivedValues}, and not if the events changed the footer itself).
+     */
+    protected rerenderDerivedFooterCells(events: TableCellUpdateEventIf[]): void;
     /**
      * Rerenders the content of a table cell based on the given parameters.
      *
@@ -360,11 +380,48 @@ export declare class RenderScope extends EleScope {
      *
      * @protected
      *
-     * @returns {0 | 1} The column index of the tree arrow column.
-     *                Returns 0 if the checkbox is not visible,
-     *                otherwise returns 1.
+     * @returns {number} The column index of the tree arrow column: the first data column (0, behind a row number
+     *                column 1), one more with a visible row checkbox column.
+     */
+    protected getTreeArrowColumnIndex(): number;
+    /**
+     * Index of the first column that is not a row number column: 1 behind a {@link RowNumberColumnDef}, otherwise 0.
+     * The checkbox of `showCheckboxWihoutExtraColumn` and the tree arrow are bound to it.
+     *
+     * @returns {number} 0 or 1
+     * @since 1.1.93
+     */
+    getFirstDataColumnIndex(): number;
+    /** false for a row number column: it has no resize handle (its width follows the numbers). */
+    protected isColumnResizable(columnIndex: number): boolean;
+    /**
+     * The last measured text of the row number column and its width (measured again only when the text changes).
+     * `approximate`: measured with the font of the host before a number cell existed – measured again with the font of
+     * a rendered number cell in the next render pass.
+     */
+    private rowNumberWidth?;
+    /** true while the containers are adjusted to a new row number width (no second change in that nested pass). */
+    private adjustingRowNumberWidth;
+    /** the approximate first width is measured again once (see adjustAfterScrolling). */
+    private rowNumberRemeasureScheduled;
+    /**
+     * Fits the width of a leading row number column ({@link RowNumberColumnDef}) to its largest number. Cheap on every
+     * render pass: only the text of the largest number is compared; it is measured (canvas) only when it changed.
+     *
+     * @returns {boolean} true if the width changed (the containers must be adjusted)
+     * @since 1.1.93
+     */
+    protected adjustRowNumberColumnWidth(): boolean;
+    /** A rendered label of a number cell – its font and padding are what the numbers need. */
+    private findRowNumberLabel;
+    /**
+     * Width in px of a row number text: with the font and padding of a rendered number cell label; before the first
+     * number cell exists with the font of the host and 6 px padding on each side (then `approximate` is true).
+     * Digits are measured as "0" (tabular figures: all digits are as wide as the widest).
+     *
+     * @returns {[number, boolean]} the width and whether it is approximate
      */
-    protected getTreeArrowColumnIndex(): 0 | 1;
+    protected measureRowNumberText(text: string): [number, boolean];
     protected addAndRenderCellDiv({ areaModel, areaIdent, sideIdent, rowIndex, index, left, width, height, top, parent, lastRowOfModel }: ArgsRenderCellDiv): [HTMLDivElement, RendererCleanupFnType | undefined];
     /**
      * Applies CSS classes to an HTML element.

package/lib/table/renderer/aggregate-cell-renderer.d.ts

@@ -0,0 +1,27 @@
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { CellRendererIf } from './cell-render.if.js';
+import { DomServiceIf } from '../service/dom-service.if.js';
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+import { RendererCleanupFnType } from './renderer-cleanup-fn.type.js';
+
+/**
+ * Writes the formatted text of a cell (`areaModel.getTextValueAt`) as a text node – never as HTML – in the label
+ * structure of a normal cell (`.ge-table-label-div > .ge-table-label`). {@link AreaModelAggregateFooter} uses it for
+ * its results (`"1,234.5"` instead of the raw `1234.4999999`) and labels when the column has no footer renderer.
+ *
+ * @example
+ * // an own footer model that formats in getTextValueAt and shows that text
+ * class MyFooter extends AreaModel {
+ *   private readonly renderer = new AggregateCellRenderer();
+ *   override getCellRenderer(_row: number, _col: number): CellRendererIf { return this.renderer; }
+ *   override getTextValueAt(_row: number, _col: number): string { return "Σ 42"; }
+ * }
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare class AggregateCellRenderer implements CellRendererIf {
+    /** Marker (works across copies of the core). */
+    readonly type = "AggregateCellRenderer";
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/row-number-cell-renderer.d.ts

@@ -0,0 +1,27 @@
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { CellRendererIf } from './cell-render.if.js';
+import { DomServiceIf } from '../service/dom-service.if.js';
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+import { RendererCleanupFnType } from './renderer-cleanup-fn.type.js';
+import { RowNumberColumnDef } from '../data/common/row-number-column-def.js';
+
+/**
+ * Renders the number of a body row – the body renderer of {@link RowNumberColumnDef}. The text is set as a text node
+ * (never as HTML), in the same label structure as a normal cell (`.ge-table-label-div > .ge-table-label`).
+ *
+ * The table uses it for a `RowNumberColumnDef` with every body model (also own {@link AreaModel}s without renderers).
+ *
+ * @example
+ * const columnDef = new RowNumberColumnDef();
+ * const renderer = columnDef.rendererMap.body; // a RowNumberCellRenderer
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare class RowNumberCellRenderer implements CellRendererIf {
+    private readonly columnDef;
+    /** Marker (works across copies of the core). */
+    readonly type = "RowNumberCellRenderer";
+    constructor(columnDef: Pick<RowNumberColumnDef, "getRowNumberText">);
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

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;
+}