@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/batch-edit/pending-cell-changes.d.ts

@@ -0,0 +1,104 @@
+/**
+ * One pending (not yet written) cell value of a batch edit – an entry of {@link PendingCellChanges}.
+ *
+ * @category Internals
+ * @since 1.1.96
+ */
+export interface PendingCellIf {
+    /** The key of the row: the row object (tree: the data of the `TreeRow`), or the row index for models without objects. */
+    rowKey: unknown;
+    /** The property of the column (`"#3"` for a column without property). */
+    property: string;
+    /** The value before the first change. */
+    oldValue: unknown;
+    /** The value shown (after the column's `editInputPipe`). */
+    newValue: unknown;
+    /** The value as entered (written with `setValue` on commit – the pipe runs there once). */
+    rawValue: unknown;
+    /** The message of {@link ColumnDefIf.validate}, if the value is invalid. */
+    error?: string;
+}
+/**
+ * What {@link PendingCellChanges.set} did: a new entry, a changed entry, an entry removed because the value is the
+ * old one again (B8), or nothing (the value equals the old one and there was no entry).
+ *
+ * @category Internals
+ * @since 1.1.96
+ */
+export type PendingChangeResult = "added" | "changed" | "removed" | "unchanged";
+/**
+ * True if two cell values are the same for a batch edit: `Object.is`, dates by time, a number and the text of the same
+ * number (an editor without `editInputPipe` returns texts), and `null` / `undefined` / `""` as "empty".
+ *
+ * @param {unknown} a - one value
+ * @param {unknown} b - another value
+ * @returns {boolean} whether the cell would not change
+ *
+ * @example
+ * isSameCellValue(5, "5");                                        // true
+ * isSameCellValue(new Date(2026, 0, 1), new Date(2026, 0, 1));    // true
+ * isSameCellValue(undefined, "");                                 // true
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export declare function isSameCellValue(a: unknown, b: unknown): boolean;
+/**
+ * The pending values of a batch edit: per row (the row **object**, not its index – sorting and filtering don't
+ * change the assignment) and property one entry with old and new value. DOM-free; the table keeps one in its
+ * batch edit service.
+ *
+ * @example
+ * const pending = new PendingCellChanges();
+ * const row = { price: 10 };
+ * pending.set(row, "price", 10, 12, "12");   // "added"
+ * pending.set(row, "price", 12, 10, "10");   // "removed" – the old value again
+ *
+ * @category Internals
+ * @since 1.1.96
+ */
+export declare class PendingCellChanges {
+    private readonly rows;
+    private count;
+    /**
+     * Sets the pending value of a cell. The old value of an existing entry stays (the value before the first change);
+     * a value equal to it removes the entry (B8).
+     *
+     * @param {unknown} rowKey - the row object (or the row index for models without objects)
+     * @param {string} property - the property of the column
+     * @param {unknown} oldValue - the current value in the model (used for a new entry)
+     * @param {unknown} newValue - the new value (after the pipe)
+     * @param {unknown} rawValue - the value as entered
+     * @param {string} [error] - validation message
+     * @returns {PendingChangeResult} what happened
+     */
+    set(rowKey: unknown, property: string, oldValue: unknown, newValue: unknown, rawValue: unknown, error?: string): PendingChangeResult;
+    /**
+     * The pending entry of a cell.
+     *
+     * @param {unknown} rowKey - the row object (or index)
+     * @param {string} property - the property of the column
+     * @returns {PendingCellIf | undefined} the entry, `undefined` if the cell is unchanged
+     */
+    get(rowKey: unknown, property: string): PendingCellIf | undefined;
+    /**
+     * Removes the entry of a cell.
+     *
+     * @param {unknown} rowKey - the row object (or index)
+     * @param {string} property - the property of the column
+     * @returns {boolean} true if there was an entry
+     */
+    remove(rowKey: unknown, property: string): boolean;
+    /** @returns {boolean} true if the row has pending values */
+    hasRow(rowKey: unknown): boolean;
+    /** @returns {number} the number of pending cells */
+    size(): number;
+    /** @returns {boolean} true if nothing is pending */
+    isEmpty(): boolean;
+    /** @returns {number} the number of pending cells with a validation message */
+    invalidCount(): number;
+    /** @returns {PendingCellIf[]} all entries, in the order they were first changed */
+    entries(): PendingCellIf[];
+    /** Forgets all entries. */
+    clear(): void;
+}

package/lib/table/calc/column-values.d.ts

@@ -0,0 +1,55 @@
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { ValueGetter } from './value-getter.type.js';
+import { ValueGetterContextIf } from './value-getter-context.if.js';
+import { AggregatorRef } from '../aggregation/aggregator-name.type.js';
+import { ShowValuesAsIf } from './show-values-as.type.js';
+
+/** What an area model provides to its {@link ColumnValues}. */
+export interface ColumnValuesOwner {
+    /** The column definitions (read lazily – they may be replaced, e.g. by a pivot). */
+    getColumnDefsForValues(): ColumnDefIf[];
+    /** The value of a property path (the model's own semantics – unchanged behaviour for normal columns). */
+    readPath(row: any, property: string): unknown;
+    /** The rows of column aggregates (filtered, data objects) and a cheap signal that changes with them. */
+    getAggregationSource(): {
+        signal: unknown;
+        length: number;
+        rows: () => ArrayLike<unknown>;
+    };
+}
+/**
+ * Resolves `valueGetter`s by property, detects cycles (`#CIRC!`), caches column aggregates.
+ * Without calculated columns `get()` is one empty-map lookup plus the model's own path read.
+ */
+export declare class ColumnValues {
+    private readonly owner;
+    private getters?;
+    private showValuesAs?;
+    private properties?;
+    private defsLength;
+    /** property → rows whose value is being computed (a getter may read the same column of another row) */
+    private readonly computing;
+    private readonly contexts;
+    private aggregates;
+    private aggSignal;
+    private aggLength;
+    constructor(owner: ColumnValuesOwner);
+    /** Drops the getter lookup and the cached aggregates (`invalidateDerivedValues`). */
+    invalidate(): void;
+    /** The getter of a calculated column. */
+    getter(property: string | undefined): ValueGetter | undefined;
+    hasGetters(): boolean;
+    isCalculated(property: string): boolean;
+    hasColumn(property: string): boolean;
+    /** The „Show values as“ options of a column. */
+    getShowValuesAs(property: string | undefined): ShowValuesAsIf | undefined;
+    hasShowValuesAs(): boolean;
+    /** The value of a column for a row: its getter (cycle-safe, exceptions → `#VALUE!`) or the path. */
+    get(row: any, property: string): unknown;
+    /** An aggregate of a column over the filtered rows – cached. */
+    aggregate(property: string, aggregator: AggregatorRef): unknown;
+    /** The context passed to a getter. */
+    context(property: string): ValueGetterContextIf;
+    private call;
+    private lookup;
+}

package/lib/table/calc/show-values-as-internals.d.ts

@@ -0,0 +1,4 @@
+import { ShowValuesAsConfig } from './show-values-as.type.js';
+
+/** The Excel number format of a shown value (percentages: `0.0%`), `undefined` for the default. */
+export declare function excelFormatOfShowValuesAs(config: ShowValuesAsConfig | undefined): string | undefined;

package/lib/table/calc/show-values-as.d.ts

@@ -0,0 +1,87 @@
+import { ShowValuesAs, ShowValuesAsConfig, ShowValuesAsIf } from './show-values-as.type.js';
+
+/**
+ * The full options of a „Show values as“ configuration – `undefined` for none or an unknown mode.
+ *
+ * @param {ShowValuesAsConfig | undefined} config - a mode or mode with options
+ * @returns {ShowValuesAsIf | undefined} the options
+ *
+ * @example
+ * resolveShowValuesAs("rank");   // { mode: "rank" }
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare function resolveShowValuesAs(config: ShowValuesAsConfig | undefined | null): ShowValuesAsIf | undefined;
+/**
+ * All modes of {@link ShowValuesAs}, e.g. for an own select box.
+ *
+ * @example
+ * select.append(...SHOW_VALUES_AS_MODES.map(mode => new Option(mode, mode)));
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare const SHOW_VALUES_AS_MODES: readonly ShowValuesAs[];
+/**
+ * True for the modes that show a share (a fraction, shown as percentage).
+ *
+ * @param {ShowValuesAs} mode - the mode
+ * @returns {boolean} whether the shown value is a fraction
+ *
+ * @example
+ * isPercentShowValuesAs("percentOfColumnTotal");   // true
+ * isPercentShowValuesAs("rank");                   // false
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare function isPercentShowValuesAs(mode: ShowValuesAs | undefined): boolean;
+/**
+ * The text of a shown value: percentages with one decimal (`"66.7%"`), ranks without decimals, differences and
+ * running totals like totals (`"1,234.5"`). Not a number → `""`.
+ *
+ * @param {unknown} value - the shown value (a fraction for percentages)
+ * @param {ShowValuesAsConfig} config - the configuration of the column
+ * @returns {string} the text
+ *
+ * @example
+ * formatShowValuesAs(0.667, "percentOfColumnTotal");                          // "66.7%"
+ * formatShowValuesAs(0.667, { mode: "percentOfColumnTotal", fractionDigits: 2 }); // "66.70%"
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare function formatShowValuesAs(value: unknown, config: ShowValuesAsConfig): string;
+/**
+ * The sum of the numbers of a list (Neumaier, like {@link Aggregators}.sum); other values are skipped.
+ *
+ * @param {ArrayLike<unknown>} values - the values
+ * @returns {number} the sum, 0 for none
+ *
+ * @example
+ * sumOfNumbers([1, "2", 3, undefined]);   // 4
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare function sumOfNumbers(values: ArrayLike<unknown>): number;
+/**
+ * „Show values as“ over a list of values in display order – DOM-free, for own area models. Percentages are
+ * fractions (`0.667`); the reference is the list itself (`percentOfRowTotal` is not applicable to a list: the values are
+ * returned unchanged). Values that are no numbers → `undefined`.
+ *
+ * @param {ArrayLike<unknown>} values - the raw values in display order
+ * @param {ShowValuesAs} mode - the mode
+ * @returns {(number | undefined)[]} the shown values
+ *
+ * @example
+ * calculateShowValuesAs([2598, 1047, 250], "percentOfColumnTotal");   // [0.667…, 0.268…, 0.064…]
+ * calculateShowValuesAs([10, 20, 20, 5], "rank");                      // [3, 1, 1, 4]
+ * calculateShowValuesAs([10, 20, 5], "runningTotal");                  // [10, 30, 35]
+ * calculateShowValuesAs([10, 20, 5], "differenceFromPrevious");        // [undefined, 10, -15]
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export declare function calculateShowValuesAs(values: ArrayLike<unknown>, mode: ShowValuesAs): (number | undefined)[];

package/lib/table/calc/show-values-as.type.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How a column shows its numbers – without changing the data („Show values as“):
+ *
+ * | Mode | Shows | Flat table | Tree / row groups | Pivot |
+ * |---|---|---|---|---|
+ * | `"percentOfColumnTotal"` | value / sum of the column | ✓ | sum of the (filtered) leaf rows | cell / column total |
+ * | `"percentOfGrandTotal"` | value / grand total | = column total | = column total | cell / grand total |
+ * | `"percentOfParentTotal"` | value / total of the parent | = column total | value / sum of its siblings (each group = 100 %) | cell / parent row |
+ * | `"percentOfRowTotal"` | value / row total | – | – | cell / row total |
+ * | `"differenceFromPrevious"` | value − value of the row above | ✓ (first row empty) | among siblings | – |
+ * | `"runningTotal"` | sum up to this row (display order) | ✓ | among siblings | – |
+ * | `"rank"` | 1 = largest value, ties share a rank (1, 2, 2, 4) | ✓ | among siblings | – |
+ *
+ * The reference are the **filtered** rows (like the total row). Not applicable (–): the raw value is shown.
+ * Values that are no numbers and a total of 0 give an empty cell.
+ *
+ * @example
+ * ColumnDef.create({ property: "share", headerLabel: "Share", valueGetter: o => o.total,
+ *                    showValuesAs: "percentOfColumnTotal" });
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ShowValuesAs = "percentOfColumnTotal" | "percentOfGrandTotal" | "percentOfParentTotal" | "percentOfRowTotal" | "differenceFromPrevious" | "runningTotal" | "rank";
+/**
+ * „Show values as“ with options: mode, decimals, own text.
+ *
+ * @example
+ * ColumnDef.create({
+ *   property: "total", headerLabel: "Share",
+ *   showValuesAs: { mode: "percentOfColumnTotal", fractionDigits: 2 }   // "66.70%"
+ * });
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export interface ShowValuesAsIf {
+    /** The mode. */
+    mode: ShowValuesAs;
+    /** Decimals of the text. Default: 1 for percentages, at most 2 otherwise, 0 for `rank`. */
+    fractionDigits?: number;
+    /** An own text of the shown value (a fraction for percentages, e.g. `0.667`). Text only – never HTML. */
+    format?: (value: number) => string;
+}
+/**
+ * The configuration of a column: a mode or a mode with options.
+ *
+ * @example
+ * const share: ShowValuesAsConfig = "percentOfColumnTotal";
+ * const precise: ShowValuesAsConfig = { mode: "percentOfColumnTotal", fractionDigits: 2 };
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ShowValuesAsConfig = ShowValuesAs | ShowValuesAsIf;

package/lib/table/calc/value-getter-context.if.d.ts

@@ -0,0 +1,35 @@
+import { AggregatorRef } from '../aggregation/aggregator-name.type.js';
+
+/**
+ * The second parameter of a {@link ValueGetter}: access to other columns of the same table – also calculated ones –
+ * and to column aggregates over the (filtered) rows. Formulas ({@link compileFormula}) use it for `[total]` and
+ * `SUM([total])`.
+ *
+ * @example
+ * ColumnDef.create({
+ *   property: "share", headerLabel: "Share",
+ *   valueGetter: (row: Item, ctx: ValueGetterContextIf) =>
+ *     Number(ctx.getValue(row, "total")) / Number(ctx.aggregate("total", "sum"))
+ * });
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export interface ValueGetterContextIf {
+    /** The property of the column that is computed. */
+    readonly property: string;
+    /**
+     * The value of another column of the row: its `valueGetter` (with protection against circular references –
+     * a cycle returns a `#CIRC!` {@link FormulaError}) or the property path.
+     */
+    getValue(row: any, property: string): unknown;
+    /** True if a column of the table shows this property. */
+    hasColumn(property: string): boolean;
+    /** True if that column is calculated (`valueGetter` or `formula`). */
+    isCalculated(property: string): boolean;
+    /**
+     * An aggregate of a column over the filtered rows of the body (cached until the data, filter or sorting changes),
+     * e.g. `aggregate("total", "sum")`. Values that are no numbers are skipped (see {@link Aggregators}).
+     */
+    aggregate(property: string, aggregator: AggregatorRef): unknown;
+}

package/lib/table/calc/value-getter.type.d.ts

@@ -0,0 +1,36 @@
+import { ValueGetterContextIf } from './value-getter-context.if.js';
+
+/**
+ * Computes the value of a calculated column from the row (`ColumnDefIf.valueGetter`). The row is the data object
+ * (in a tree the `TreeRow.data`). The data is not changed – sorting, filter (`tableApi.getRowValue`), copy, Excel and
+ * totals use the computed value.
+ *
+ * Keep it fast and free of side effects: it runs for every visible cell on each render (values are not cached) and
+ * once per row for sorting and totals.
+ *
+ * @example
+ * const total: ValueGetter<Item> = row => row.price * row.quantity;
+ * ColumnDef.create({ property: "total", headerLabel: "Total", valueGetter: total });
+ *
+ * @typeParam T - the row type
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ValueGetter<T = any> = (row: T, context: ValueGetterContextIf) => unknown;
+/**
+ * Writes an edited value of a calculated column back into the row (`ColumnDefIf.valueSetter`). Without a setter a
+ * calculated column cannot be edited. Return `false` to reject the value.
+ *
+ * @example
+ * // "total" is price × quantity – editing the total changes the price
+ * const setTotal: ValueSetter<Item> = (row, value) => {
+ *   const total = Number(value);
+ *   if (!Number.isFinite(total) || !row.quantity) return false;
+ *   row.price = total / row.quantity;
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type ValueSetter<T = any> = (row: T, value: unknown) => boolean | void;

package/lib/table/data/common/event/ge-batch-edit-event.d.ts

@@ -0,0 +1,46 @@
+import { CellChangeIf } from '../../../batch-edit/cell-change.if.js';
+
+/**
+ * What happened in a batch edit: `"start"` ({@link TableApi.startBatchEdit}), `"change"` (values were marked or a
+ * value was set back), `"commit"` (written), `"cancel"` (discarded).
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export type GeBatchEditEventType = "start" | "change" | "commit" | "cancel";
+/**
+ * Reported by {@link EventListenerIf.onBatchEditChanged}: the pending changes of a batch edit changed – e.g. to enable
+ * a "Save" button.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onBatchEditChanged = (evt: GeBatchEditEvent) => {
+ *   saveButton.disabled = evt.pendingCount === 0 || evt.invalidCount > 0;
+ *   discardButton.disabled = evt.pendingCount === 0;
+ * };
+ *
+ * @category Fill handle & batch edit
+ * @since 1.1.96
+ */
+export declare class GeBatchEditEvent {
+    /** What happened. */
+    readonly type: GeBatchEditEventType;
+    /** The cells of this step (`"commit"`: the written cells, `"cancel"`: the discarded ones). */
+    readonly changes: CellChangeIf[];
+    /** The number of pending cells after this step. */
+    readonly pendingCount: number;
+    /** The number of pending cells with an invalid value. */
+    readonly invalidCount: number;
+    private readonly pendingProvider;
+    constructor(
+    /** What happened. */
+    type: GeBatchEditEventType, 
+    /** The cells of this step (`"commit"`: the written cells, `"cancel"`: the discarded ones). */
+    changes: CellChangeIf[], 
+    /** The number of pending cells after this step. */
+    pendingCount: number, 
+    /** The number of pending cells with an invalid value. */
+    invalidCount: number, pendingProvider?: () => CellChangeIf[]);
+    /** All pending changes after this step (computed when read – it scans the shown rows once). */
+    get pendingChanges(): CellChangeIf[];
+}

package/lib/table/data/common/event/ge-model-change-event.d.ts

@@ -1,9 +1,13 @@
 import { GeCellIndices } from './ge-cell-indices.js';
+import { CellChangeIf, CellChangeSource } from '../../../batch-edit/cell-change.if.js';
 
 /**
  * Reported by {@link EventListenerIf.onModelChanged} after cells were edited: the row and column indices
  * of the changed cells. The new values are already written into the area model.
  *
+ * Since 1.1.96 the event comes **once per change** – an edit, a fill (fill handle, Ctrl/⌘+D), a commit of a batch
+ * edit or {@link TableApi.applyCellChanges} – with all cells, and {@link changes} tells old and new values.
+ *
  * @example
  * override onModelChanged(evt: GeModelChangeEvent): void {
  *   for (const { rowIndex } of evt.cells) {
@@ -19,6 +23,28 @@ import { GeCellIndices } from './ge-cell-indices.js';
  */
 export declare class GeModelChangeEvent {
     cells: GeCellIndices[];
-    constructor(cells: GeCellIndices[]);
+    /**
+     * The changed cells with row object, property, old and new value (since 1.1.96; `undefined` for events created by
+     * own code with the old constructor).
+     */
+    changes?: CellChangeIf<any>[] | undefined;
+    /** What changed the cells: `"edit"`, `"fill"`, `"commit"` or `"api"` (since 1.1.96). */
+    source?: CellChangeSource | undefined;
+    constructor(cells: GeCellIndices[], 
+    /**
+     * The changed cells with row object, property, old and new value (since 1.1.96; `undefined` for events created by
+     * own code with the old constructor).
+     */
+    changes?: CellChangeIf<any>[] | undefined, 
+    /** What changed the cells: `"edit"`, `"fill"`, `"commit"` or `"api"` (since 1.1.96). */
+    source?: CellChangeSource | undefined);
+    /**
+     * An event for a change set (since 1.1.96): `cells` from the row and column indices of the changes.
+     *
+     * @param {CellChangeIf[]} changes - the changed cells
+     * @param {CellChangeSource} source - what changed them
+     * @returns {GeModelChangeEvent} the event
+     */
+    static createForChanges(changes: CellChangeIf[], source: CellChangeSource): GeModelChangeEvent;
     static createSingle(rowIndex: number, columnIndex: number): GeModelChangeEvent;
 }

package/lib/table/data/common/event/ge-row-drag-event.d.ts

@@ -0,0 +1,89 @@
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+
+/**
+ * Phase of a row drag: `"start"` (the pointer moved past the threshold, or a move key), `"move"` (the drop target
+ * changed), `"end"` (dropped) or `"cancel"` (Escape, `pointercancel`, `tableApi.cancelRowDrag()`, destroy).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type GeRowDragEventType = "start" | "move" | "end" | "cancel";
+/**
+ * What started the drag: the pointer (mouse, touch, pen) on a drag handle, or the keyboard
+ * (`MOVE_ROW_UP` / `MOVE_ROW_DOWN`, Ctrl+Alt+↑/↓).
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export type GeRowDragSource = "pointer" | "keyboard";
+/**
+ * A row drag ({@link EventListenerIf.onRowDragStart}, {@link EventListenerIf.onRowDragMove},
+ * {@link EventListenerIf.onRowDragEnd}).
+ *
+ * Call {@link preventDefault} to veto: in `"start"` no drag happens, in `"move"` the target is invalid (no drop
+ * marker, no drop). In managed mode `"end"` comes after the move (`moved`, `toIndex` = the real position).
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onRowDragEnd = (evt: GeRowDragEvent<Order>) => {
+ *   if (evt.moved) {
+ *     const ids = evt.rows.map(order => order.id);
+ *     void fetch("/api/orders/move", { method: "POST", body: JSON.stringify({ ids, toIndex: evt.toIndex }) });
+ *   }
+ * };
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare class GeRowDragEvent<T = any> {
+    /** Phase of the drag. */
+    readonly type: GeRowDragEventType;
+    /** Pointer or keyboard. */
+    readonly source: GeRowDragSource;
+    /** The dragged row objects (tree: the `TreeRow`s) in display order. */
+    readonly rows: T[];
+    /** Display indices of the dragged rows when the drag started (ascending). */
+    readonly rowIndices: number[];
+    /** The current drop target – `undefined` if there is none (invalid, vetoed, outside the table). */
+    readonly target: RowDropTargetIf | undefined;
+    /**
+     * Flat tables: display index of the first dragged row after the drop (`0` = first row), `-1` without target.
+     * Trees: `-1` before the move; in a managed `"end"` the index the row really got.
+     */
+    toIndex: number;
+    /** true if the pointer is outside the table – e.g. over an own drop zone of the page. */
+    readonly outside: boolean;
+    /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
+    readonly managed: boolean;
+    /** The browser event behind this event (pointer or keyboard). */
+    readonly originalEvent?: PointerEvent | KeyboardEvent | undefined;
+    /** true if the moved rows changed in the table (managed mode, `"end"`, not prevented). */
+    moved: boolean;
+    private prevented;
+    constructor(
+    /** Phase of the drag. */
+    type: GeRowDragEventType, 
+    /** Pointer or keyboard. */
+    source: GeRowDragSource, 
+    /** The dragged row objects (tree: the `TreeRow`s) in display order. */
+    rows: T[], 
+    /** Display indices of the dragged rows when the drag started (ascending). */
+    rowIndices: number[], 
+    /** The current drop target – `undefined` if there is none (invalid, vetoed, outside the table). */
+    target: RowDropTargetIf | undefined, 
+    /**
+     * Flat tables: display index of the first dragged row after the drop (`0` = first row), `-1` without target.
+     * Trees: `-1` before the move; in a managed `"end"` the index the row really got.
+     */
+    toIndex: number, 
+    /** true if the pointer is outside the table – e.g. over an own drop zone of the page. */
+    outside: boolean, 
+    /** true if the table moves the rows itself ({@link RowDragOptionsIf.managed}). */
+    managed: boolean, 
+    /** The browser event behind this event (pointer or keyboard). */
+    originalEvent?: PointerEvent | KeyboardEvent | undefined);
+    /** true after {@link preventDefault}. */
+    get defaultPrevented(): boolean;
+    /** Veto: no drag (`"start"`), invalid target (`"move"`); no effect in `"end"` and `"cancel"`. */
+    preventDefault(): void;
+}

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