@guiexpert/table 1.1.92 → 1.1.94

package/lib/table/aggregation/aggregate-internals.d.ts

@@ -0,0 +1,30 @@
+import { AggregatorIf } from './aggregator.if.js';
+import { AggregateSpec } from './aggregate-spec.if.js';
+import { ValueAccessor } from './value-accessor.type.js';
+
+/**
+ * A spec of {@link AggregateSpecMap} resolved for a pass over rows.
+ */
+export interface ResolvedAggregateSpec<T = any> {
+    key: string;
+    aggregator: AggregatorIf;
+    /** where the value comes from: the spec's `value`, otherwise the key as property path */
+    value: ValueAccessor<T>;
+    /** undefined for `count` (the value does not matter) */
+    getValue?: (row: T) => unknown;
+    format?: (result: unknown) => string;
+}
+/**
+ * Resolves one entry of an {@link AggregateSpecMap}: the aggregator object, the value getter (default: the key as
+ * property path) and the format.
+ */
+export declare function resolveAggregateSpec<T>(key: string, spec: AggregateSpec<T>): ResolvedAggregateSpec<T>;
+/**
+ * Runs resolved specs over the rows in one pass and returns the states (for `merge` by the caller) – the core of
+ * {@link aggregateColumns} and of {@link AreaModelAggregateFooter}.
+ */
+export declare function aggregateStates<T>(rows: ArrayLike<T>, specs: ResolvedAggregateSpec<T>[]): unknown[];
+/**
+ * Like {@link aggregateStates} for models without row objects: the getters get the row index 0 … rowCount-1.
+ */
+export declare function aggregateIndexStates(rowCount: number, specs: Pick<ResolvedAggregateSpec<number>, 'aggregator' | 'getValue'>[]): unknown[];

package/lib/table/aggregation/aggregate-spec.if.d.ts

@@ -0,0 +1,51 @@
+import { AggregatorRef } from './aggregator-name.type.js';
+import { ValueAccessor } from './value-accessor.type.js';
+
+/**
+ * One aggregate in full form: which aggregator, which value, and (in a footer) how it is shown.
+ *
+ * @example
+ * const spec: AggregateSpecIf<Order> = {
+ *   aggregator: "avg",
+ *   value: "total",                                    // default: the key of the spec
+ *   format: v => `${(v as number).toFixed(2)} €`         // footer text; Excel gets the number
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregateSpecIf<T = any> {
+    /** A built-in aggregator by name or an own one. */
+    aggregator: AggregatorRef;
+    /** The value of a row. Default: the key of the spec as property path. */
+    value?: ValueAccessor<T>;
+    /** The text in a footer cell. Default: numbers with at most two decimals (`"1,234.5"`), dates as date, `undefined` empty. */
+    format?: (result: unknown) => string;
+}
+/**
+ * An aggregate in short form (`"sum"`, an own aggregator) or in full form ({@link AggregateSpecIf}).
+ *
+ * @example
+ * const short: AggregateSpec<Order> = "sum";
+ * const full: AggregateSpec<Order> = { aggregator: "sum", value: o => o.quantity * o.price };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregateSpec<T = any> = AggregatorRef | AggregateSpecIf<T>;
+/**
+ * Several aggregates by key. In {@link aggregateColumns} the key names the result (and is the default property path);
+ * in a footer ({@link AreaModelAggregateFooter}) the key is the property of the column that shows the result.
+ *
+ * @example
+ * const specs: AggregateSpecMap<Order> = {
+ *   quantity: "sum",
+ *   total: "sum",
+ *   customer: "countDistinct",
+ *   avgTotal: { aggregator: "avg", value: "total" }   // a key without a column: only in the results
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregateSpecMap<T = any> = Record<string, AggregateSpec<T>>;

package/lib/table/aggregation/aggregate.d.ts

@@ -0,0 +1,58 @@
+import { AggregatorRef } from './aggregator-name.type.js';
+import { ValueAccessor } from './value-accessor.type.js';
+import { AggregateSpecMap } from './aggregate-spec.if.js';
+
+/**
+ * Aggregates one value of all rows.
+ *
+ * @param {ArrayLike<T>} rows - the rows (an array, also filtered or sorted ones)
+ * @param {ValueAccessor<T>} value - property path (`"total"`, `"address.zip"`) or function
+ * @param {AggregatorRef} aggregator - `"sum"`, `"count"`, `"avg"`, `"min"`, `"max"`, `"countDistinct"`, `"first"`,
+ *        `"last"` or an own {@link AggregatorIf}
+ * @returns {unknown} the result (`sum` of no numbers is `0`, `avg`/`min`/`max` of no numbers `undefined`)
+ *
+ * @example
+ * aggregate(orders, "total", "sum");                      // all orders
+ * aggregate(orders.filter(o => o.city === "Berlin"), "total", "avg");
+ * aggregate(orders, o => o.quantity * o.price, "max");    // a computed value
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function aggregate<T = any>(rows: ArrayLike<T>, value: ValueAccessor<T>, aggregator: AggregatorRef): unknown;
+/**
+ * Aggregates several values in **one** pass over the rows. The keys of `specs` name the results; a key is also the
+ * default property path.
+ *
+ * @param {ArrayLike<T>} rows - the rows
+ * @param {AggregateSpecMap<T>} specs - key → aggregator name, own aggregator or {@link AggregateSpecIf}
+ * @returns {Record<string, unknown>} key → result, in the order of `specs`
+ *
+ * @example
+ * const totals = aggregateColumns(orders, {
+ *   quantity: "sum",
+ *   total: "sum",
+ *   customer: "countDistinct",
+ *   avgTotal: { aggregator: "avg", value: "total" }
+ * });
+ * // { quantity: 549812, total: 27481033.5, customer: 412, avgTotal: 274.81 }
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function aggregateColumns<T = any>(rows: ArrayLike<T>, specs: AggregateSpecMap<T>): Record<string, unknown>;
+/**
+ * The default text of an aggregate (e.g. in a footer cell or a status bar): numbers with at most two decimals and
+ * thousands separators, dates as date (en-US), `null`/`undefined` empty, everything else as text.
+ *
+ * @param {unknown} value - an aggregation result
+ * @returns {string} the text
+ *
+ * @example
+ * formatAggregateValue(1234.5678);   // "1,234.57"
+ * formatAggregateValue(undefined);   // ""
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function formatAggregateValue(value: unknown): string;

package/lib/table/aggregation/aggregator-name.type.d.ts

@@ -0,0 +1,39 @@
+import { AggregatorIf } from './aggregator.if.js';
+
+/**
+ * The names of the built-in aggregators ({@link Aggregators}).
+ *
+ * | name | result | uses |
+ * |---|---|---|
+ * | `sum` | sum, `0` for no numbers | numbers (`NaN` ignored) |
+ * | `count` | number of rows | every row – the value does not matter |
+ * | `avg` | sum / count of the numbers, `undefined` for none | numbers |
+ * | `min`, `max` | smallest / largest value, `undefined` for none | numbers and valid `Date`s |
+ * | `countDistinct` | number of different values | everything except `null`/`undefined`; dates by time |
+ * | `first`, `last` | value of the first / last row | every row, the value as it is |
+ *
+ * Text is never converted to a number (like Excel's SUM over a range): `"12"` does not count. Use an accessor such as
+ * `row => Number(row.amount)` for numbers stored as text.
+ *
+ * @example
+ * const name: AggregatorName = "avg";
+ * aggregate(orders, "total", name);
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregatorName = "sum" | "count" | "avg" | "min" | "max" | "countDistinct" | "first" | "last";
+/**
+ * A built-in aggregator by name or an own {@link AggregatorIf}.
+ *
+ * @example
+ * const byName: AggregatorRef = "sum";
+ * const own: AggregatorRef = { name: "range", init: () => [Infinity, -Infinity],
+ *   add: ([lo, hi]: number[], v: unknown) => typeof v === "number" ? [Math.min(lo, v), Math.max(hi, v)] : [lo, hi],
+ *   merge: (a: number[], b: number[]) => [Math.min(a[0], b[0]), Math.max(a[1], b[1])],
+ *   result: ([lo, hi]: number[]) => hi - lo };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregatorRef = AggregatorName | AggregatorIf;

package/lib/table/aggregation/aggregator.if.d.ts

@@ -0,0 +1,51 @@
+/**
+ * An aggregation (sum, average, …) as four small functions over a **state**: `init` → `add` per value → `result`.
+ * `merge` combines two partial states – the result is the same as one pass over all values. That makes groups
+ * (row grouping, pivot) cheap: the state of a group is the merge of the states of its sub-groups, and an average of
+ * averages stays correct (`{ sum, count }` instead of a number).
+ *
+ * The built-in aggregators are in {@link Aggregators}; an own aggregator implements this interface and can be used
+ * everywhere a name like `"sum"` is accepted ({@link AggregatorRef}).
+ *
+ * `add(state, …)` and `merge(a, b)` may change `state` / `a` and return it (no allocation per row with millions of
+ * rows); `merge` never changes `b`, so a child state can be merged into several parents. Call `init()` for a fresh
+ * state, e.g. `merge(init(), child)` for a parent that must not change the child.
+ *
+ * @example
+ * // the product of all numbers
+ * const product: AggregatorIf<number, number> = {
+ *   name: "product",
+ *   init: () => 1,
+ *   add: (state, value) => typeof value === "number" ? state * value : state,
+ *   merge: (a, b) => a * b,
+ *   result: state => state
+ * };
+ * aggregate([{ f: 2 }, { f: 3 }, { f: 7 }], "f", product); // 42
+ *
+ * @example
+ * // partial results: the average of two groups is the average of all rows
+ * const avg = Aggregators.avg;
+ * const north = [100, 50, 120].reduce((s, v) => avg.add(s, v), avg.init());
+ * const south = [80, 70, 30].reduce((s, v) => avg.add(s, v), avg.init());
+ * avg.result(avg.merge(north, south)); // 75 – not the mean of 90 and 60
+ *
+ * @typeParam S - the state
+ * @typeParam R - the result
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregatorIf<S = any, R = unknown> {
+    /** The name, e.g. `"sum"` – the built-in ones use their {@link AggregatorName}. */
+    readonly name: string;
+    /** The state of the empty set. */
+    init(): S;
+    /** Takes one value into the state (values the aggregator can't use are ignored); returns the state. */
+    add(state: S, value: unknown): S;
+    /**
+     * Combines two partial states (`a` first, then `b` – matters for `first`/`last`); may change `a` and returns the
+     * combined state; never changes `b`.
+     */
+    merge(a: S, b: S): S;
+    /** The result of a state, e.g. `sum / count` for the average. */
+    result(state: S): R;
+}

package/lib/table/aggregation/aggregators.d.ts

@@ -0,0 +1,37 @@
+import { AggregatorIf } from './aggregator.if.js';
+import { AggregatorName, AggregatorRef } from './aggregator-name.type.js';
+
+/**
+ * The built-in aggregators by name ({@link AggregatorName}) – each one is an {@link AggregatorIf}, so `merge` combines
+ * partial results correctly (the average of groups is the average of all rows).
+ *
+ * - `sum` and `avg` sum with compensation (Neumaier): `0.1 + 0.2 + 0.3` is `0.6`, and splitting the data into groups
+ *   does not change the result.
+ * - Numeric aggregators use numbers only (`NaN`, text, `null` … are ignored); `min`/`max` also valid `Date`s;
+ *   `count` counts rows; `countDistinct` ignores `null`/`undefined`; `first`/`last` take the value as it is.
+ *
+ * @example
+ * const { sum } = Aggregators;
+ * let state = sum.init();
+ * for (const order of orders) state = sum.add(state, order.total);
+ * sum.result(state);                         // the same as aggregate(orders, "total", "sum")
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare const Aggregators: Readonly<Record<AggregatorName, AggregatorIf>>;
+/**
+ * The aggregator for a name, or the given aggregator itself.
+ *
+ * @param {AggregatorRef} aggregator - a name like `"sum"` or an own {@link AggregatorIf}
+ * @returns {AggregatorIf} the aggregator
+ * @throws {Error} for an unknown name (the message lists the built-in names)
+ *
+ * @example
+ * getAggregator("avg").name;            // "avg"
+ * getAggregator(Aggregators.max);       // the same object
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function getAggregator(aggregator: AggregatorRef): AggregatorIf;

package/lib/table/aggregation/create-value-getter.d.ts

@@ -0,0 +1,18 @@
+import { ValueAccessor } from './value-accessor.type.js';
+
+/**
+ * A function that reads a value from a row: a property path (`"address.city"`, missing parents → `undefined`) or the
+ * given function itself.
+ *
+ * @param {ValueAccessor<T>} value - property path or function
+ * @returns {(row: T) => unknown} the getter
+ *
+ * @example
+ * const city = createValueGetter<{ address?: { city: string } }>("address.city");
+ * city({ address: { city: "Kiel" } }); // "Kiel"
+ * city({});                            // undefined
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function createValueGetter<T = any>(value: ValueAccessor<T>): (row: T) => unknown;

package/lib/table/aggregation/selection-aggregates.if.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Count, sum, average, minimum and maximum of the selected body cells – for a status bar like in a spreadsheet
+ * ({@link TableApi.getSelectionAggregates}).
+ *
+ * Counted are the selected cells of the visible data columns (row number and checkbox columns not); `numericCount`,
+ * `sum`, `avg`, `min`, `max` use the cells whose value is a number.
+ *
+ * @example
+ * const a: SelectionAggregatesIf = tableApi.getSelectionAggregates();
+ * const text = a.capped ? "selection too large"
+ *   : a.numericCount ? `Count ${a.count} · Sum ${formatAggregateValue(a.sum)} · Avg ${formatAggregateValue(a.avg)}`
+ *   : a.count ? `Count ${a.count}` : "";
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface SelectionAggregatesIf {
+    /** Number of selected cells. */
+    count: number;
+    /** Number of selected cells with a number. */
+    numericCount: number;
+    /** Sum of the numbers (`0` without numbers). */
+    sum: number;
+    /** Average of the numbers (`undefined` without numbers). */
+    avg: number | undefined;
+    /** Smallest number (`undefined` without numbers). */
+    min: number | undefined;
+    /** Largest number (`undefined` without numbers). */
+    max: number | undefined;
+    /**
+     * `true` if the selection covers more than {@link SelectionAggregator.maxCells} cells: then nothing is computed
+     * (all values 0 / `undefined`) – a partial sum would be wrong.
+     */
+    capped: boolean;
+}

package/lib/table/aggregation/value-accessor.type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Where an aggregation gets its value from a row: a property path (`"total"`, `"address.city"`) or a function
+ * (computed values, numbers stored as text, …).
+ *
+ * @example
+ * const byPath: ValueAccessor<Order> = "total";
+ * const computed: ValueAccessor<Order> = order => order.quantity * order.price;
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type ValueAccessor<T = any> = string | ((row: T) => unknown);

package/lib/table/data/common/row-number-column-def.d.ts

@@ -0,0 +1,107 @@
+import { SizeIf } from './size.if.js';
+import { ColumnDefIf } from '../tablemodel/column/column-def.if.js';
+import { CellRendererIf } from '../../renderer/cell-render.if.js';
+import { AreaObjectMapType } from './area-map.type.js';
+import { AreaModelIf } from '../tablemodel/areamodel/area-model.if.js';
+import { BooleanFunction } from './boolean-function.js';
+import { RowNumberOptionsIf } from './row-number-options.if.js';
+
+/**
+ * A built-in column with running row numbers (1, 2, 3 …) like the row headers of a spreadsheet.
+ *
+ * The easy way is the factory flag: `TableFactory.createTableModel({ rows, rowNumbersVisible: true })` puts this column
+ * in front of the others and fixes it on the left. Put it into `columnDefs` yourself if you build the models yourself
+ * – as the **first** column, counted in `fixedLeftColumnCount`.
+ *
+ * What the table does with it:
+ * - the width follows the largest number (`"9"` → `"2000000"`) – after `setRows`, filtering, expanding tree rows;
+ * - not sortable, not editable, no resize handle, can't be dragged, no column can be dragged in front of it;
+ * - body cells have `role="rowheader"` – screen readers announce the number with the row;
+ * - a click on a number selects the row (selection type `"row"` and `"range"`), Shift extends, Ctrl/⌘ toggles;
+ *   a click on the header cell selects all;
+ * - copy ({@link TableApi.copyToClipboard}) and Excel export ({@link TableApi.downloadExcel}) leave it out, unless
+ *   `exported: true`;
+ * - with a {@link CheckboxColumnDef} directly behind it, the checkbox, the tree arrow and
+ *   `showCheckboxWihoutExtraColumn` move one column to the right.
+ *
+ * Note: it is a real column – the indices of all other columns are one higher (like with a `CheckboxColumnDef`).
+ * Use properties where you can (`tableApi.setColumnVisible("total", false)`, {@link TableApi.getColumnIndex}).
+ *
+ * @example
+ * const withNumbers: ColumnDefIf[] = [new RowNumberColumnDef(), new CheckboxColumnDef(), ...columnDefs];
+ * const model = TableFactory.createTableModel({ rows: orders, columnDefs: withNumbers, fixedLeftColumnCount: 2 });
+ *
+ * @see Training: [Fixed columns](https://gui.expert/training/fixed-columns/)
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare class RowNumberColumnDef implements ColumnDefIf {
+    /** Marker for {@link isRowNumberColumnDef} (works across copies of the core). */
+    readonly type = "RowNumberColumnDef";
+    property: string;
+    headerLabel: string;
+    /** Starts with `minWidthInPx`; the table widens it to fit the largest number. */
+    width: SizeIf;
+    minWidth: SizeIf;
+    maxWidth: SizeIf;
+    rendererMap: AreaObjectMapType<CellRendererIf>;
+    classes: AreaObjectMapType<string[]>;
+    isVisible: BooleanFunction;
+    /** The options (defaults from {@link RowNumberOptions}). */
+    readonly options: RowNumberOptionsIf;
+    /**
+     * "original": position of each row in getAllRows() – built when needed, for one array with one length. Checked on
+     * every lookup (`rows[position] === row`): rows sorted or replaced in place rebuild it.
+     */
+    private originalIndex?;
+    constructor(options?: Partial<RowNumberOptionsIf>);
+    /**
+     * The number of a body row (1-based): its position in the view (`"display"`) or in `getAllRows()` (`"original"`).
+     *
+     * @param {number} rowIndex - row index in the body (the current view)
+     * @param {AreaModelIf} bodyModel - the body model
+     * @returns {number} the row number
+     *
+     * @example
+     * const columnDef = new RowNumberColumnDef();
+     * const rowNumber = columnDef.getRowNumber(0, tableModel.getBodyModel()); // 1
+     */
+    getRowNumber(rowIndex: number, bodyModel: AreaModelIf): number;
+    /**
+     * The text of a row number: `options.format(getRowNumber(…))`.
+     *
+     * @param {number} rowIndex - row index in the body
+     * @param {AreaModelIf} bodyModel - the body model
+     * @returns {string} the text shown in the cell (and exported with `exported: true`)
+     *
+     * @example
+     * const columnDef = new RowNumberColumnDef({ format: n => n.toLocaleString("en-US") });
+     * const text = columnDef.getRowNumberText(1999, tableModel.getBodyModel()); // "2,000"
+     */
+    getRowNumberText(rowIndex: number, bodyModel: AreaModelIf): string;
+    /**
+     * The text of the largest number the column can show now – the table measures it for the column width.
+     * `"display"`: the row count; `"original"`: the count of all rows (unfiltered). At least the text of 1.
+     *
+     * @param {AreaModelIf} bodyModel - the body model
+     * @returns {string} e.g. `"2000000"`
+     *
+     * @example
+     * const widest = new RowNumberColumnDef().getWidestText(tableModel.getBodyModel()); // "1000" for 1000 rows
+     */
+    getWidestText(bodyModel: AreaModelIf): string;
+    /**
+     * True if the numbers are shown without an own `format` (plain digits) – the Excel export then writes numbers.
+     *
+     * @returns {boolean} false with an own `options.format`
+     *
+     * @example
+     * const plain = new RowNumberColumnDef().hasDefaultFormat(); // true
+     */
+    hasDefaultFormat(): boolean;
+    private hasAllRows;
+    /** Position of a row in getAllRows() (0-based), undefined if the model has no getAllRows() or the row is not in it. */
+    private getOriginalPosition;
+    private buildOriginalIndex;
+}

package/lib/table/data/common/row-number-columns.d.ts

@@ -0,0 +1,17 @@
+import { ColumnDefIf } from '../tablemodel/column/column-def.if.js';
+
+/**
+ * 1 if the first column is a {@link RowNumberColumnDef}, otherwise 0 – the offset of the built-in columns that are
+ * bound to "the first column": the {@link CheckboxColumnDef}, the tree arrow and the checkbox of
+ * `showCheckboxWihoutExtraColumn` sit at this index (behind the row numbers).
+ *
+ * @param {ColumnDefIf[] | undefined} columnDefs - the column definitions of the table model
+ * @returns {0 | 1} the number of leading row number columns
+ *
+ * @example
+ * const firstDataColumn = getLeadingRowNumberColumnCount(tableModel.getColumnDefs());
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare function getLeadingRowNumberColumnCount(columnDefs: ColumnDefIf[] | undefined): 0 | 1;

package/lib/table/data/common/row-number-options.d.ts

@@ -0,0 +1,19 @@
+import { RowNumberMode, RowNumberOptionsIf } from './row-number-options.if.js';
+
+/**
+ * The default options of the row number column: numbers of the current view, no thousands separators, header `"#"`,
+ * not exported, at least 36 px wide.
+ *
+ * @example
+ * const columnDef = new RowNumberColumnDef({ ...new RowNumberOptions(), headerLabel: "" });
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare class RowNumberOptions implements RowNumberOptionsIf {
+    mode: RowNumberMode;
+    format: (rowNumber: number) => string;
+    headerLabel: string;
+    exported: boolean;
+    minWidthInPx: number;
+}

package/lib/table/data/common/row-number-options.if.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How a {@link RowNumberColumnDef} counts:
+ * - `"display"` (default): the position in the current view – 1, 2, 3 … also after sorting and filtering
+ *   (like the row headers of a spreadsheet).
+ * - `"original"`: the position in the unsorted, unfiltered rows (`getAllRows()` of the body model) – the number stays
+ *   with its row. Body models without `getAllRows()` (tree, own area models) count like `"display"`.
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export type RowNumberMode = "display" | "original";
+/**
+ * Options of the row number column ({@link RowNumberColumnDef}). Pass any subset – to
+ * `new RowNumberColumnDef({ … })` or as `rowNumbersVisible: { … }` to {@link TableFactory.createTableModel}.
+ * Defaults: {@link RowNumberOptions}.
+ *
+ * @example
+ * const tableModel = TableFactory.createTableModel({
+ *   rows: orders,
+ *   rowNumbersVisible: { mode: "original", format: n => n.toLocaleString("en-US"), exported: true }
+ * });
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export interface RowNumberOptionsIf {
+    /** `"display"` (default) or `"original"`, see {@link RowNumberMode}. */
+    mode: RowNumberMode;
+    /**
+     * The text of a number. Default `String(n)` – no thousands separators (`"2000000"`).
+     * The column width is measured with the text of the largest number, so the text should not get shorter for
+     * larger numbers.
+     *
+     * @example
+     * const options: Partial<RowNumberOptionsIf> = { format: n => n.toLocaleString("de-DE") }; // "2.000.000"
+     */
+    format: (rowNumber: number) => string;
+    /** Text of the header cell. Default `"#"` (an empty header cell has no accessible name). */
+    headerLabel: string;
+    /** `true`: {@link TableApi.copyToClipboard} and {@link TableApi.downloadExcel} contain the numbers. Default `false`. */
+    exported: boolean;
+    /** The column is never narrower than this (px). Default 36. */
+    minWidthInPx: number;
+}

package/lib/table/data/tablemodel/areamodel/aggregate-footer-options.if.d.ts

@@ -0,0 +1,73 @@
+import { AggregateSpecMap } from '../../../aggregation/aggregate-spec.if.js';
+import { AreaModelIf } from './area-model.if.js';
+
+/**
+ * One total row of an {@link AreaModelAggregateFooter}: the aggregates by column property and an optional label.
+ *
+ * @example
+ * const sumRow: AggregateFooterRowIf<Order> = { label: "Sum", aggregates: { quantity: "sum", total: "sum" } };
+ * const avgRow: AggregateFooterRowIf<Order> = {
+ *   label: (rowCount, results) => `Ø of ${rowCount} orders`,
+ *   aggregates: { total: { aggregator: "avg", format: v => `${(v as number).toFixed(2)} €` } }
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregateFooterRowIf<T = any> {
+    /** Key = property of the column that shows the result (a key without a column is only in `getResults()`). */
+    aggregates: AggregateSpecMap<T>;
+    /**
+     * Text in the label column (always set as text, never as HTML). Default: `"6 rows"` – or, in a footer with
+     * several rows whose aggregates all use the same built-in aggregator, its word (`"Sum"`, `"Average"`, `"Min"` …).
+     */
+    label?: string | ((rowCount: number, results: Record<string, unknown>) => string);
+}
+/**
+ * The options of an {@link AreaModelAggregateFooter} (and of `TableFactory.createTableModel({ footerAggregates })`).
+ *
+ * @example
+ * const options: AggregateFooterOptionsIf<Order> = {
+ *   rows: [
+ *     { label: "Sum", aggregates: { quantity: "sum", total: "sum" } },
+ *     { label: "Average", aggregates: { quantity: "avg", total: "avg" } }
+ *   ],
+ *   labelProperty: "customer",   // the labels go into the customer column
+ *   rowHeight: 36
+ * };
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export interface AggregateFooterOptionsIf<T = any> {
+    /** One footer row per entry. */
+    rows: AggregateFooterRowIf<T>[];
+    /** The column of the labels (property). Default: the first data column without an aggregate in that row. */
+    labelProperty?: string;
+    /** Height of the footer rows in px. Default 34 (the factory uses `defaultRowHeights.footer`). */
+    rowHeight?: number;
+    /**
+     * Which rows are aggregated: `"filtered"` (default) – the rows the body shows (after `externalFilterFunction`;
+     * in a tree all leaves that pass the filter, expanded or not); `"all"` – all rows, the filter is ignored.
+     */
+    source?: "filtered" | "all";
+    /** An own source of rows (instead of the body model's rows), e.g. the data of a server response. */
+    getRows?: (bodyModel: AreaModelIf) => ArrayLike<T>;
+}
+/**
+ * The short and the full forms of a footer configuration:
+ * - `{ total: "sum" }` – one row ({@link AggregateSpecMap}),
+ * - `[{ label: "Sum", aggregates: … }, …]` – several rows ({@link AggregateFooterRowIf}),
+ * - `{ rows: […], labelProperty, rowHeight, source, getRows }` – everything ({@link AggregateFooterOptionsIf}).
+ *
+ * @example
+ * const oneRow: AggregateFooterConfig<Order> = { quantity: "sum", total: "sum" };
+ * const twoRows: AggregateFooterConfig<Order> = [
+ *   { label: "Sum", aggregates: { total: "sum" } },
+ *   { label: "Max", aggregates: { total: "max" } }
+ * ];
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export type AggregateFooterConfig<T = any> = AggregateSpecMap<T> | AggregateFooterRowIf<T>[] | AggregateFooterOptionsIf<T>;