@guiexpert/table 1.1.92 → 1.1.94

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

@@ -6,6 +6,8 @@ import { TableOptionsIf } from '../data/options/table-options.if.js';
 import { TableModelIf } from '../data/tablemodel/table-model.if.js';
 import { TableModel } from '../data/tablemodel/table-model.js';
 import { SelectionModelIf } from '../selection/selection-model.if.js';
+import { RowNumberOptionsIf } from '../data/common/row-number-options.if.js';
+import { AggregateFooterConfig } from '../data/tablemodel/areamodel/aggregate-footer-options.if.js';
 
 /**
  * Parameters of {@link TableFactory.createTableModel} – pass any subset (`Partial<CreateTableModelPara>`).
@@ -37,14 +39,45 @@ export interface CreateTableModelPara {
     headerAreaModel: AreaModelIf;
     /** Model of the body. Default: built from `rows` (objects or tree rows) or `bodyData`. See {@link AreaModel} for own models. */
     bodyAreaModel: AreaModelIf;
-    /** Model of the footer. Default: `footerData`, otherwise no footer. Totals that follow the filter: an own {@link AreaModel}. */
+    /** Model of the footer. Default: `footerAggregates`, `footerData`, otherwise no footer. */
     footerAreaModel: AreaModelIf;
+    /**
+     * A footer with totals that follow filter and sorting ({@link AreaModelAggregateFooter}): `{ total: "sum" }` (one
+     * row – the key is the property of the column), `[{ label, aggregates }, …]` (several rows) or full
+     * {@link AggregateFooterOptionsIf}. Row height: `defaultRowHeights.footer`. Ignored with an own `footerAreaModel`
+     * (warning); `footerData` is ignored with it (warning).
+     *
+     * @example
+     * const tableModel = TableFactory.createTableModel({
+     *   rows: orders,
+     *   columnDefs,
+     *   footerAggregates: { quantity: "sum", total: "sum" }       // footer: "100,000 rows" | … | 549,812 | 27,481,033.5
+     * });
+     *
+     * @since 1.1.94
+     */
+    footerAggregates: AggregateFooterConfig;
     /** Number of columns fixed on the left (side "west"). Default 0. */
     fixedLeftColumnCount: number;
     /** Number of columns fixed on the right (side "east"). Default 0. */
     fixedRightColumnCount: number;
     /** Show a checkbox column for every row. Default false. */
     rowCheckboxVisible: boolean;
+    /**
+     * Row numbers (1, 2, 3 …) in a column in front of all others, fixed on the left: `true` or options
+     * ({@link RowNumberOptionsIf}). Puts a {@link RowNumberColumnDef} in front of `columnDefs` and adds 1 to
+     * `fixedLeftColumnCount`; `headerData`/`footerData` get an empty cell in front. Default false.
+     *
+     * The column is a real column: the indices of all other columns are one higher – use properties where you can
+     * ({@link TableApi.getColumnIndex}). With `bodyData` or own area models the flag is ignored (with a warning), because
+     * their columns would shift – put a `RowNumberColumnDef` into the column definitions of your models yourself.
+     *
+     * @example
+     * const tableModel = TableFactory.createTableModel({ rows: orders, columnDefs, rowNumbersVisible: true });
+     *
+     * @since 1.1.93
+     */
+    rowNumbersVisible: boolean | Partial<RowNumberOptionsIf>;
     /** Row heights of header, body and footer in px. Default: `tableOptions.defaultRowHeights`, otherwise 34 / 34 / 34. */
     defaultRowHeights: DefaultRowHeightsIf;
     /** The columns: property, header label, width, classes, renderers, sorting, editing. See {@link ColumnDef}. */
@@ -120,6 +153,17 @@ export declare class TableFactory {
      * });
      */
     static createTableModel(p: Partial<CreateTableModelPara>): TableModelIf;
+    /**
+     * `footerAggregates`: returns the configuration if the factory builds an aggregate footer (after the body model),
+     * `undefined` if there is none or an own `footerAreaModel` wins.
+     */
+    private static checkFooterAggregates;
+    /**
+     * `rowNumbersVisible`: puts a RowNumberColumnDef in front of the column definitions (and an empty cell in front of
+     * `headerData`/`footerData`) and fixes it on the left. Only where the factory builds the models from the column
+     * definitions – with `bodyData` or own area models every column would shift by one.
+     */
+    private static addRowNumberColumn;
     /**
      * Constructs a table model (an instance of `TableModelIf`) by using provided parameters.
      *

package/lib/table/instanceof-workaround.d.ts

@@ -1,3 +1,13 @@
+import { RowNumberColumnDef } from './data/common/row-number-column-def.js';
+import { AreaModelAggregateFooter } from './data/tablemodel/areamodel/area-model-aggregate-footer.js';
+import { AreaModelRowGroups } from './data/tablemodel/areamodel/area-model-row-groups.js';
+import { RowGroupIf } from './rowgroup/row-group.if.js';
+import { RowGroupColumnDef } from './rowgroup/row-group-column-def.js';
+import { TreeRowIf } from './data/common/tree-row-if.js';
+import { AreaModelPivot } from './data/tablemodel/areamodel/area-model-pivot.js';
+import { PivotTableModel } from './pivot/pivot-table-model.js';
+import { PivotColumnDef } from './pivot/pivot-column-def.js';
+
 /**
  * Checks if the given row is a tree row.
  *
@@ -17,6 +27,16 @@ export declare function isTreeRow(row: any): boolean;
  * @category Utilities
  */
 export declare function isAreaModelTree(model: any): boolean;
+/**
+ * True for a {@link CheckboxCellRenderer} – also from another copy of the core (no `instanceof`).
+ *
+ * @example
+ * isCheckboxCellRenderer(new CheckboxCellRenderer()); // true
+ *
+ * @since 1.1.91
+ * @category Utilities
+ */
+export declare function isCheckboxCellRenderer(o: any): boolean;
 /**
  * Checks if the given object is a CheckboxColumnDef.
  *
@@ -25,14 +45,131 @@ export declare function isAreaModelTree(model: any): boolean;
  *
  * @category Utilities
  */
+export declare function isCheckboxColumnDef(o: any): boolean;
 /**
- * True for a {@link CheckboxCellRenderer} – also from another copy of the core (no `instanceof`).
+ * True for a {@link RowNumberColumnDef} – also from another copy of the core (no `instanceof`).
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getColumnDef(0)`
+ * @returns {boolean} true for a row number column
  *
  * @example
- * isCheckboxCellRenderer(new CheckboxCellRenderer()); // true
+ * const hasRowNumbers = isRowNumberColumnDef(tableModel.getColumnDef(0));
  *
- * @since 1.1.91
- * @category Utilities
+ * @since 1.1.93
+ * @category Row numbers
  */
-export declare function isCheckboxCellRenderer(o: any): boolean;
-export declare function isCheckboxColumnDef(o: any): boolean;
+export declare function isRowNumberColumnDef(o: any): o is RowNumberColumnDef;
+/**
+ * True for an {@link AreaModelAggregateFooter} – also from another copy of the core (no `instanceof`).
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getAreaModel("footer")`
+ * @returns {boolean} true for a footer with totals
+ *
+ * @example
+ * const footer = tableModel.getAreaModel("footer");
+ * const totals = isAreaModelAggregateFooter(footer) ? footer.getResults() : {};
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function isAreaModelAggregateFooter(o: any): o is AreaModelAggregateFooter;
+/**
+ * True for a group of a row grouping ({@link RowGroupIf}) – the `data` of a group row. Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `treeRow.data`
+ * @returns {boolean} true for a group
+ *
+ * @example
+ * const row = tableModel.getBodyModel().getRowByIndex(rowIndex);
+ * if (isTreeRow(row) && isRowGroup(row.data)) console.log(row.data.label, row.data.count);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isRowGroup(o: any): o is RowGroupIf;
+/**
+ * True for a group row of a row grouping: a tree row whose `data` is a {@link RowGroupIf} (detail rows hold your objects).
+ *
+ * @param {any} row - a body row, e.g. `tableModel.getBodyModel().getRowByIndex(rowIndex)` or `mouseEvent.row`
+ * @returns {boolean} true for a group row
+ *
+ * @example
+ * const eventListener = new EventAdapter();
+ * eventListener.onMouseClicked = (evt: GeMouseEvent) => {
+ *   const row = tableModel.getBodyModel().getRowByIndex(evt.rowIndex);
+ *   if (isGroupRow(row)) console.log("group", row.data.path);
+ * };
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isGroupRow(row: any): row is TreeRowIf<RowGroupIf>;
+/**
+ * True for the body model of a row grouping ({@link AreaModelRowGroups}). It is a tree as well
+ * (`isAreaModelTree` is true). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getBodyModel()`
+ * @returns {boolean} true for a row grouping
+ *
+ * @example
+ * const body = tableModel.getBodyModel();
+ * const groups = isAreaModelRowGroups(body) ? body.getGroups() : [];
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isAreaModelRowGroups(o: any): o is AreaModelRowGroups;
+/**
+ * True for the group column of a row grouping ({@link RowGroupColumnDef}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. a column definition
+ * @returns {boolean} true for the group column
+ *
+ * @example
+ * const groupColumnIndex = (tableModel.getColumnDefs() ?? []).findIndex(isRowGroupColumnDef);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isRowGroupColumnDef(o: any): o is RowGroupColumnDef;
+/**
+ * True for the table model of a pivot table ({@link PivotTableModel}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableApi.getTableModel()`
+ * @returns {boolean} true for a pivot table
+ *
+ * @example
+ * const model = tableApi.getTableModel();
+ * const config = isPivotTableModel(model) ? model.getPivotConfig() : undefined;
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isPivotTableModel(o: any): o is PivotTableModel;
+/**
+ * True for the body of a pivot table ({@link AreaModelPivot}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getBodyModel()`
+ * @returns {boolean} true for a pivot body
+ *
+ * @example
+ * const body = tableModel.getBodyModel();
+ * const total = isAreaModelPivot(body) ? pivotBody.getResult().getValue() : undefined;
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isAreaModelPivot(o: any): o is AreaModelPivot;
+/**
+ * True for a value column of a pivot table ({@link PivotColumnDef}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. a column definition
+ * @returns {boolean} true for a value, subtotal or total column of a pivot
+ *
+ * @example
+ * const valueColumns = (tableModel.getColumnDefs() ?? []).filter(isPivotColumnDef);
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isPivotColumnDef(o: any): o is PivotColumnDef;

package/lib/table/pivot/area-model-pivot-header.d.ts

@@ -0,0 +1,9 @@
+import { AreaModelCellGroups } from '../data/tablemodel/areamodel/area-model-cell-groups.js';
+
+/**
+ * The header of a pivot table: header groups with classes for the labels – column groups (`2026`, `Jan`) start at the
+ * left of their span (a wide group stays readable), column labels (`Q1`, `Revenue`) sit above their numbers.
+ */
+export declare class AreaModelPivotHeader extends AreaModelCellGroups {
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+}

package/lib/table/pivot/pivot-column-def.d.ts

@@ -0,0 +1,28 @@
+import { ColumnDef } from '../data/tablemodel/column/column-def.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { PivotColumnInfoIf } from './pivot-column-info.if.js';
+
+/**
+ * A value column of a pivot table – created by {@link PivotFactory} (you don't create them yourself). Its property is
+ * stable for the same column key and value (`pivot:[["monat","s:Jan"],"sum(umsatz)"]`), so widths and sorting are
+ * remembered like for any column; {@link AreaModelPivot.getColumnProperty} builds it for you.
+ *
+ * @example
+ * const columns = tableModel.getColumnDefs()?.filter(isPivotColumnDef) ?? [];
+ * columns.map(c => c.pivot.kind);   // ["value", "value", "total"]
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotColumnDef extends ColumnDef {
+    readonly pivot: PivotColumnInfoIf;
+    /** Marker for {@link isPivotColumnDef} (works across copies of the core). */
+    readonly type = "PivotColumnDef";
+    /**
+     * @param {string} property - the stable property
+     * @param {string} headerLabel - the label in the lowest header row
+     * @param {PivotColumnInfoIf} pivot - what the column shows
+     * @param {SizeIf} [width] - the width (default 100 px)
+     */
+    constructor(property: string, headerLabel: string, pivot: PivotColumnInfoIf, width?: SizeIf);
+}

package/lib/table/pivot/pivot-column-info.if.d.ts

@@ -0,0 +1,25 @@
+import { RowGroupIf } from '../rowgroup/row-group.if.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+
+/**
+ * What a value column of a pivot table shows ({@link AreaModelPivot.getColumnInfo}): the values of one column key
+ * (`"value"`), the subtotal of a column group (`"subtotal"`, with {@link PivotConfigIf.columnSubtotals}) or the
+ * total over all column keys (`"total"`).
+ *
+ * @example
+ * const info = pivotModel.getPivotBody().getColumnInfo(columnIndex);
+ * if (info?.kind === "value") console.log(info.column?.path, info.value.name);   // ["Jan"], "sum(umsatz)"
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotColumnInfoIf {
+    /** `"value"` – one column key, `"subtotal"` – a column group, `"total"` – all columns. */
+    readonly kind: "value" | "subtotal" | "total";
+    /** The column key (lowest level) or column group; undefined for the total. */
+    readonly column?: RowGroupIf;
+    /** The value shown in the column. */
+    readonly value: PivotValueInfoIf;
+    /** The index of the value in {@link PivotConfigIf.values}. */
+    readonly valueIndex: number;
+}

package/lib/table/pivot/pivot-config.if.d.ts

@@ -0,0 +1,58 @@
+import { RowGroupField } from '../rowgroup/row-group-field.type.js';
+import { RowGroupExpanded } from '../rowgroup/row-group-model-options.if.js';
+import { PivotValue } from './pivot-value.type.js';
+
+/**
+ * What a pivot table shows: the row fields (grouped like a row grouping), the column fields (their values become
+ * columns) and the values (aggregated per row × column), plus subtotals and totals. Used by
+ * {@link PivotFactory.createTableModel}, {@link pivotRows} and {@link TableApi.setPivotConfig}.
+ *
+ * Fields have the form of a row grouping level ({@link RowGroupField}): a property path, a function (e.g. the quarter
+ * of a date) or {@link RowGroupFieldIf} with `label`, `format` and `order` – `groupBy` of a row grouping works as
+ * `rowFields`.
+ *
+ * @example
+ * const config: PivotConfigIf<Sale> = {
+ *   rowFields: ["region", "produkt"],
+ *   columnFields: [{ value: "monat", order: "insertion" }],   // Jan before Feb (order in the data)
+ *   values: ["umsatz"],                                        // sum of umsatz
+ *   emptyText: "–"
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotConfigIf<T = any> {
+    /** The row levels, top first. Several levels form a hierarchy with subtotals. An empty list shows one total row. */
+    rowFields: RowGroupField<T>[];
+    /** The fields whose values become columns, top first. Several fields form a multi-row header. Default `[]` (totals only). */
+    columnFields?: RowGroupField<T>[];
+    /** The aggregated values (at least one): `"umsatz"` (sum) or {@link PivotValueIf}. With several values every column key gets one column per value. */
+    values: PivotValue<T>[];
+    /** Show the aggregates in the group rows (subtotals). Default true. */
+    subtotals?: boolean;
+    /**
+     * A total column behind every column group (e.g. "2026 Total" behind its quarters); the group gets a toggle and,
+     * when collapsed, shows only its total. Default: true with two or more column fields.
+     */
+    columnSubtotals?: boolean;
+    /** The total column(s) on the right: `"fixed"` (default, fixed on the right), `true` (last columns, scrolled) or `false`. */
+    totalColumn?: boolean | "fixed";
+    /** The total row in the footer. Default true. */
+    totalRow?: boolean;
+    /**
+     * The maximum number of column keys (of the lowest column level). More keys: the first ones are shown, a warning is
+     * logged and {@link PivotResult.truncated} is true – total column, subtotal columns and total row still count all rows.
+     * Default 1000.
+     */
+    maxColumns?: number;
+    /** Expanded row groups: `true` (default), `false`, open levels as a number (`0` = all closed) or a function per group. */
+    expanded?: RowGroupExpanded<T>;
+    /** The label of empty keys (`null`, `undefined`, `""`) – rows and columns. Default `"(empty)"`. */
+    emptyLabel?: string;
+    /** The text of a cell without data (the value stays `undefined`, not 0). Default `""`. */
+    emptyText?: string;
+    /** The word for totals: header of the total column, label of the total row, suffix of subtotal columns. Default `"Total"`. */
+    totalLabel?: string;
+}

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

@@ -0,0 +1,13 @@
+import { PivotValue, PivotValueInfoIf } from './pivot-value.type.js';
+
+/** A value resolved for a pass over the rows. */
+export interface ResolvedPivotValue<T = any> extends PivotValueInfoIf {
+    /** undefined for `count` (the value does not matter) */
+    readonly getValue?: (row: T) => unknown;
+}
+/** The default maximum number of column keys. */
+export declare const DEFAULT_MAX_COLUMNS = 1000;
+/** The default word for totals. */
+export declare const DEFAULT_TOTAL_LABEL = "Total";
+/** Resolves the values of a pivot configuration: aggregator, getter, unique name, label. */
+export declare function resolvePivotValues<T>(values: PivotValue<T>[] | undefined): ResolvedPivotValue<T>[];

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

@@ -0,0 +1,40 @@
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { CellGroupIf } from '../data/tablemodel/cellgroup/cell-group.if.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { RowGroup } from '../rowgroup/row-group.js';
+import { PivotConfigIf } from './pivot-config.if.js';
+import { PivotResult } from './pivot-result.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+import { RowGroupField } from '../rowgroup/row-group-field.type.js';
+
+/** Columns, header groups and fixed right columns of a pivot. */
+export interface PivotLayout {
+    /** leading columns (row numbers, group column) + value columns + total columns */
+    columnDefs: ColumnDefIf[];
+    /** the header groups, one leaf per column in the same order */
+    cellGroups: CellGroupIf[];
+    /** the number of total columns fixed on the right */
+    fixedRightColumnCount: number;
+}
+export interface PivotLayoutOptions {
+    /** width of a value column (default 100 px) */
+    valueWidth?: SizeIf;
+    /** ids of collapsed column groups (kept when the layout is built again) */
+    closedIds?: ReadonlySet<string>;
+    /** the widths of existing columns by property (kept when the layout is built again) */
+    widths?: ReadonlyMap<string, SizeIf>;
+}
+/** The property of a value column: column path + value name. */
+export declare function pivotValueProperty(column: RowGroup, value: PivotValueInfoIf): string;
+/** The property of a subtotal column of a column group. */
+export declare function pivotSubtotalProperty(column: RowGroup, value: PivotValueInfoIf): string;
+/** The property of a total column. */
+export declare function pivotTotalProperty(value: PivotValueInfoIf): string;
+/** The default name of a field path in a header: the last part, first letter upper case ("address.city" → "City"). */
+export declare function humanizePath(path: string): string;
+/** The header of the group column of a pivot: the row field labels, e.g. "Region › Produkt" ("" without row fields). */
+export declare function pivotGroupHeaderLabel(rowFields: RowGroupField[]): string;
+/** True if the subtotal columns are on (default: two or more column fields). */
+export declare function hasColumnSubtotals(config: PivotConfigIf): boolean;
+/** Builds the columns and the grouped header of a pivot. */
+export declare function buildPivotLayout<T>(result: PivotResult<T>, config: PivotConfigIf<T>, leading: ColumnDefIf[], options?: PivotLayoutOptions): PivotLayout;

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

@@ -0,0 +1,157 @@
+import { PivotConfigIf } from './pivot-config.if.js';
+import { RowGroupIf } from '../rowgroup/row-group.if.js';
+import { RowGroup } from '../rowgroup/row-group.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+
+/**
+ * The result of a pivot ({@link pivotRows}, {@link AreaModelPivot.getResult}): the row and column hierarchies and the
+ * aggregated value of every combination – cells, subtotals and totals. DOM-free; the table reads its cells from here.
+ *
+ * - `getValue(row, column)` – a cell; leave out `row` for the column total, `column` for the row total, both for the
+ *   grand total. Groups of higher levels give subtotals.
+ * - A combination without rows is `undefined` (not 0).
+ * - Every cell is computed from the rows (leaf cells) or by merging aggregation **states** – an average of a region is
+ *   the average of its rows, never the average of the product averages. Order of the merges: first along the columns
+ *   (column groups), then along the rows (row groups, total row) – children in key order. This matters for
+ *   `first`/`last` only: a row total adds its rows in source order, a column group merges its keys in key order, so
+ *   the two may differ. Keys cut off by `maxColumns` still count in subtotals and totals.
+ *
+ * @example
+ * const result = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"] });
+ * const nord = result.rowGroups[0];                      // Nord
+ * const jan = result.columnLeaves.find(c => c.key === "Jan");
+ * result.getValue(nord, jan);   // 150
+ * result.getValue(nord);        // 270 – the row total
+ * result.getValue(undefined, jan);   // 230 – the column total
+ * result.getValue();            // 450
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotResult<T = any> {
+    /** @internal the source rows */
+    readonly source: ArrayLike<T>;
+    /** The row groups of the top level (with sub-groups); empty without row fields. */
+    readonly rowGroups: RowGroup<T>[];
+    /** The column groups of the top level (with sub-groups); empty without column fields. */
+    readonly columnGroups: RowGroup<T>[];
+    /** The shown column keys of the lowest level in display order – at most {@link PivotConfigIf.maxColumns}. */
+    readonly columnLeaves: RowGroup<T>[];
+    /** The values (name, label, aggregator, format). */
+    readonly values: readonly PivotValueInfoIf[];
+    /** True if there were more column keys than {@link PivotConfigIf.maxColumns} (the rest is not shown as columns). */
+    readonly truncated: boolean;
+    /** the lowest column key (index into allColumnLeaves) of every source row, -1: no column fields */
+    private readonly columnLeafOf;
+    /** all column keys of the lowest level, also the ones cut off by maxColumns (they count in subtotals) */
+    private readonly allColumnLeaves;
+    /** shown column groups (all levels) */
+    private readonly shownColumns;
+    /** non-leaf column groups (shown or not), deepest first */
+    private readonly columnParentsPostOrder;
+    /** non-leaf row groups, deepest first */
+    private readonly rowParentsPostOrder;
+    /** row leaves in display order */
+    private readonly rowLeaves;
+    private cells;
+    /** the values with their getters */
+    private readonly resolved;
+    private accept?;
+    /**
+     * Groups the rows by the row and column fields and aggregates the values. Use {@link pivotRows}.
+     *
+     * @param {ArrayLike<T>} source - the rows (not changed)
+     * @param {PivotConfigIf<T>} config - fields and values
+     * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count
+     */
+    constructor(
+    /** @internal the source rows */
+    source: ArrayLike<T>, config: PivotConfigIf<T>, accept?: (sourceIndex: number) => boolean);
+    /**
+     * Computes all cells again (same keys) – after a filter change or changed values.
+     *
+     * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count
+     *
+     * @example
+     * result.compute(i => sales[i].monat === "Jan");
+     * result.getValue();   // 230
+     */
+    compute(accept?: (sourceIndex: number) => boolean): void;
+    /**
+     * The aggregated value of a cell, a subtotal or a total.
+     *
+     * @param {RowGroupIf<T>} [row] - a row group (any level); undefined = all rows (column totals)
+     * @param {RowGroupIf<T>} [column] - a column key or column group (any level); undefined = all columns (row totals)
+     * @param {number | string} [value=0] - the index or name of the value
+     * @returns {unknown} the result, `undefined` if no row has this combination
+     *
+     * @example
+     * result.getValue(result.rowGroups[0], undefined, "sum(umsatz)");   // the total of the first row group
+     */
+    getValue(row?: RowGroupIf<T>, column?: RowGroupIf<T>, value?: number | string): unknown;
+    /**
+     * The number of rows of a cell, a subtotal or a total (after the filter).
+     *
+     * @param {RowGroupIf<T>} [row] - a row group; undefined = all rows
+     * @param {RowGroupIf<T>} [column] - a column key or group; undefined = all columns
+     * @returns {number} the row count, 0 for a combination without rows
+     *
+     * @example
+     * result.getCount(result.rowGroups[0]);   // 3 – the rows of Nord
+     */
+    getCount(row?: RowGroupIf<T>, column?: RowGroupIf<T>): number;
+    /**
+     * The rows behind a cell (drill-down), after the filter, in source order.
+     *
+     * @param {RowGroupIf<T>} [row] - a row group; undefined = all rows
+     * @param {RowGroupIf<T>} [column] - a column key or group; undefined = all columns
+     * @returns {T[]} a new array
+     *
+     * @example
+     * result.getSourceRows(nord, jan).map(s => s.umsatz);   // [100, 50]
+     */
+    getSourceRows(row?: RowGroupIf<T>, column?: RowGroupIf<T>): T[];
+    /**
+     * True if a column group is shown – false for groups whose keys were all cut off by `maxColumns`.
+     *
+     * @param {RowGroupIf<T>} column - a column group
+     * @returns {boolean} true if it has at least one shown column key
+     */
+    isColumnShown(column: RowGroupIf<T>): boolean;
+    /** @internal the index of a value (by index or name), -1 if unknown */
+    valueIndex(value: number | string): number;
+    private cell;
+    private newCell;
+    /** One pass over the rows of a row leaf: the cells per column key and the row total, then the column groups. */
+    private leafCells;
+    private mergeInto;
+    private mergeMap;
+}
+/**
+ * Pivots rows: groups them by the row fields and by the column fields and aggregates the values of every combination,
+ * with subtotals and totals – the engine behind {@link PivotFactory} (DOM-free, also usable without a table). One pass
+ * over the rows; empty combinations are `undefined`, averages are computed from sum and count.
+ *
+ * @param {ArrayLike<T>} rows - the rows (not changed)
+ * @param {PivotConfigIf<T>} config - row fields, column fields, values (see {@link PivotConfigIf})
+ * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count (index into `rows`)
+ * @returns {PivotResult<T>} the hierarchies and the values
+ *
+ * @example
+ * // case 1: regions × months, sum of umsatz
+ * const result = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"] });
+ * result.rowGroups.map(r => `${r.label}: ${result.getValue(r)}`);   // ["Nord: 270", "Süd: 180"]
+ * result.getValue();                                                // 450
+ *
+ * @example
+ * // case 3: the average of a column total is the average of its rows
+ * const avg = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"],
+ *   values: [{ value: "umsatz", aggregator: "avg" }] });
+ * const jan = avg.columnLeaves.find(c => c.key === "Jan");
+ * avg.getValue(undefined, jan);   // 76.666… (230 / 3) – not 77.5, the mean of 75 and 80
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function pivotRows<T = any>(rows: ArrayLike<T>, config: PivotConfigIf<T>, accept?: (sourceIndex: number) => boolean): PivotResult<T>;

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

@@ -0,0 +1,86 @@
+import { TableModel } from '../data/tablemodel/table-model.js';
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.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 { AreaModelCellGroups } from '../data/tablemodel/areamodel/area-model-cell-groups.js';
+import { AreaModelPivot } from '../data/tablemodel/areamodel/area-model-pivot.js';
+import { AreaModelPivotFooter } from '../data/tablemodel/areamodel/area-model-pivot-footer.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { PivotConfigIf } from './pivot-config.if.js';
+
+/**
+ * The table model of a pivot table – a {@link TableModel} (all wrappers take it) whose columns follow the pivot: a
+ * group column, one column per column key × value, subtotal and total columns, a grouped header and a total row.
+ * Created by {@link PivotFactory.createTableModel}.
+ *
+ * Pivot again at runtime – other fields, values or rows – with {@link TableApi.setPivotConfig}: the same model and the
+ * same table get new columns (no new model, so no rebuild in the framework wrappers).
+ *
+ * @example
+ * const tableModel = PivotFactory.createTableModel<Sale>({
+ *   rows: sales, rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"]
+ * });
+ * tableModel.getPivotBody().getResult().getValue();   // 450
+ * tableModel.getPivotConfig().columnFields;           // ["monat"]
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotTableModel<T = any> extends TableModel {
+    private readonly leadingColumnDefs;
+    private readonly valueWidth?;
+    /** Marker for {@link isPivotTableModel} (works across copies of the core). */
+    readonly kind = "PivotTableModel";
+    private pivotFixedRightColumnCount;
+    /**
+     * Use {@link PivotFactory.createTableModel}.
+     *
+     * @param {AreaModelCellGroups} header - the grouped header
+     * @param {AreaModelPivot<T>} body - the pivot body
+     * @param {AreaModelPivotFooter<T>} footer - the total row
+     * @param {ColumnDefIf[]} leadingColumnDefs - the columns in front of the values (row numbers, group column)
+     * @param {ColumnDefIf[]} columnDefs - all columns (leading columns, value columns, total columns)
+     * @param {number} fixedRightColumnCount - the fixed total columns on the right
+     * @param {number} fixedLeftColumnCount - fixed columns on the left (the leading columns)
+     * @param {DefaultRowHeightsIf} defaultRowHeights - row heights
+     * @param {GetT<SelectionModelIf>} getSelectionModel - selection model factory
+     * @param {SizeIf} [valueWidth] - the width of new value columns
+     */
+    constructor(header: AreaModelCellGroups, body: AreaModelPivot<T>, footer: AreaModelPivotFooter<T>, leadingColumnDefs: ColumnDefIf[], columnDefs: ColumnDefIf[], fixedRightColumnCount: number, fixedLeftColumnCount: number, defaultRowHeights: DefaultRowHeightsIf, getSelectionModel: GetT<SelectionModelIf>, valueWidth?: SizeIf | undefined);
+    getFixedRightColumnCount(): number;
+    /**
+     * The body: cells, row groups, drill-down ({@link AreaModelPivot.getCellSourceRows}) and the {@link PivotResult}.
+     *
+     * @returns {AreaModelPivot<T>} the body model
+     *
+     * @example
+     * const pivotBody = pivotModel.getPivotBody();
+     * pivotBody.getResult().columnLeaves.map(c => c.label);   // ["Feb", "Jan"]
+     */
+    getPivotBody(): AreaModelPivot<T>;
+    /**
+     * The current configuration.
+     *
+     * @returns {PivotConfigIf<T>} a copy
+     *
+     * @example
+     * pivotModel.getPivotConfig().rowFields;   // ["region"]
+     */
+    getPivotConfig(): PivotConfigIf<T>;
+    /**
+     * Pivots again with a changed configuration and/or new rows: new keys, columns, header and totals in this model.
+     * Prefer {@link TableApi.setPivotConfig} – it also lays the table out again; after this method alone the table
+     * must be laid out by you.
+     *
+     * @param {Partial<PivotConfigIf<T>>} changes - the changed parts, e.g. `{ columnFields: ["jahr"] }`
+     * @param {T[]} [rows] - new source rows (default: the current ones)
+     *
+     * @example
+     * pivotModel.setPivotConfig({ values: [{ value: "umsatz", aggregator: "avg" }] });
+     */
+    setPivotConfig(changes: Partial<PivotConfigIf<T>>, rows?: T[]): void;
+    /** Columns and header for the current pivot of the body. */
+    private relayout;
+}