@guiexpert/table 1.1.106 → 1.1.108

package/lib/table/data/common/scroll-position.if.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A scroll position – the argument of {@link TableApi.repaintHard} (since 1.1.107): the rows are counted again and the
+ * table shows this position in the same render pass. A missing axis keeps its position.
+ *
+ * - `px`: the horizontal scroll position from the start (0 = the first center column at the start; right-to-left
+ *   measured from the right edge, see {@link TableOptionsIf.direction}) – the same as the first argument of
+ *   {@link TableApi.scrollToPixel} (scroll bar pixels, not a column offset: for a column use `scrollToIndex`).
+ * - `py`: a **content** position from the top of the first body row (with the heights of open detail rows above) – the same as the second
+ *   argument of {@link TableApi.scrollToPixel}, also exact with a capped scroll height (more than
+ *   {@link EleScope.maxScrollHeightInPx} px of rows).
+ *
+ * @example
+ * // live tail: rows were appended – count them and show row 500,000 (20 px rows) at the top
+ * tableApi.repaintHard({ py: 500_000 * 20 });
+ *
+ * @example
+ * // only horizontally: back to the first column, the vertical position stays
+ * tableApi.repaintHard({ px: 0 });
+ *
+ * @category Table & API
+ * @since 1.1.107
+ */
+export interface ScrollPositionIf {
+    /** Horizontal scroll position in px from the start (like `scrollToPixel`). Missing: the horizontal position stays. */
+    px?: number;
+    /** Vertical content position in px from the top of the first body row. Missing: the vertical position stays. */
+    py?: number;
+}

package/lib/table/data/options/table-options.if.d.ts

@@ -118,15 +118,25 @@ export interface TableOptionsIf {
      */
     horizontalBorderVisible: boolean;
     /**
-     * The value of the css `overflowX` determines the behavior of horizontal overflow for the table body (scroll port).
+     * The css `overflow-x` of the scroll viewport (`.ge-table-scroll-viewport`): `"auto"` (default) shows the horizontal
+     * scroll bar only when the columns are wider than the table, `"scroll"` always.
      *
-     * @typedef {'auto' | 'scroll'} OverflowX
+     * To hide the scroll bars completely use CSS – there is no `"hidden"` (wheel, touch, keyboard and the API still
+     * scroll, the table lays out without the bars):
+     * ```css
+     * .my-table .ge-table-scroll-viewport { scrollbar-width: none; }
+     * ```
      */
     overflowX: "auto" | "scroll";
     /**
-     * The value of the css `overflowX` determines the behavior of vertical overflow for the table body (scroll port).
+     * The css `overflow-y` of the scroll viewport (`.ge-table-scroll-viewport`): `"auto"` (default) shows the vertical
+     * scroll bar only when the rows are higher than the body, `"scroll"` always.
      *
-     * @typedef {'auto' | 'scroll'} OverflowX
+     * To hide the scroll bars completely use CSS – there is no `"hidden"` (wheel, touch, keyboard and the API still
+     * scroll, the table lays out without the bars):
+     * ```css
+     * .my-table .ge-table-scroll-viewport { scrollbar-width: none; }
+     * ```
      */
     overflowY: "auto" | "scroll";
     /**

package/lib/table/data/tablemodel/areamodel/abstract-area-model.d.ts

@@ -19,6 +19,10 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     private columnValuesInstance?;
     private calcTextRenderer?;
     protected cellRenderers: (CellRendererIf | undefined)[];
+    /**
+     * @deprecated since 1.1.107 – filled by `init()` for `defaultRowHeight -1`, but no longer read:
+     * {@link getYPosByRowIndex} sums `getRowHeight()` (the cache missed rows added after `init()`).
+     */
     protected yPositions: number[];
     /** Cell formulas of the table (since 1.1.99, set by the table for a flat body). @internal */
     sheetCells?: SheetCellsIf;
@@ -41,6 +45,25 @@ export declare abstract class AbstractAreaModel<T> implements AreaModelIf, HasDe
     setRowChecked(rowIndex: number, checked: boolean): void;
     getMaxColspan(): number;
     getMaxRowspan(): number;
+    /**
+     * The top of a row in px from the first row of this area.
+     *
+     * With a constant row height (`getConstantRowHeight()` of the subclass – the built-in models return their
+     * `defaultRowHeight` as long as `getRowHeight()` is not overridden) it is `rowIndex × height` (O(1)); otherwise the
+     * sum of `getRowHeight()` of all rows above (O(n), always up to date). Before 1.1.107 it was
+     * `defaultRowHeight × rowIndex` also when a subclass overrode `getRowHeight()`, and for `defaultRowHeight -1` a cache
+     * from `init()` that missed rows added later. The table itself positions the body rows with its own row layout.
+     *
+     * @param {number} rowIndex - the index of the row
+     * @returns {number} px from the top of the first row
+     *
+     * @example
+     * // a subclass with taller even rows: the positions follow the overridden getRowHeight()
+     * class Striped extends AreaModelObjectArray<any> {
+     *   override getRowHeight(rowIndex: number): number { return rowIndex % 2 ? 20 : 40; }
+     * }
+     * const y = new Striped("body", rows, 34, columnDefs).getYPosByRowIndex(3); // 40 + 20 + 40 = 100
+     */
     getYPosByRowIndex(rowIndex: number): number;
     init(): void;
     abstract externalFilterChanged<T>(predictFn: FilterFunction<T>): void;

package/lib/table/data/tablemodel/areamodel/area-model-cell-groups.d.ts

@@ -47,7 +47,7 @@ export declare class AreaModelCellGroups implements AreaModelIf {
     getTooltipAt(_rowIndex: number, _columnIndex: number): any;
     getValueAt(rowIndex: number, columnIndex: number): any;
     getTextValueAt(rowIndex: number, columnIndex: number): string;
-    getYPosByRowIndex(_rowIndex: number): number;
+    getYPosByRowIndex(rowIndex: number): number;
     getRowHeight(_rowIndex: number): number;
     isEditable(_rowIndex: number, _columnIndex: number): boolean;
     isFilterable(): boolean;

package/lib/table/data/tablemodel/areamodel/area-model-object-array.d.ts

@@ -9,6 +9,7 @@ import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { DerivedValuesChangeIf } from './derived-values-change.if.js';
 import { ShowValuesAsIf } from '../../../calc/show-values-as.type.js';
 import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { AppendRowsContextIf, AppendRowsModelResultIf } from '../../../live-append/append-rows-options.if.js';
 
 /**
  * @class AreaModelObjectArray
@@ -175,6 +176,11 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * @internal
      */
     protected sorterService: SorterService;
+    /**
+     * True while the displayed rows are in the order of {@link getAllRows} (unsorted, maybe filtered) – then the rows a
+     * ring buffer removes at the start are a prefix of the displayed rows (no O(n) search, see {@link appendRows}).
+     */
+    private displayInDataOrder;
     /** Cached „Show values as“ values per property (cleared on filter, sorting and invalidation). */
     private showValuesCache;
     /**
@@ -251,6 +257,43 @@ export declare class AreaModelObjectArray<T> extends AbstractAreaModel<T> implem
      * bodyAreaModel.setRows(newRows);
      */
     setRows(rows: T[]): void;
+    /**
+     * Live data (since 1.1.108): appends rows **in place** to {@link getAllRows} (your array – no copy) and to the
+     * displayed rows: the active filter runs only for the new rows (O(k)), with an active sort order they are sorted
+     * and merged in (O(n + k), stable – behind equal rows, like a sort of all rows). With `ctx.maxRows` the oldest
+     * rows are removed from the start (ring buffer) – in blocks of at least 1 % of `maxRows` (moving the rows of an
+     * array is O(n)), so the row count stays between 99 % and 100 % of `maxRows`. Use `tableApi.appendRows()` – it passes filter and order and moves
+     * selection, focus and scroll position along.
+     *
+     * @param {unknown[]} newRows - the new rows (appended in this order)
+     * @param {AppendRowsContextIf<T>} [ctx] - active filter, sort order, ring buffer size
+     * @returns {AppendRowsModelResultIf} the removed and inserted display positions
+     *
+     * @example
+     * const result = bodyAreaModel.appendRows(lines, { maxRows: 100_000 });
+     * console.log(result.insertedPositions);   // where the new rows are shown
+     *
+     * @since 1.1.108
+     */
+    appendRows(newRows: unknown[], ctx?: AppendRowsContextIf<T>): AppendRowsModelResultIf;
+    /** Removes the first `count` rows of the data (in place) and of the displayed rows; their old display positions. */
+    private removeFirstRows;
+    private appendShown;
+    /** Sorts the new rows and merges them into the (sorted) displayed rows from the back – stable, in place. */
+    private mergeSorted;
+    /**
+     * The comparator of sort items (first item = primary key, the following ones break ties), as used by
+     * {@link doSort} – e.g. to sort new rows in (live data). `undefined` if no item sorts (state "").
+     *
+     * @param {SortItem[]} sortItems - column index and sort state per sorted column
+     * @returns {((a: T, b: T) => number) | undefined} the comparator
+     *
+     * @example
+     * const compare = bodyAreaModel.createSortComparator([new SortItem(2, "desc")]);
+     *
+     * @since 1.1.108
+     */
+    createSortComparator(sortItems: SortItem[]): ((a: T, b: T) => number) | undefined;
     /**
      * Filters both the original rows and filtered rows arrays using the provided predicate function.
      * Unlike `externalFilterChanged`, this method permanently modifies the original rows array.

package/lib/table/data/tablemodel/areamodel/area-model.if.d.ts

@@ -1,4 +1,5 @@
 import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { AppendRowsContextIf, AppendRowsModelResultIf } from '../../../live-append/append-rows-options.if.js';
 import { DerivedValuesChangeIf } from './derived-values-change.if.js';
 import { CellRendererIf } from '../../../renderer/cell-render.if.js';
 import { CheckedType } from '../../common/checked-type.js';
@@ -316,6 +317,19 @@ export interface AreaModelIf {
      * @since 1.1.95
      */
     moveRows?(rowIndices: number[], target: RowDropTargetIf): boolean;
+    /**
+     * Optional (live data, since 1.1.108): appends rows **in place** – the active filter only for the new rows, sorted
+     * in by the active order, oldest rows removed for a ring buffer – and reports the display positions, so the table
+     * moves selection, focus and scroll position along (`tableApi.appendRows()`). Implemented by
+     * {@link AreaModelObjectArray}; `false` = not supported (the table logs a warning and changes nothing).
+     *
+     * @param {unknown[]} rows - the new rows
+     * @param {AppendRowsContextIf} ctx - active filter, sort order, ring buffer size
+     * @returns {AppendRowsModelResultIf | false} what changed, or false
+     * @example
+     * const result = bodyModel.appendRows?.(lines, { maxRows: 100_000 });
+     */
+    appendRows?(rows: unknown[], ctx: AppendRowsContextIf): AppendRowsModelResultIf | false;
     /**
      * Optional: drops cached, derived values (e.g. the totals of an {@link AreaModelAggregateFooter}). The table calls
      * it for all three areas when data may have changed: filter, sorting, editing, `updateCells()` and the public
@@ -663,6 +677,10 @@ export interface AreaModelIf {
      * Returns the height of the row at the specified index, in pixels.
      * This method allows for variable row heights in the table.
      *
+     * The table draws the rows with these heights, and since 1.1.107 the height of the area (scroll height of the body,
+     * height of header and footer) is their sum as well – {@link getConstantRowHeight} × row count if given.
+     * `defaultRowHeights` of the table model only counts if every row height is 0.
+     *
      * @param {number} rowIndex - The index of the row
      * @returns {number} The height of the row in pixels
      *
@@ -699,6 +717,8 @@ export interface AreaModelIf {
      * of all rows above it – with millions of rows this keeps scrolling at the end of the table as fast as at
      * the beginning. Only return a number if `getRowHeight(i)` returns exactly this value for every row.
      * If the method is missing or returns `undefined`, the renderer falls back to iterating the row heights.
+     * The height of the area (the scroll height of the body) is then this value × row count – O(1) – and wins over
+     * `defaultRowHeights` of the table model (since 1.1.107; before, `defaultRowHeights` came first).
      *
      * @returns {number | undefined} The constant row height in pixels, or `undefined` if row heights may vary.
      *

package/lib/table/data/tablemodel/areamodel/col-and-rowspan-model.d.ts

@@ -15,6 +15,18 @@ export declare class ColAndRowspanModel {
     /** Row count of the area model at the last {@link init} (−1: not initialized yet). */
     protected rowCountAtInit: number;
     init(): void;
+    /** Adds the spans starting in a row. */
+    private scanRow;
+    /**
+     * Live data (since 1.1.108): rows were inserted (and maybe removed at the start) – scans only the inserted rows
+     * (O(k)) instead of all rows ({@link init}: O(n) per update, because most area models report a possible span of 31).
+     * Only possible while no span exists; otherwise (or before the first init) false – then {@link initIfRowCountChanged}
+     * builds the ranges again.
+     *
+     * @param {ArrayLike<number>} insertedPositions - display indices of the inserted rows (after the step), ascending
+     * @returns {boolean} true if the ranges are up to date
+     */
+    updateForInsertedRows(insertedPositions: ArrayLike<number>): boolean;
     /**
      * Builds the ranges again if the row count of the area model changed since the last {@link init} – e.g. after
      * `setRows()` or a filter (the old ranges could point to rows that no longer exist). Cheap otherwise.

package/lib/table/data/tablemodel/table-model.d.ts

@@ -157,10 +157,24 @@ export declare class TableModel implements TableModelIf {
      */
     getModel(rowAreaIdent: AreaIdent): AreaModelIf;
     /**
-     * Calculates the height of the area identified by the given area identifier.
+     * Calculates the height of the area identified by the given area identifier – the height of the rows the table
+     * draws (since 1.1.107 the same source as the rendering):
+     *
+     * 1. `getConstantRowHeight()` of the area model (> 0): row count × that height – O(1), also for millions of rows,
+     * 2. otherwise the sum of `getRowHeight(i)` of all rows (variable heights; O(n), like the row layout of the body),
+     * 3. only if the model has no row heights of its own (every `getRowHeight(i)` is 0): row count ×
+     *    `defaultRowHeights[area]`.
+     *
+     * Before 1.1.107 `defaultRowHeights[area]` came first: an area model with other heights got a wrong scroll height
+     * (a scroll bar without overflow, a wrong thumb). The built-in area models take their row height from
+     * `defaultRowHeights` anyway, so nothing changes for them.
      *
      * @param {AreaIdent} areaIdent - The identifier of the area.
-     * @return {number} - The height of the area.
+     * @return {number} - The height of the area in px.
+     *
+     * @example
+     * // an own body with 20 px rows: 3000 rows are 60,000 px high – also if defaultRowHeights.body is 34
+     * const height = (tableModel as TableModel).getAreaHeight("body");
      */
     getAreaHeight(areaIdent: AreaIdent): number;
     /**

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

@@ -140,11 +140,20 @@ export declare class EleScope {
     /** The element that holds the rows of an area (`DivScope.child`). */
     protected getAreaChild(area: AreaIdent, side: SideIdent): HTMLDivElement;
     /**
-     * Adjusts the containers and rows of the table based on the current state.
+     * Adjusts the containers and rows of the table based on the current state: lays out the areas
+     * ({@link layoutContainers}) and renders the visible rows ({@link adjustAfterScrolling}).
      *
      * @return {void}
      */
     adjustContainersAndRows(): void;
+    /**
+     * Lays out the scroll viewport, the nine areas, the separator borders, the overlay and the detail layer for the
+     * current size of the host and the current padding – without rendering the rows (that is
+     * {@link adjustAfterScrolling}). `repaintHard()` uses it to set a new scroll position before its one render pass.
+     *
+     * @since 1.1.107
+     */
+    protected layoutContainers(): void;
     /**
      * The height the table lays out header, body and footer in: the host height minus a horizontal scroll bar that
      * takes space (see {@link horizontalScrollBarHeight}).

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

@@ -103,7 +103,12 @@ export interface CreateTableModelPara {
      * @since 1.1.99
      */
     columnLetters: boolean;
-    /** Row heights of header, body and footer in px. Default: `tableOptions.defaultRowHeights`, otherwise 34 / 34 / 34. */
+    /**
+     * Row heights of header, body and footer in px. Default: `tableOptions.defaultRowHeights`, otherwise 34 / 34 / 34.
+     * The area models built by the factory get these heights. An own area model (`bodyAreaModel` …) keeps its own:
+     * since 1.1.107 the table measures every area with the heights of its model (`getConstantRowHeight()`, otherwise
+     * `getRowHeight(i)`) – `defaultRowHeights` only counts for a model whose `getRowHeight()` returns 0.
+     */
     defaultRowHeights: DefaultRowHeightsIf;
     /** The columns: property, header label, width, classes, renderers, sorting, editing. See {@link ColumnDef}. */
     columnDefs: ColumnDefIf[];

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

@@ -1,6 +1,7 @@
 import { FocusType } from './focus.type.js';
 import { FocusModelIf } from './focus-model.if.js';
 import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if.js';
+import { RowIndexShift } from '../live-append/row-index-shift.js';
 
 /**
  * The `FocusModel` class is an implementation of the `FocusModelIf` interface.
@@ -63,6 +64,17 @@ export declare class FocusModel implements FocusModelIf {
     hasChanged(): boolean;
     clear(): void;
     setFocus(rowIndex: number, columnIndex: number): void;
+    /**
+     * Live data (since 1.1.108): the focused row moves along when rows were removed at the start or inserted
+     * (`tableApi.appendRows()`). The same row keeps the focus without an event; if it was removed, the next remaining
+     * row gets it (with an event – the table keeps it inside the rows).
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     *
+     * @example
+     * focusModel.adjustForRowChanges?.(new RowIndexShift([0, 1], []));   // row 5 → row 3
+     */
+    adjustForRowChanges(shift: RowIndexShift): void;
     hasFocus(rowIndex: number, columnIndex: number): boolean;
     getFocus(): [number, number];
 }

package/lib/table/focus/focus-model.if.d.ts

@@ -1,4 +1,5 @@
 import { EventFocusChangedListenerIf } from './event-focus-changed-listener.if.js';
+import { RowIndexShift } from '../live-append/row-index-shift.js';
 
 /**
  * The focused cell of a table (moved by click and arrow keys; F2 edits it). The implementation is {@link FocusModel};
@@ -31,4 +32,14 @@ export interface FocusModelIf {
     hasChanged(): boolean;
     /** Resets {@link hasChanged}. */
     clearChanged(): void;
+    /**
+     * Optional (live data, since 1.1.108): the focused row moves along when rows were removed at the start or
+     * inserted (`tableApi.appendRows()`). Same row: no event. Focused row removed: the next remaining row gets the
+     * focus (with an event).
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     * @example
+     * focusModel.adjustForRowChanges?.(new RowIndexShift([0], []));
+     */
+    adjustForRowChanges?(shift: RowIndexShift): void;
 }

package/lib/table/live-append/append-rows-options.if.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Where the view goes after new rows came in (`tableApi.appendRows()` / `rowsAppended()`):
+ * - `"auto"` (default): it follows the end if it was at the end before ("tail -f"), otherwise the first visible row
+ *   stays where it is;
+ * - `true`: always to the end;
+ * - `false`: the first visible row always stays (a "freeze scroll" button of the app).
+ *
+ * While the mouse button is held in the table (a click, a drag), `"auto"` keeps the row – the content does not slide
+ * away under the pointer.
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export type AppendFollowMode = "auto" | boolean;
+/**
+ * Options of `tableApi.appendRows(rows, options)`.
+ *
+ * @example
+ * const result = tableApi.appendRows(lines, { follow: "auto", maxRows: 1_000_000 });
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export interface AppendRowsOptionsIf {
+    /** Where the view goes – see {@link AppendFollowMode}. Default `"auto"`. */
+    follow?: AppendFollowMode;
+    /**
+     * Ring buffer: keep at most this many rows – the oldest (first) rows of the data are removed from the start, in
+     * blocks of at least 1 % of `maxRows` (removing from the start of an array moves all rows: O(n) – the blocks make
+     * that rare), so the row count stays between 99 % and 100 % of `maxRows`.
+     * Selection, focus and the visible row stay at their rows; a selected row that is removed leaves the selection.
+     */
+    maxRows?: number;
+}
+/**
+ * Options of `tableApi.rowsAppended(count, options)` – an own area model that appended (and maybe removed) rows
+ * itself.
+ *
+ * @example
+ * const logLines: string[] = [];             // the data of an own area model
+ * for (const line of newLines) logLines.push(line);
+ * const dropped = Math.max(0, logLines.length - 100_000);
+ * logLines.splice(0, dropped);               // the app keeps its own ring buffer
+ * tableApi.rowsAppended(newLines.length, { follow: "auto", removedAtStart: dropped });
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export interface RowsAppendedOptionsIf {
+    /** Where the view goes – see {@link AppendFollowMode}. Default `"auto"`. */
+    follow?: AppendFollowMode;
+    /** Number of rows the app removed at the start (display indices 0 … n-1 before the step). Default 0. */
+    removedAtStart?: number;
+}
+/**
+ * Result of `tableApi.appendRows()` / `rowsAppended()`.
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export interface AppendRowsResultIf {
+    /** rows added to the data */
+    added: number;
+    /** of them shown (an active filter hides the others) */
+    shown: number;
+    /** rows removed at the start (`maxRows` / `removedAtStart`) */
+    removed: number;
+    /** true if the view follows the end after this update */
+    following: boolean;
+}
+/**
+ * What a table passes to {@link AreaModelIf.appendRows}: the active filter and sort order, so the model treats only
+ * the new rows (O(k) unsorted, O(n + k) sorted).
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export interface AppendRowsContextIf<T = unknown> {
+    /** the active filter (`tableOptions.externalFilterFunction`) – new rows it rejects are kept but not shown */
+    filter?: (row: T) => boolean;
+    /** the active sort order – new rows are inserted at their place (stable: behind equal rows) */
+    compare?: (a: T, b: T) => number;
+    /** ring buffer size, see {@link AppendRowsOptionsIf.maxRows} */
+    maxRows?: number;
+}
+/**
+ * What {@link AreaModelIf.appendRows} did – the table moves selection, focus and position along.
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export interface AppendRowsModelResultIf {
+    added: number;
+    shown: number;
+    /** rows removed from the data */
+    removed: number;
+    /** display indices **before** the step of the removed rows that were shown, ascending */
+    removedPositions: Int32Array;
+    /** display indices **after** the step of the new shown rows, ascending */
+    insertedPositions: Int32Array;
+}

package/lib/table/live-append/row-index-shift.d.ts

@@ -0,0 +1,71 @@
+/**
+ * How the display indices of the body rows move when rows are removed and inserted in one step (live data:
+ * `tableApi.appendRows()` / `rowsAppended()`, since 1.1.108) – so selection, focus and anchor stay at the same rows
+ * instead of being cleared. DOM-free.
+ *
+ * Order: first the `removed` rows leave (indices **before** the step), then the `inserted` rows come in (indices
+ * **after** the step). An old row keeps its relative order.
+ *
+ * @example
+ * // 2 rows dropped at the start (ring buffer), 3 appended at the end of 10 → 11 rows
+ * const shift = new RowIndexShift([0, 1], [8, 9, 10]);
+ * shift.mapIndex(5);        // 3
+ * shift.mapIndex(1);        // -1 (removed)
+ *
+ * @example
+ * // sorted: one row inserted at display index 2 (between the old rows 1 and 2)
+ * const shift = new RowIndexShift([], [2]);
+ * shift.mapRange(0, 4);     // [[0, 1], [3, 5]] – the new row splits the range (it is not selected)
+ *
+ * @category Live data
+ * @since 1.1.108
+ */
+export declare class RowIndexShift {
+    private readonly removed;
+    private readonly inserted;
+    /** inserted[j] - j: the number of old rows in front of the inserted row j (non-decreasing) */
+    private readonly insertBefore;
+    /**
+     * @param {ArrayLike<number>} removed - display indices before the step of the removed rows, ascending, unique
+     * @param {ArrayLike<number>} inserted - display indices after the step of the inserted rows, ascending, unique
+     */
+    constructor(removed?: ArrayLike<number>, inserted?: ArrayLike<number>);
+    /** True if nothing moves (no row removed, none inserted). */
+    isEmpty(): boolean;
+    /** Number of removed rows. */
+    getRemovedCount(): number;
+    /** Number of inserted rows. */
+    getInsertedCount(): number;
+    /**
+     * True if a row at an old display index `<= index` is removed or a row is inserted in front of the old row `index`
+     * (i.e. the rows `0 … index` are not the same as before).
+     *
+     * @param {number} index - an old display index
+     * @returns {boolean} true if the rows up to this index changed
+     */
+    touchesUpTo(index: number): boolean;
+    /**
+     * The new display index of an old one.
+     *
+     * @param {number} index - display index before the step
+     * @returns {number} the index after the step, -1 if the row was removed (or `index` is negative)
+     */
+    mapIndex(index: number): number;
+    /**
+     * The display index after the step of the first remaining row at or after an old index – for a position that
+     * must stay on a row (e.g. the first visible row) when that row itself was removed.
+     *
+     * @param {number} index - display index before the step
+     * @returns {number} the index after the step (the end if no old row at or after `index` remains)
+     */
+    mapIndexOrNext(index: number): number;
+    /**
+     * The new ranges of an old range of rows `lo … hi` (inclusive): removed rows leave it, inserted rows inside split
+     * it (they are not part of it). `hi = Number.MAX_SAFE_INTEGER` (whole columns) stays open at the end.
+     *
+     * @param {number} lo - first row of the range before the step
+     * @param {number} hi - last row of the range before the step (inclusive)
+     * @returns {[number, number][]} the pieces after the step, ascending, `[]` if all its rows were removed
+     */
+    mapRange(lo: number, hi: number): [number, number][];
+}

package/lib/table/mouse-handler.d.ts

@@ -1,5 +1,6 @@
 import { TableScope } from './table-scope.js';
 import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
+import { RowIndexShift } from './live-append/row-index-shift.js';
 
 /**
  * Class representing a MouseHandler.
@@ -17,11 +18,26 @@ export declare class MouseHandler {
      * @type {number}
      */
     doubleClickDelay: number;
+    /**
+     * A render between mousedown and mouseup replaces the pressed cell, and the browser sends no "click" (both must hit
+     * the same element). The handler then reports the click itself for the pressed cell – if the mouse moved at most
+     * this many pixels (screen coordinates) between mousedown and mouseup. Since 1.1.108.
+     *
+     * @type {number}
+     */
+    clickMoveTolerance: number;
     mouseEvent?: MouseEvent;
     startMouseEvent?: GeMouseEvent;
     geMouseEvent?: GeMouseEvent;
     geMouseEventOld?: GeMouseEvent;
     private lastClickedCellKey;
+    /** The cell of the last left-button mousedown (see {@link PressedCell}). */
+    private pressedCell?;
+    /** Counts native "click" / "dblclick" events: a report of a lost click is dropped if the browser sent one after all. */
+    private nativeClickCount;
+    private nativeDblClickCount;
+    /** Timer of a pending report of a lost click (cleared by destroy via the abort signal). */
+    private lostClickTimer?;
     /** The second click of a double click that was already reported (clickCount 2) – its "dblclick" is not. */
     private reportedDoubleClick?;
     private mouseDown;
@@ -49,6 +65,16 @@ export declare class MouseHandler {
      * @return {void}
      */
     private onHostElementClicked;
+    /**
+     * Handles a click: on `eventTarget`, or – if `cell` is given – on that cell (a click the browser did not send
+     * because a render replaced the pressed element; `eventTarget` is then the detached pressed element).
+     */
+    private handleClick;
+    /** "area:row:column" of a cell given explicitly (same format as {@link getCellKey}). */
+    private toCellKey;
+    /** Target data of a replaced element: area, row and column come from the pressed cell (current row index). */
+    private applyCell;
+    private createCellEvent;
     /** "area:row:column" of the cell of an event target ('' outside of a cell). */
     private getCellKey;
     /** A click that triggers an action on its own: row checkbox, tree arrow, "expand/collapse all", header group toggle. */
@@ -60,6 +86,8 @@ export declare class MouseHandler {
      * @param {MouseEvent} event - The double click event.
      */
     private onHostElementDblClicked;
+    /** Handles a double click on `eventTarget`, or on `cell` (see {@link handleClick}). */
+    private handleDblClick;
     /**
      * Publishes a GeMouseEvent.
      *
@@ -77,12 +105,41 @@ export declare class MouseHandler {
     private isInteractiveCellElement;
     private getArrowColumnIndex;
     private onMouseDown;
+    /** A mouseup that did not reach the host (released outside the table). */
+    private onDocumentMouseUp;
+    /**
+     * Live data (since 1.1.108): a drag in progress (range selection) keeps its start row when rows were removed at the
+     * start or inserted.
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     */
+    adjustForRowChanges(shift: RowIndexShift): void;
     private onMouseMove;
     private onMouseUp;
+    /** The cell under a mousedown, or undefined outside of a cell. */
+    private readPressedCell;
+    /**
+     * After a mouseup: if a render replaced the pressed element, the browser sends no "click" (nor "dblclick"). Then the
+     * click is reported for the pressed cell – once this task is through and only if no native click came after all.
+     */
+    private checkLostClick;
+    /**
+     * The current index of the pressed row: rows may have been added, removed or sorted in while the button was held.
+     * -1 if the row is gone.
+     */
+    private resolveRowIndex;
+    private rowAt;
     private mouseDraggingOnFrame;
     /** Handles the end of the last drag now (in its frame, or earlier when the next mousedown comes first). */
     private flushDraggingEnd;
     private mouseMoveOnFrame;
+    /**
+     * True while the mouse button is held in the table (a click or a drag in progress) – live data does not jump to
+     * the end then (`tableApi.appendRows({ follow: "auto" })`, since 1.1.108).
+     *
+     * @returns {boolean} true between mousedown and mouseup
+     */
+    isButtonDown(): boolean;
     /** A mouse event on a blocking loading overlay ({@link TableOverlay.isEventBlocked}): the table ignores it. */
     private isBlocked;
 }