@guiexpert/table 1.1.106 → 1.1.108

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';
@@ -30,6 +31,7 @@ import { AriaTextsIf } from './aria/aria-texts.if.js';
 import { RowLayout } from './row-layout/row-layout.js';
 import { MasterDetailService } from './master-detail/master-detail-service.js';
 import { TableSheet } from './sheet/table-sheet.js';
+import { ScrollPositionIf } from './data/common/scroll-position.if.js';
 
 /** @category Internals */
 export declare class RenderScope extends EleScope {
@@ -67,6 +69,23 @@ export declare class RenderScope extends EleScope {
         scrollTop: number;
         contentTop: number;
     };
+    /**
+     * The scroll position (`scrollTop`, logical `scrollLeft`) of the last render pass – the `scroll` event of a position
+     * 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?: {
         [key in AreaIdent]?: number;
@@ -214,8 +233,10 @@ export declare class RenderScope extends EleScope {
     /** True if open detail rows take space between the body rows. */
     protected hasBodyRowExtras(): boolean;
     /**
-     * The top of a body row in content pixels: {@link AreaModelIf.getYPosByRowIndex} plus the heights of the open detail
-     * rows above it (master/detail).
+     * The top of a body row in content pixels – from the row layout of the table ({@link getBodyRowLayout}: the heights
+     * the rows are drawn with, plus the open detail rows above it). Since 1.1.107 always from the layout (before: without
+     * detail rows from {@link AreaModelIf.getYPosByRowIndex}, which an area model with its own `getRowHeight()` could
+     * get wrong – `scrollToIndex()` landed beside the row). O(1) for constant heights, otherwise after one O(n) build.
      *
      * @param {number} rowIndex - display index
      * @returns {number} px from the top of the first body row
@@ -264,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.
@@ -296,13 +324,51 @@ export declare class RenderScope extends EleScope {
      */
     invalidateAggregates(change?: DerivedValuesChangeIf): void;
     /**
-     * Repaints the UI by resetting the size of the wrapper div,
-     * adjusting the containers and rows, and performing additional adjustments
-     * after scrolling.
+     * Repaints the UI after the row count or the row heights changed: new heights and padding, new size of the scroll
+     * content, new layout of the areas – then **one** render pass (since 1.1.107; before: two).
      *
+     * @param {ScrollPositionIf} [scrollTo] - a content position to show in that render pass (like {@link scrollToPixel},
+     *   exact also with a capped scroll height); a missing axis keeps its position
      * @return {void} This method does not return any value.
      */
-    repaintHard(): void;
+    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
+     * content range – always with a capped scroll height, but also slightly without (the scroll content is 1 px higher
+     * than the rows, the scroll viewport includes the footer and the horizontal scroll bar). `scrollTop = py` would leave
+     * the target row a few pixels off, so the exact content position is remembered (`pendingContentScroll`) and used by
+     * the next render passes as long as the scroll bar is not moved.
+     *
+     * @param {number | undefined} px - from the start of the rows (logical, right-to-left from the right edge);
+     *   `undefined` keeps the horizontal position
+     * @param {number | undefined} py - content px from the top of the first body row; `undefined` keeps the vertical
+     *   position
+     * @returns {boolean} true if the exact content position was set (then render now – a scroll event may not fire);
+     *   false if the browser renders it with its scroll event (nothing to scroll vertically, or only `px`)
+     * @since 1.1.107
+     */
+    protected setContentScrollPosition(px: number | undefined, py: number | undefined): boolean;
+    /**
+     * The `scroll` listener of the scroll viewport: renders the new position – nothing if the position is already
+     * rendered (the event of a `repaintHard({ py })`, `scrollToPixel()` or `ensureColumnIsVisible()` arrives after
+     * their own render pass).
+     *
+     * @since 1.1.107
+     */
+    onViewportScroll(): void;
     /**
      * Recalculates the column widths of the table (% and weight columns depend on the available width) and repaints.
      *
@@ -316,7 +382,7 @@ export declare class RenderScope extends EleScope {
     protected setParentWidth(widthInPixel: number): void;
     /** True if a column has a % or weight width (it depends on the width of the host). */
     protected hasRelativeColumnWidths(): boolean;
-    adjustContainersAndRows(): void;
+    protected layoutContainers(): void;
     /**
      * % and weight columns share the width next to the vertical scroll bar. The bar appears (or disappears) only after
      * the rows are laid out – the first layout, rows added or removed, a filter: then the columns were computed for the
@@ -448,14 +514,14 @@ export declare class RenderScope extends EleScope {
      * scaled and scrollTop is no longer a content pixel position.
      */
     isScrollHeightCapped(): boolean;
+    /** The detail layer (master/detail) covers the visible body. @since 1.1.97 */
+    protected adjustDetailLayerBounds(left: number, top: number, width: number, height: number): void;
     /**
      * The model's content height plus the heights of open detail rows (master/detail).
      *
      * @returns {number} px
      * @since 1.1.97
      */
-    /** The detail layer (master/detail) covers the visible body. @since 1.1.97 */
-    protected adjustDetailLayerBounds(left: number, top: number, width: number, height: number): void;
     protected getBodyContentHeight(): number;
     /** Scrollable range of the content in content pixels (content height minus visible body height). */
     protected getContentScrollRangeY(): number;
@@ -601,7 +667,7 @@ export declare class RenderScope extends EleScope {
      */
     private rowNumberWidth?;
     /** true while the containers are adjusted to a new row number width (no second change in that nested pass). */
-    private adjustingRowNumberWidth;
+    protected adjustingRowNumberWidth: boolean;
     /** Guards {@link adjustRelativeColumnWidthsToScrollBar} against re-entry. */
     private adjustingRelativeWidths;
     /** The width % and weight columns were last computed for (`TableModelIf.setParentWidth`), -1 = unknown. */

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).

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

@@ -27,6 +27,8 @@ import { CellRange } from './data/common/cell-range.js';
 import { EventListenerIf } from './event-listener.if.js';
 import { ExcelExportOptionsIf } from './service/excel-export-options.if.js';
 import { SheetEngine } from './sheet/sheet-engine.js';
+import { ScrollPositionIf } from './data/common/scroll-position.if.js';
+import { AppendRowsOptionsIf, AppendRowsResultIf, RowsAppendedOptionsIf } from './live-append/append-rows-options.if.js';
 
 /**
  * The public API of one table – everything you do with a table after it has been created:
@@ -200,7 +202,7 @@ export declare class TableApi {
      * };
      *
      * // Initialize your table with these options
-     * const tableApi = new TableApi(tableScope);
+     * const tableApi = tableScope.getApi();
      *
      * // Later, when filter criteria change (e.g., in a search input handler)
      * function onFilterTextChanged() {
@@ -432,7 +434,7 @@ export declare class TableApi {
      *
      * @example
      * // Update data and repaint the table
-     * const tableApi = new TableApi(tableScope);
+     * const tableApi = tableScope.getApi();
      * tableApi.setRows(newData);
      * tableApi.repaint();
      *
@@ -464,19 +466,24 @@ export declare class TableApi {
      */
     destroy(): void;
     /**
-     * Performs a complete repaint of the table by triggering a hard repaint on the underlying table scope.
+     * Performs a complete repaint of the table: use it when the row count or the row heights changed (rows added or
+     * removed, a filter, a new model content, `ColumnDefIf.isVisible` changed yourself …). It
+     * - drops cached derived values (footer totals, calculated columns),
+     * - recalculates the heights and the padding of the table model and the size of the scroll content,
+     * - lays out header, body and footer again and
+     * - renders the visible rows – **once** (since 1.1.107; before: twice).
      *
-     * A hard repaint is more thorough than a regular repaint and performs the following operations:
-     * - Recalculates the height and padding of the table model
-     * - Resets the size of the wrapper div elements
-     * - Adjusts containers and rows positioning
-     * - Makes additional adjustments after scrolling
+     * With `scrollTo` (since 1.1.107) it also sets the scroll position in that same render pass – exactly like
+     * {@link scrollToPixel}, also with a capped scroll height (more than {@link EleScope.maxScrollHeightInPx} px of rows).
+     * A live tail that appends rows and keeps a position needs one render per update instead of three
+     * (`repaintHard()` + `scrollToPixel()`). The `scroll` event of the browser for that position renders nothing.
+     * A missing axis keeps its position.
      *
-     * Use this method when regular repaint isn't sufficient, such as when:
-     * - Table dimensions have significantly changed
-     * - The structure of data has been modified (rows/columns added or removed)
-     * - The table layout needs complete recalculation
-     * - After major DOM changes affecting the table's container
+     * For a repaint with the same row count (values changed) {@link repaint} is enough.
+     *
+     * @param {ScrollPositionIf} [scrollTo] - the position to show: `px` horizontal scroll position from the start, `py`
+     *   content pixels from the top of the first body row (both like {@link scrollToPixel}); without it the position stays
+     * @returns {void} This method doesn't return a value
      *
      * @example
      * // Example 1: Basic usage
@@ -499,9 +506,20 @@ export declare class TableApi {
      * column.isVisible = FalseFn;
      * tableApi.repaintHard();
      *
-     * @returns {void} This method doesn't return a value
+     * @example
+     * // Example 5: live tail – rows were appended to the area model, the first visible row stays at the top
+     * // (pixel-exact: keep your own py from the last update instead – e.g. from onScroll)
+     * const rowHeight = 20;                                   // the row height of the area model
+     * const first = tableApi.getFirstVisibleRowIndex();
+     * rows.push(...newData);                                  // the row count of the model grows
+     * tableApi.repaintHard({ py: first * rowHeight });        // one render pass, exact also for millions of rows
+     *
+     * @example
+     * // Example 6: follow the end ("tail -f") – show the last row after every update
+     * rows.push(...newData);
+     * tableApi.repaintHard({ py: Number.MAX_SAFE_INTEGER }); // clamped to the end of the content
      */
-    repaintHard(): void;
+    repaintHard(scrollTo?: ScrollPositionIf): void;
     /**
      * Recalculates the column widths of the table.
      *
@@ -888,7 +906,7 @@ export declare class TableApi {
      *
      * @example
      * // Access the TableScope to perform a custom operation
-     * const tableApi = new TableApi(myTableScope);
+     * const tableApi = myTableScope.getApi();
      * const tableScope = tableApi.getTableScope();
      *
      * // Example: Manually trigger a context menu at a specific location
@@ -1023,6 +1041,8 @@ export declare class TableApi {
      * Only works with an {@link AreaModelObjectArray} body – logs a console warning otherwise.
      * Does **not** repaint and resets filtering and sorting of the body: afterwards call
      * {@link externalFilterChanged} (if a filter function is set) and {@link repaintHard} (the row count changed).
+     * Copies all rows (O(n)) – for live data (rows arriving all the time) use {@link appendRows}: in place, filter and
+     * order only for the new rows, selection and position stay.
      *
      * @template T - The type of elements in the rows array
      * @param {T[]} rows - An array of data objects to append to the table's existing rows
@@ -1039,6 +1059,81 @@ export declare class TableApi {
      * tableApi.repaintHard();
      * tableApi.ensureRowIsVisible(tableApi.getDisplayedRowCount() - 1);
      */
+    /**
+     * **Live data** (a log tail, a ticker – since 1.1.108): appends rows to the body and shows them in **one** render
+     * pass – O(k) for k new rows, not O(n).
+     *
+     * - **In place**: the rows are pushed to your array (`getAllRows()`), nothing is copied.
+     * - **Filter and order** (`externalFilterFunction`, a sorted column or `sort(fn)`) apply to the new rows only:
+     *   filtered rows are kept but not shown, sorted rows are merged in (O(n + k), behind equal rows).
+     * - **Selection, focus, anchor, checked rows** stay at their rows (the indices move along; no `onSelectionChanged`
+     *   unless a selected row was removed).
+     * - **Position**: `follow: "auto"` (default) stays at the end if the view was at the end ("tail -f"), otherwise the
+     *   first visible row stays; `true` = always the end, `false` = always keep the row ("freeze scroll"). While the
+     *   mouse button is held in the table, `"auto"` keeps the row.
+     * - **Ring buffer**: `maxRows` removes the oldest rows from the start.
+     * - Rows behind the visible ones (a reader in the middle of the log): the cells are not rebuilt – only scroll height
+     *   and scroll bar change.
+     *
+     * Works with an {@link AreaModelObjectArray} body (`TableFactory.createTableModel({ rows, … })`) without cell
+     * formulas; a tree, row grouping, pivot or spreadsheet → `false` and a console warning. Own area model:
+     * {@link rowsAppended}.
+     *
+     * @param {T[]} rows - the new rows (appended in this order)
+     * @param {AppendRowsOptionsIf} [options] - `follow` ("auto" | true | false), `maxRows`
+     * @returns {AppendRowsResultIf | false} `{ added, shown, removed, following }`, or false
+     *
+     * @example
+     * // a log viewer: new lines every animation frame, at most one million
+     * const result = tableApi.appendRows(newLines, { follow: "auto", maxRows: 1_000_000 });
+     * if (result && !result.following) {
+     *   console.log(`+${result.shown} new lines below`);
+     * }
+     *
+     * @example
+     * // "Freeze scroll" / "Scroll to end" buttons of the app
+     * let frozen = false;
+     * function onLines(lines: { time: string; text: string }[]) {
+     *   tableApi.appendRows(lines, { follow: frozen ? false : "auto" });
+     * }
+     * function scrollToEnd() {
+     *   frozen = false;
+     *   tableApi.repaintHard({ py: Number.MAX_SAFE_INTEGER });
+     * }
+     *
+     * @since 1.1.108
+     */
+    appendRows<T>(rows: T[], options?: AppendRowsOptionsIf): AppendRowsResultIf | false;
+    /**
+     * **Live data with an own area model** (since 1.1.108): your model appended `count` rows at the end (and maybe
+     * removed `removedAtStart` rows at the start) – the table moves selection, focus and anchor along, keeps the first
+     * visible row or follows the end (`follow` as in {@link appendRows}) and renders once (not at all if only rows behind
+     * the visible ones came in). Filtering and sorting are up to your model.
+     *
+     * @param {number} count - rows appended at the end
+     * @param {RowsAppendedOptionsIf} [options] - `follow`, `removedAtStart`
+     * @returns {AppendRowsResultIf} `{ added, shown, removed, following }`
+     *
+     * @example
+     * class LogBody extends AreaModel {
+     *   readonly lines: string[] = [];
+     *   override getRowCount(): number { return this.lines.length; }
+     *   override getRowHeight(): number { return 20; }
+     *   override getConstantRowHeight(): number { return 20; }
+     *   override getValueAt(row: number): string { return this.lines[row]; }
+     * }
+     * const body = new LogBody();
+     *
+     * function onNewLines(newLines: string[]) {
+     *   for (const line of newLines) body.lines.push(line);      // a loop: push(...lines) overflows above ~100,000
+     *   const dropped = Math.max(0, body.lines.length - 1_000_000);
+     *   body.lines.splice(0, dropped);                            // the app's own ring buffer
+     *   tableApi.rowsAppended(newLines.length, { follow: "auto", removedAtStart: dropped });
+     * }
+     *
+     * @since 1.1.108
+     */
+    rowsAppended(count: number, options?: RowsAppendedOptionsIf): AppendRowsResultIf;
     addRows<T>(rows: T[]): void;
     /**
      * Inserts new rows at a specific position in the table body.
@@ -2325,7 +2420,7 @@ export declare class TableApi {
      * @example
      * ```typescript
      * // Get the first visible row index
-     * const tableApi = new TableApi(tableScope);
+     * const tableApi = tableScope.getApi();
      * const firstVisibleIndex = tableApi.getFirstVisibleRowIndex();
      *
      * // Use the index for scroll position calculations

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

@@ -2,6 +2,7 @@ import { TableOverlayChange } from './overlay/table-overlay.js';
 import { GeOverlayKind } from './overlay/ge-overlay-kind.type.js';
 import { TableModelIf } from './data/tablemodel/table-model.if.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
+import { SideIdent } from './data/side-ident.type.js';
 import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
 import { DomServiceIf } from './service/dom-service.if.js';
 import { TableOptionsIf } from './data/options/table-options.if.js';
@@ -50,6 +51,7 @@ import { ClipboardService } from './clipboard/clipboard-service.js';
 import { UndoOptionsIf } from './undo/undo-options.if.js';
 import { UndoService } from './undo/undo-service.js';
 import { ShortcutActionIdMapping } from './action/shortcut-actionid-mapping.type.js';
+import { AppendRowsOptionsIf, AppendRowsResultIf, RowsAppendedOptionsIf } from './live-append/append-rows-options.if.js';
 
 /**
  * Creates and runs one table in a host element – the core that every framework wrapper uses.
@@ -130,6 +132,8 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
     private firstDraggingRendering;
     /** Last comparator passed to `sort()`; re-applied after filtering. Cleared by a header sort. */
     private lastSortCompareFn?;
+    /** Live data: the content position held while the mouse button was down in a view that followed the end. */
+    private followHeldAt?;
     /** Excel-style editing (`tableOptions.editing`), `undefined` = off. @since 1.1.99 */
     private readonly editingOptions?;
     /** Listeners of {@link TableApi.subscribe}. @since 1.1.99 */
@@ -750,6 +754,22 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
      * @return {GeMouseEvent} - The created GeMouseEvent object.
      */
     createGeMouseEvent(mouseEvent: MouseEvent): GeMouseEvent;
+    /**
+     * Creates a GeMouseEvent for a given cell – used when the cell element of a mouse event is gone (a render replaced
+     * it between mousedown and mouseup, see {@link MouseHandler}) and the cell is known from the mousedown.
+     *
+     * @param mouseEvent - the original browser event
+     * @param cell - area, side, row and column of the cell, and the action of the pressed element
+     * @returns the event with row/column positions of the cell
+     * @since 1.1.108
+     */
+    createGeMouseEventForCell(mouseEvent: MouseEvent, cell: {
+        areaIdent?: AreaIdent;
+        sideIdent?: SideIdent;
+        rowIndex: number;
+        columnIndex: number;
+        action: string | null;
+    }): GeMouseEvent;
     /**
      * The element a mouse event belongs to – usually `evt.target`. The scroll viewport lies above the footer areas (its
      * horizontal scroll bar must stay usable), so a mouse event on a footer cell arrives at the viewport: then the footer
@@ -1039,6 +1059,37 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
     private setAreaVisible;
     autoResizeColumns(recalcWrappers?: boolean): void;
     recalcWrappers(): void;
+    /**
+     * Live data (since 1.1.108): appends rows to an {@link AreaModelObjectArray} body in place – filter and sort order
+     * only for the new rows, optional ring buffer – moves selection, focus and anchor along, keeps the first visible row
+     * or follows the end, and renders once (not at all if only rows behind the visible ones came in).
+     * See {@link TableApi.appendRows}.
+     *
+     * @param {T[]} rows - the new rows
+     * @param {AppendRowsOptionsIf} [options] - follow mode, ring buffer
+     * @returns {AppendRowsResultIf | false} what changed; false (with a warning) for other bodies (tree, row groups,
+     *   pivot, spreadsheet, cell formulas)
+     */
+    appendRows<T>(rows: T[], options?: AppendRowsOptionsIf): AppendRowsResultIf | false;
+    /**
+     * Live data (since 1.1.108): an own area model appended `count` rows at the end (and maybe removed some at the
+     * start) – moves selection, focus and anchor along, keeps the first visible row or follows the end, renders once.
+     * See {@link TableApi.rowsAppended}.
+     *
+     * @param {number} count - rows the model appended at the end (display order)
+     * @param {RowsAppendedOptionsIf} [options] - follow mode, rows removed at the start
+     * @returns {AppendRowsResultIf} what changed
+     */
+    notifyRowsAppended(count: number, options?: RowsAppendedOptionsIf): AppendRowsResultIf;
+    /** The order new rows are sorted in: the last `sort(fn)`, otherwise the columns with a sort state. */
+    protected getActiveSortComparator(): ((a: unknown, b: unknown) => number) | undefined;
+    /** Moves the index-based state along, chooses the position and renders once (or only updates the row count). */
+    private afterRowsAppended;
+    /**
+     * True if nothing else on the screen depends on the row count: no row number column (its width may grow), no
+     * totals footer, no calculated/„show values as“ columns, no open detail rows.
+     */
+    private canKeepDrawnRows;
     reSort(): void;
     sort(compareFn: (a: any, b: any) => number): void;
     /**