@guiexpert/table 1.1.107 → 1.1.109

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

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

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

@@ -11,6 +11,7 @@ import { CellRange } from './data/common/cell-range.js';
 import { RendererCleanupFnType } from './renderer/renderer-cleanup-fn.type.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
 import { SideIdent } from './data/side-ident.type.js';
+import { RowIndexShift } from './live-append/row-index-shift.js';
 import { DivScope } from './data/div-scope.type.js';
 import { DerivedValuesChangeIf } from './data/tablemodel/areamodel/derived-values-change.if.js';
 import { AreaModelIf } from './data/tablemodel/areamodel/area-model.if.js';
@@ -73,6 +74,17 @@ export declare class RenderScope extends EleScope {
      * that is already rendered (`repaintHard({ py })`, `scrollToPixel()` render it at once) renders nothing.
      */
     protected renderedScrollTop: number;
+    /**
+     * The body rows of the last render pass (live data, since 1.1.108): row count, first visible row and the content
+     * offset into it, last (partly) visible row, and whether the view was at the end.
+     */
+    protected renderedBodyRows: {
+        count: number;
+        first: number;
+        offset: number;
+        last: number;
+        atEnd: boolean;
+    };
     protected renderedScrollLeft: number;
     /** Area heights read once at the start of adjustAfterScrolling() (before the DOM is modified). */
     protected areaHeightsOfRenderPass?: {
@@ -273,6 +285,13 @@ export declare class RenderScope extends EleScope {
      *
      * @returns {void}
      */
+    /**
+     * Live data (since 1.1.108): the in-cell editor (`getEditRenderer`) and its draft follow their row when rows were
+     * removed at the start or inserted; a removed row closes the editor.
+     *
+     * @param shift - how the display indices move
+     */
+    protected shiftEditorRow(shift: RowIndexShift): void;
     resetEditorRenderer(): void;
     /**
      * Clears the selection in the component.
@@ -313,6 +332,18 @@ export declare class RenderScope extends EleScope {
      * @return {void} This method does not return any value.
      */
     repaintHard(scrollTo?: ScrollPositionIf): void;
+    /** Remembers which body rows the render pass drew ({@link renderedBodyRows}) – two O(log n) lookups. */
+    private rememberRenderedBodyRows;
+    /**
+     * Live data (since 1.1.108, prompt 018 part B): the body got more rows, but the drawn rows stay the same (rows
+     * appended or sorted in behind the visible ones, the view does not follow). Updates heights, scroll content, scroll
+     * bar and `aria-rowcount` – **without** rebuilding the cells. Returns false (and does nothing more) if that is not
+     * enough: the vertical scroll bar appeared or disappeared (the widths change) or col-/rowspans exist.
+     *
+     * @param {number} py - the content position to keep (the same rows as drawn)
+     * @returns {boolean} true if done, false if the caller must render
+     */
+    protected updateRowCountWithoutRender(py: number): boolean;
     /**
      * Sets the scroll position of the viewport to a content position **without rendering** (shared by
      * `scrollToPixel()` and `repaintHard({ px, py })`). `py` is a content position: the scroll bar range differs from the

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

@@ -2,6 +2,7 @@ import { CellRange } from '../data/common/cell-range.js';
 import { ExtendedSelectionType, SelectionMode } from './selection.type.js';
 import { SelectionModelIf } from './selection-model.if.js';
 import { EventSelectionChangedListenerIf } from './event-selection-changed-listener.if.js';
+import { RowIndexShift } from '../live-append/row-index-shift.js';
 
 /**
  * Saved state of a {@link SelectionModel} – see {@link SelectionModel.createSnapshot}.
@@ -84,6 +85,22 @@ export declare class SelectionModel implements SelectionModelIf {
      * @param {SelectionSnapshot} snapshot - the state to restore
      */
     restoreSnapshot(snapshot: SelectionSnapshot): void;
+    /**
+     * Live data (since 1.1.108): moves the selected rows along when rows were removed at the start or inserted
+     * (`tableApi.appendRows()` / `rowsAppended()`). Ranges are adjusted **in place** (snapshots and the anchor of the
+     * selection service keep pointing at them); removed rows leave a range, rows inserted inside split it (not
+     * selected – like Excel); whole columns (`r1 = 0`, `r2 = MAX_SAFE_INTEGER`) and "all selected" stay. No event.
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     * @returns {boolean} true if a selected row was removed
+     *
+     * @example
+     * // rows 0 and 1 removed (ring buffer): the selection of row 5 is row 3 now
+     * selectionModel.adjustForRowChanges(new RowIndexShift([0, 1], []));
+     */
+    adjustForRowChanges(shift: RowIndexShift): boolean;
+    /** Shifts ranges in place (split pieces are appended); true if rows of a range were removed. */
+    private static shiftRanges;
     getSelectionCount(rowIndex: number, columnIndex: number): number;
     isInNegativeRange(rowIndex: number, columnIndex: number): boolean;
     getRanges(): CellRange[];

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

@@ -1,5 +1,6 @@
 import { CellRange } from '../data/common/cell-range.js';
 import { EventSelectionChangedListenerIf } from './event-selection-changed-listener.if.js';
+import { RowIndexShift } from '../live-append/row-index-shift.js';
 
 /**
  * What is selected in a table – a list of rectangles ({@link CellRange}). The implementation is {@link SelectionModel};
@@ -82,4 +83,16 @@ export interface SelectionModelIf {
     isAllSelected(): boolean;
     /** Called by the table on a click: starts a selection at this cell, depending on selection type and mode. */
     firstClick(rowIndex: number, columnIndex: number): void;
+    /**
+     * Optional (live data, since 1.1.108): moves the selected rows along when rows were removed at the start or
+     * inserted (`tableApi.appendRows()` / `rowsAppended()`), instead of clearing the selection. Removed rows leave the
+     * selection; rows inserted inside a selected range split it (they are not selected); whole columns and "all
+     * selected" stay. Fires no event.
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     * @returns {boolean} true if a selected row was removed (the selection shows other rows now)
+     * @example
+     * selectionModel.adjustForRowChanges?.(new RowIndexShift([0, 1], [98, 99]));
+     */
+    adjustForRowChanges?(shift: RowIndexShift): boolean;
 }

package/lib/table/selection/selection-service.d.ts

@@ -7,6 +7,7 @@ import { CellRange } from '../data/common/cell-range.js';
 import { OnActionTriggeredIf } from '../action/on-action-triggered.if.js';
 import { ActionId } from '../action/action-id.type.js';
 import { SelectionSnapshot } from './selection-model.js';
+import { RowIndexShift } from '../live-append/row-index-shift.js';
 
 /** @category Internals */
 export declare class SelectionService implements OnActionTriggeredIf {
@@ -62,6 +63,13 @@ export declare class SelectionService implements OnActionTriggeredIf {
      * @returns {[number, number] | undefined} row and column, `undefined` before the first click/keyboard move
      * @since 1.1.99
      */
+    /**
+     * Live data (since 1.1.108): anchor, moving corner and last click follow their rows when rows were removed at the
+     * start or inserted (`tableApi.appendRows()`); a removed row drops them.
+     *
+     * @param {RowIndexShift} shift - how the display indices move
+     */
+    adjustForRowChanges(shift: RowIndexShift): void;
     getAnchor(): [number, number] | undefined;
     /**
      * The moving corner of the range Shift+arrows grow (the anchor if there is none).