@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/action/action-id.type.d.ts

@@ -5,7 +5,7 @@
  *
  * @category Keyboard
  */
-export declare const actionIds: readonly ["COPY_2_CLIPBOARD", "START_EDITING", "TOGGLE_SELECTION", "SELECT_ALL", "DESELECT_ALL", "NAVIGATE_LEFT", "NAVIGATE_RIGHT", "NAVIGATE_UP", "NAVIGATE_DOWN", "NAVIGATE_ROW_START", "NAVIGATE_ROW_END", "NAVIGATE_FIRST_CELL", "NAVIGATE_LAST_CELL", "NAVIGATE_PAGE_UP", "NAVIGATE_PAGE_DOWN", "ACTIVATE_CELL"];
+export declare const actionIds: readonly ["COPY_2_CLIPBOARD", "START_EDITING", "TOGGLE_SELECTION", "SELECT_ALL", "DESELECT_ALL", "NAVIGATE_LEFT", "NAVIGATE_RIGHT", "NAVIGATE_UP", "NAVIGATE_DOWN", "NAVIGATE_ROW_START", "NAVIGATE_ROW_END", "NAVIGATE_FIRST_CELL", "NAVIGATE_LAST_CELL", "NAVIGATE_PAGE_UP", "NAVIGATE_PAGE_DOWN", "ACTIVATE_CELL", "MOVE_ROW_UP", "MOVE_ROW_DOWN", "FILL_DOWN", "FILL_RIGHT"];
 /**
  * Represents an action ID.
  *

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/aria/aria-texts.d.ts

@@ -31,4 +31,15 @@ export declare class AriaTexts implements AriaTextsIf {
     selectAllRows(): string;
     expandGroup(groupLabel: string): string;
     collapseGroup(groupLabel: string): string;
+    rowDragStarted(rowCount: number): string;
+    rowMoved(position: number, rowCount: number): string;
+    rowMoveNotPossible(): string;
+    rowDragCancelled(): string;
+    cellsFilled(cellCount: number): string;
+    fillTooLarge(maxCells: number): string;
+    pendingChanges(pendingCount: number): string;
+    changesCommitted(cellCount: number): string;
+    changesDiscarded(): string;
+    commitBlocked(invalidCount: number): string;
+    invalidValue(message: string): string;
 }

package/lib/table/aria/aria-texts.if.d.ts

@@ -85,4 +85,91 @@ export interface AriaTextsIf {
      * @returns {string} default: `"Collapse group Q1"`
      */
     collapseGroup(groupLabel: string): string;
+    /**
+     * Announced when a row drag starts (optional – {@link AriaTexts} has a default).
+     *
+     * @param {number} rowCount - number of dragged rows
+     * @returns {string} default: `"Dragging 1 row. Press Escape to cancel."`
+     * @since 1.1.95
+     */
+    rowDragStarted?(rowCount: number): string;
+    /**
+     * Announced after rows were moved by drag and drop or Ctrl+Alt+↑/↓ (optional – {@link AriaTexts} has a default).
+     *
+     * @param {number} position - 1-based position of the first moved row
+     * @param {number} rowCount - number of displayed rows
+     * @returns {string} default: `"Row moved to position 7 of 20"`
+     * @since 1.1.95
+     */
+    rowMoved?(position: number, rowCount: number): string;
+    /**
+     * Announced when rows cannot be moved: the table is sorted or filtered (managed row drag), or the row cannot move
+     * further (optional – {@link AriaTexts} has a default).
+     *
+     * @returns {string} default: `"Rows cannot be moved while the table is sorted or filtered"`
+     * @since 1.1.95
+     */
+    rowMoveNotPossible?(): string;
+    /**
+     * Announced when a row drag was cancelled (Escape) – optional, {@link AriaTexts} has a default.
+     *
+     * @returns {string} default: `"Drag cancelled"`
+     * @since 1.1.95
+     */
+    rowDragCancelled?(): string;
+    /**
+     * Announced after a fill (fill handle, Ctrl/⌘+D, Ctrl/⌘+R) – optional, {@link AriaTexts} has a default.
+     *
+     * @param {number} cellCount - the number of filled cells
+     * @returns {string} default: `"3 cells filled"`
+     * @since 1.1.96
+     */
+    cellsFilled?(cellCount: number): string;
+    /**
+     * Announced when a fill is refused because it covers too many cells ({@link FillHandleOptionsIf.maxCells}).
+     *
+     * @param {number} maxCells - the limit
+     * @returns {string} default: `"Too many cells to fill (at most 100000)"`
+     * @since 1.1.96
+     */
+    fillTooLarge?(maxCells: number): string;
+    /**
+     * Announced after a value was marked in a batch edit (or set back).
+     *
+     * @param {number} pendingCount - the number of pending cells
+     * @returns {string} default: `"3 changes not saved"`, `"No unsaved changes"`
+     * @since 1.1.96
+     */
+    pendingChanges?(pendingCount: number): string;
+    /**
+     * Announced after {@link TableApi.commitBatchEdit}.
+     *
+     * @param {number} cellCount - the number of written cells
+     * @returns {string} default: `"3 changes saved"`
+     * @since 1.1.96
+     */
+    changesCommitted?(cellCount: number): string;
+    /**
+     * Announced after {@link TableApi.cancelBatchEdit}.
+     *
+     * @returns {string} default: `"Changes discarded"`
+     * @since 1.1.96
+     */
+    changesDiscarded?(): string;
+    /**
+     * Announced when invalid values block {@link TableApi.commitBatchEdit}.
+     *
+     * @param {number} invalidCount - the number of invalid cells
+     * @returns {string} default: `"2 invalid values – nothing saved"`
+     * @since 1.1.96
+     */
+    commitBlocked?(invalidCount: number): string;
+    /**
+     * Announced when an edited value is invalid ({@link ColumnDefIf.validate}) and not written (without batch edit).
+     *
+     * @param {string} message - the message of the validator
+     * @returns {string} default: `"Invalid value: <message>"`
+     * @since 1.1.96
+     */
+    invalidValue?(message: string): string;
 }

package/lib/table/batch-edit/batch-edit-options.d.ts

@@ -0,0 +1,21 @@
+import { BatchEditOptionsIf } from './batch-edit-options.if.js';
+
+/**
+ * The defaults of {@link BatchEditOptionsIf}.
+ *
+ * @example
+ * BatchEditOptions.create(true).blockCommitOnInvalid;   // true
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export declare class BatchEditOptions implements BatchEditOptionsIf {
+    blockCommitOnInvalid: boolean;
+    /**
+     * The options of {@link TableOptionsIf.batchEdit} (`true`, `false` or an object) with defaults.
+     *
+     * @param {boolean | Partial<BatchEditOptionsIf>} [option] - `tableOptions.batchEdit`
+     * @returns {BatchEditOptionsIf} complete options
+     */
+    static create(option?: boolean | Partial<BatchEditOptionsIf>): BatchEditOptionsIf;
+}

package/lib/table/batch-edit/batch-edit-options.if.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Options of the batch edit ({@link TableOptionsIf.batchEdit}): changes are collected (marked, not written) and
+ * written with {@link TableApi.commitBatchEdit} or discarded with {@link TableApi.cancelBatchEdit}.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   batchEdit: { blockCommitOnInvalid: false },   // always collect; invalid values don't block saving
+ * };
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export interface BatchEditOptionsIf {
+    /**
+     * `true` (default): {@link TableApi.commitBatchEdit} writes nothing while a pending value is invalid
+     * ({@link ColumnDefIf.validate}) and returns `false`.
+     */
+    blockCommitOnInvalid: boolean;
+}

package/lib/table/batch-edit/batch-edit-service.d.ts

@@ -0,0 +1,104 @@
+import { TableScope } from '../table-scope.js';
+import { CellChangeIf } from './cell-change.if.js';
+import { BatchEditOptionsIf } from './batch-edit-options.if.js';
+import { PendingCellIf } from './pending-cell-changes.js';
+
+/** A value to mark as pending – prepared by {@link TableScope.applyCellChanges}. */
+export interface PendingInputIf {
+    rowIndex: number;
+    columnIndex: number;
+    /** after the editInputPipe */
+    value: unknown;
+    /** as entered */
+    rawValue: unknown;
+    error?: string;
+}
+/**
+ * Batch edit of one table (`tableScope.batchEditService`): collects changes instead of writing them, shows them
+ * (`ge-table-cell-pending`) and writes them on commit. Use {@link TableApi.startBatchEdit},
+ * {@link TableApi.commitBatchEdit}, {@link TableApi.cancelBatchEdit} and {@link TableApi.getPendingChanges}.
+ *
+ * The pending values belong to the row **objects** – sorting and filtering keep them on their rows. They are shown, but
+ * sorting, filtering, totals, copy and the Excel export use the written data (like ag-Grid).
+ *
+ * @category Internals
+ * @since 1.1.96
+ */
+export declare class BatchEditService {
+    private readonly tableScope;
+    private readonly pending;
+    private started;
+    constructor(tableScope: TableScope);
+    /** The options of this table ({@link TableOptionsIf.batchEdit} + defaults). */
+    get options(): BatchEditOptionsIf;
+    /** `tableOptions.batchEdit` is set: changes are always collected. */
+    isPermanent(): boolean;
+    /** True while changes are collected (started, or {@link isPermanent}). */
+    isActive(): boolean;
+    /** True if values are pending. */
+    hasPending(): boolean;
+    /**
+     * Starts collecting changes (until commit or cancel).
+     *
+     * @returns {boolean} false if a batch edit is already running
+     */
+    start(): boolean;
+    /** The key of a shown row: its object (tree: the data), the index for models without objects. */
+    rowKeyOf(rowIndex: number): unknown;
+    /** The key of a column: its property, `#<index>` without one. */
+    propertyOf(columnIndex: number): string;
+    /**
+     * The pending value of a shown body cell – asked for every rendered cell (one map lookup, nothing while empty).
+     *
+     * @param {number} rowIndex - display index
+     * @param {number} columnIndex - model index
+     * @returns {PendingCellIf | undefined} the entry
+     */
+    getPendingAt(rowIndex: number, columnIndex: number): PendingCellIf | undefined;
+    /**
+     * The value a body cell shows: the pending value, otherwise the model value.
+     *
+     * @param {number} rowIndex - display index
+     * @param {number} columnIndex - model index
+     * @returns {unknown} the shown value
+     */
+    getShownValue(rowIndex: number, columnIndex: number): unknown;
+    /**
+     * Marks values as pending (B1, B6, B8) and reports the step (`onBatchEditChanged`, announcement). The caller repaints.
+     *
+     * @param {PendingInputIf[]} inputs - cells with piped and raw value
+     * @returns {CellChangeIf[]} the cells whose pending state changed
+     */
+    addPending(inputs: PendingInputIf[]): CellChangeIf[];
+    /**
+     * All pending changes with the current display indices (one scan of the shown rows).
+     *
+     * @returns {CellChangeIf[]} the pending cells
+     */
+    getPendingChanges(): CellChangeIf[];
+    /**
+     * Writes the pending values (B3): shown rows through `setValue` (the pipe runs once, row groupings regroup), rows a
+     * filter hides directly into their objects. One `onModelChanged` with all cells, then `onBatchEditChanged` "commit".
+     *
+     * @returns {boolean} false if invalid values block the commit ({@link BatchEditOptionsIf.blockCommitOnInvalid})
+     */
+    commit(): boolean;
+    /** Discards the pending values (B4) and ends a started batch edit. */
+    cancel(): void;
+    /**
+     * Forgets pending values of rows that are no longer in the model (`setRows`, a reloaded tree): they would never be
+     * shown, block a commit with an invalid value and be written into stale objects. Only for models whose rows are known
+     * (object arrays, trees, row groupings); others keep their entries.
+     *
+     * @returns {number} the number of removed entries
+     */
+    pruneOrphans(): number;
+    /** All row keys of the body (also filtered and collapsed rows) – `undefined` if the model can't tell. */
+    private collectRowKeys;
+    private toChange;
+    private findColumnIndex;
+    /** Row key → display index, for the rows with pending values only. */
+    private createRowIndexMap;
+    private fire;
+    private texts;
+}

package/lib/table/batch-edit/cell-change.if.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What started a change of cells: `"edit"` (cell editor), `"fill"` (fill handle, Ctrl/⌘+D, Ctrl/⌘+R),
+ * `"commit"` ({@link TableApi.commitBatchEdit}) or `"api"` ({@link TableApi.applyCellChanges}).
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export type CellChangeSource = "edit" | "fill" | "commit" | "api";
+/**
+ * One changed cell: row, column, old and new value – the unit of a change set ({@link GeModelChangeEvent.changes},
+ * {@link TableApi.getPendingChanges}). With old **and** new value it is enough for undo and redo.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onModelChanged = (evt: GeModelChangeEvent) => {
+ *   for (const change of evt.changes ?? []) {
+ *     console.log(change.property, change.oldValue, "→", change.newValue, change.row);
+ *   }
+ * };
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export interface CellChangeIf<T = any> {
+    /** The row object (tree: the data of the `TreeRow`); `undefined` for own area models without row objects. */
+    row: T;
+    /** Display index of the row when the change was reported, `-1` if a filter hides the row. */
+    rowIndex: number;
+    /** Model index of the column when the change was reported, `-1` if the column no longer exists. */
+    columnIndex: number;
+    /** The property of the column (`"#3"` for a column without property). */
+    property: string;
+    /** The value before the change (batch edit: before the first change of the cell). */
+    oldValue: unknown;
+    /** The new value (after the column's `editInputPipe`). */
+    newValue: unknown;
+    /** Batch edit: the message of {@link ColumnDefIf.validate} if the new value is invalid. */
+    error?: string;
+}

package/lib/table/batch-edit/cell-value-change.if.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A value to write into a body cell – the input of {@link TableApi.applyCellChanges} (and of the fill handle).
+ *
+ * @example
+ * const change: CellValueChangeIf = { rowIndex: 3, column: "price", value: 9.9 };
+ * tableApi.applyCellChanges([change]);
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export interface CellValueChangeIf {
+    /** Display index of the row in the body. */
+    rowIndex: number;
+    /** Model index of the column, or its property. */
+    column: number | string;
+    /** The new value – like typed into the editor: it runs through the column's `editInputPipe`. */
+    value: unknown;
+}