@testgorilla/tgo-ui 11.2.2 → 11.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testgorilla/tgo-ui",
-  "version": "11.2.2",
+  "version": "11.3.0",
   "license": "proprietary-license",
   "lint-staged": {
     "{projects,components}/**/*.ts": [

package/types/testgorilla-tgo-ui-components-infinite-scroll-table.d.ts

@@ -5,62 +5,63 @@ import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
 import * as i1 from '@angular/common';
 
 /**
- * Column definition for the infinite-scroll table.
- *
- * The shape intentionally mirrors the existing `ui-table` `TableColumn` (the fields that carry
- * over to a virtualized body) so consumers can migrate their column configs and cell templates
- * with a selector swap. Types have no runtime footprint, so this is a deliberate duplication
- * rather than a shared import — it keeps the new component fully independent of `ui-table`.
+ * The structural contract `selectable` puts on a row: the checkbox reflects `selected`, and `key` /
+ * `rowIdKey` lookups read arbitrary fields. Declared once here rather than asserted at each read site, so
+ * the requirement is discoverable from the types instead of only from the docs.
  */
-interface InfiniteScrollTableColumn<T = any> {
-    /** Stable identifier for the column; also used to read the default cell value from a row. */
+type InfiniteScrollTableRowLike = Record<string, unknown> & {
+    selected?: boolean;
+};
+interface InfiniteScrollTableColumn<T> {
+    /** Also reads the default cell value. A plain string, so a synthetic column can have no matching field. */
     key: string;
     /** Header label rendered when no `headerCellTemplate` is provided. */
     title?: string;
+    headerCellTemplate?: TemplateRef<InfiniteScrollTableHeaderCellContext<T>>;
+    rowCellTemplate?: TemplateRef<InfiniteScrollTableRowCellContext<T>>;
     /**
-     * Consumer-supplied header cell template.
-     * Context: `{ $implicit: column.title, column, colIndex }` — matches `ui-table`.
-     */
-    headerCellTemplate?: TemplateRef<unknown>;
-    /**
-     * Consumer-supplied row cell template.
-     * Context: `{ $implicit: element, rowIndex }` — matches `ui-table`.
+     * Pins the column. Only honoured on the **first** column (pins left) and the **last** column (pins
+     * right); anywhere else it is ignored, with a dev-mode warning.
      */
-    rowCellTemplate?: TemplateRef<unknown>;
-    /** When set, the first sticky column pins to the left and the last sticky column pins to the right. */
     isSticky?: boolean;
     styles?: InfiniteScrollTableColumnStyles;
 }
 interface InfiniteScrollTableColumnStyles {
-    'min-width'?: string;
+    /**
+     * Authoritative column width (default `160px`), applied as `flex-basis`, `min-width` AND `max-width`:
+     * the column never grows or shrinks and overflowing content is clipped, which is what keeps the header
+     * and body scroll containers pixel-aligned. Leftover row width goes to a trailing spacer instead.
+     */
     width?: string;
     alignment?: InfiniteScrollTableColumnAlignment;
 }
 type InfiniteScrollTableColumnAlignment = 'left' | 'right' | 'center';
-/** Context object passed to the error template so it can trigger a retry. */
+interface InfiniteScrollTableRowCellContext<T> {
+    $implicit: T;
+    rowIndex: number;
+}
+interface InfiniteScrollTableHeaderCellContext<T> {
+    $implicit: string | undefined;
+    column: InfiniteScrollTableColumn<T>;
+    colIndex: number;
+}
 interface InfiniteScrollTableErrorContext {
     $implicit: () => void;
     retry: () => void;
 }
 /**
- * Payload emitted on `rowClick`: the row plus its data index.
- *
- * Note: this is a **shallow copy** (`{ ...row, index }`, matching `ui-table`), so a class instance's
- * prototype is not preserved and any pre-existing `index` field on the row is overwritten.
+ * `row` is the consumer's own object by reference — not a copy — so class prototypes survive and a row's
+ * own `index` field is never shadowed. Same for `InfiniteScrollTableRowSelection`.
  */
-type InfiniteScrollTableRowClick<T> = T & {
+interface InfiniteScrollTableRowClick<T> {
+    row: T;
     index: number;
-};
-/**
- * Payload emitted on `selectionChange`: the row, its data index, and the new selected state.
- *
- * As with `rowClick`, this is a **shallow copy** (`{ ...row, index, selected }`) — no prototype, and
- * any pre-existing `index` / `selected` field on the row is overwritten.
- */
-type InfiniteScrollTableRowSelection<T> = T & {
+}
+interface InfiniteScrollTableRowSelection<T> {
+    row: T;
     index: number;
     selected: boolean;
-};
+}
 
 /** Internal row wrapper so real rows and skeleton placeholders flow through one virtual list. */
 type RenderRow<T> = {
@@ -72,177 +73,248 @@ type RenderRow<T> = {
     id: string;
 };
 /**
- * A generic, virtualized table with scroll-driven infinite loading.
- *
- * Owns rendering, fixed-height vertical virtualization (CDK), horizontal scroll, a pinned header,
- * sticky first/last columns, first-load and load-more skeletons, and a guarded `loadMore` event.
- * All content and layout come from consumer inputs — nothing domain-specific lives here.
- *
- * Independent of `ui-table`: it reuses only stable leaf primitives (`ui-skeleton`) and duplicates
- * the column/context type shapes so consumers can migrate with a selector swap.
+ * A generic, virtualized table with scroll-driven infinite loading. Independent of `ui-table`: it reuses
+ * only stable leaf primitives (`ui-skeleton`) and duplicates the column/context type shapes so consumers
+ * can migrate with a selector swap.
  */
 declare class InfiniteScrollTableComponent<T> {
-    /** Rows loaded so far. The consumer appends pages to this array. */
-    readonly data: _angular_core.InputSignal<T[]>;
-    /** Column definitions. The first `isSticky` column pins left; the last `isSticky` column pins right. */
-    readonly columns: _angular_core.InputSignal<InfiniteScrollTableColumn<T>[]>;
     /**
-     * Fixed row height in px — used as the virtualization `itemSize`.
-     * Variable / multi-line row heights are unsupported in this variant.
+     * Rows loaded so far. **Must change by reference** (`[...rows, ...page]`): a signal input cannot observe
+     * `rows.push(...)`, so an in-place append renders nothing and leaves `loadMore` disarmed.
      */
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    readonly columns: _angular_core.InputSignal<InfiniteScrollTableColumn<T>[]>;
+    /** Fixed row height in px (the virtualization `itemSize`). Variable row heights are unsupported. */
     readonly rowHeight: _angular_core.InputSignal<number>;
-    /** Optional stable row identity so recycled rows re-render correctly. Takes precedence over `rowIdKey`. */
+    /** Stable row identity so recycled rows re-render correctly. Takes precedence over `rowIdKey`. */
     readonly trackBy: _angular_core.InputSignal<TrackByFunction<T> | undefined>;
-    /** Optional key on each row that holds a stable id. Used when `trackBy` is not provided. */
+    /** Key on each row holding a stable id. Used when `trackBy` is not provided. */
     readonly rowIdKey: _angular_core.InputSignal<string | undefined>;
     /**
-     * Accepted for API parity with `ui-table`. In this bounded layout the header is always rendered
-     * above the internal scroll region and stays visible regardless — `.ui-ist` has `overflow: hidden`,
-     * so the header cannot stick to an outer scrolling page. Kept so `ui-table` templates migrate
-     * unchanged. Default `true`.
+     * CDK's rendered buffers. Both default to a multiple of `rowHeight` (~5 and ~10 rows) rather than a
+     * fixed px value, which would mean a different row count at every `rowHeight`.
      */
-    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minBufferPx: _angular_core.InputSignal<number | undefined>;
+    readonly maxBufferPx: _angular_core.InputSignal<number | undefined>;
     /** Max height of the internal scroll region (e.g. `'70vh'`). The body shrinks to fit fewer rows. */
     readonly maxHeight: _angular_core.InputSignal<string>;
-    /** Condensed spacing. */
+    /** Stretch to the parent's height instead of the content's; `maxHeight` becomes a cap, not the target. */
+    readonly fillHeight: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly isCondensed: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * Enables row selection. When `true`, a dedicated checkbox column is prepended (pinned to the left)
-     * and each row's checkbox reflects the row's `selected` property; toggling it emits `selectionChange`.
-     * Selection stays data-driven and consumer-managed, exactly like `ui-table`. Default `false`.
+     * Prepends a left-pinned checkbox column driven by each row's `selected` property. Consumer-managed
+     * (like `ui-table`): toggling only emits `selectionChange`.
      */
     readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Makes rows focusable and activatable by click or Enter/Space. Off by default: a read-only table
+     * must not create a tab stop per rendered row or imply interactivity it does not have.
+     */
+    readonly rowsClickable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** First-load state: renders a full body of skeleton rows. */
     readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Appends skeleton rows below the existing rows while the next page is fetched. */
     readonly loadingMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Whether more pages exist. When `false`, `loadMore` never fires and the load-more skeleton is hidden. */
+    /** Required, not defaulted: a silent "never load" default would disable the headline behaviour. */
     readonly hasMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Number of skeleton rows for the first-load state. */
     readonly skeletonRowCount: _angular_core.InputSignal<number>;
-    /** How many rows from the end trigger `loadMore`. */
+    /** Number of skeleton rows appended below the loaded rows while `loadingMore` is true. */
+    readonly loadMoreSkeletonCount: _angular_core.InputSignal<number>;
+    /**
+     * Skeleton placeholder columns for a lazily-loaded column set. They deliberately sit OUTSIDE `columns`,
+     * so they cannot change which column is last and unpin a sticky last column.
+     */
+    readonly loadingColumnCount: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly loadMoreThreshold: _angular_core.InputSignal<number>;
-    /** Empty-state template, shown when `data` is empty and not loading. */
+    /** Shown when `data` is empty and not loading. */
     readonly noDataTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
-    /** Error template, shown when `error` is `true`. Receives `{ $implicit: retry, retry }` as context. */
+    /** Shown when `error` is `true`. Receives `{ $implicit: retry, retry }` as context. */
     readonly errorTemplate: _angular_core.InputSignal<TemplateRef<InfiniteScrollTableErrorContext> | undefined>;
-    /** Whether a page fetch failed. */
     readonly error: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * Fires when the user scrolls within `loadMoreThreshold` rows of the end.
-     * Guarded: emits only when `hasMore && !loading && !loadingMore`, and only once per approach.
+     * Shown once `hasMore` goes `false` with rows loaded. Deliberately has NO built-in fallback (unlike
+     * `noDataTemplate` / `errorTemplate`): a single-page list would otherwise flash "no more results".
      */
+    readonly endOfListTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    /** Guarded: only when `hasMore && !loading && !loadingMore`, and only once per approach to the end. */
     readonly loadMore: _angular_core.OutputEmitterRef<void>;
-    /** Fires from the error template's retry affordance. */
     readonly retry: _angular_core.OutputEmitterRef<void>;
-    /** Fires when a data row is clicked; payload is the row plus its data index. */
     readonly rowClick: _angular_core.OutputEmitterRef<InfiniteScrollTableRowClick<T>>;
-    /**
-     * Fires when a row's selection checkbox is toggled (only when `selectable`). Payload is the row,
-     * its data index, and the new selected state. The consumer updates its data's `selected` property.
-     */
+    /** The consumer is expected to apply `selected` back onto its own data. */
     readonly selectionChange: _angular_core.OutputEmitterRef<InfiniteScrollTableRowSelection<T>>;
-    /** Fixed width of the checkbox column; exposed so the template can offset a sticky first column. */
-    protected readonly checkboxColumnWidth = 56;
     protected readonly viewport: _angular_core.Signal<CdkVirtualScrollViewport | undefined>;
     protected readonly headerScroll: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
-    /** Horizontal-scroll state, mirroring the existing table's `scrollSettings`. */
     protected readonly scrollStart: _angular_core.WritableSignal<boolean>;
     protected readonly scrollEnd: _angular_core.WritableSignal<boolean>;
     protected readonly horizontalScroll: _angular_core.WritableSignal<boolean>;
-    /**
-     * Measured width (px) of the body viewport's vertical scrollbar. Reserved as right padding on the
-     * header so the header's content width exactly equals the body's, keeping every column — including
-     * the last — aligned between header and body regardless of browser/scrollbar behaviour.
-     */
+    /** Reserved as right padding on the header, so its content width exactly equals the body's. */
     protected readonly scrollbarWidth: _angular_core.WritableSignal<number>;
+    /** Added to the viewport height so on a short list the scrollbar doesn't eat into the rows. */
+    protected readonly hScrollbarHeight: _angular_core.WritableSignal<number>;
     /**
-     * Measured height (px) of the body viewport's horizontal scrollbar. When a short list also has a
-     * horizontal scrollbar, this is added to the viewport height so the scrollbar doesn't eat into the
-     * rows' vertical space and force a spurious vertical scrollbar. Mirrors `scrollbarWidth`.
+     * Paging latch. Three fields, one rule: `loadMore` emits at most once per page that lands while the
+     * user is inside the trigger zone. `isLoadMoreArmed` is the latch itself, written here and by
+     * `checkLoadMore`; `dataLengthAtEmit` records how long `data` was when the last emission went out, so
+     * "the requested page arrived" is a length comparison rather than a guess about scroll positions;
+     * `firstVisibleIndex` is where the user actually is.
+     *
+     * The invariant that matters: arming and firing must read the SAME trigger zone. They used to derive it
+     * from two different thresholds, which opened bands the latch could never leave.
      */
-    protected readonly hScrollbarHeight: _angular_core.WritableSignal<number>;
-    /** Guards `loadMore` to a single emission per approach to the end. */
-    private loadMoreArmed;
+    private isLoadMoreArmed;
+    private dataLengthAtEmit;
+    /** In-place-mutation detector; see the effect that reads these for the discriminator. */
+    private wasLoadingMore;
+    private lastDataReference;
+    private lastDataLength;
     /** Pending frame for a deferred CDK viewport re-measure, so repeated triggers coalesce to one. */
     private remeasureFrame;
+    /** Pending frame for the deferred scroll reset. Cancelled on destroy, like every other frame here. */
+    private resetScrollFrame;
+    private previousHeadIdentity;
+    /** Latches once any non-empty `data` is seen, so only the very first render is exempt from resetting. */
+    private hasSeenHead;
+    /** Previous `loading` value, for spotting the false -> true edge that starts a reset. */
+    private wasLoading;
     /**
-     * True when the browser can drive the header via a CSS scroll timeline (see the SCSS): the header
-     * then tracks the body's horizontal scroll on the compositor, with no per-frame main-thread work.
-     * In that case the JS `scrollLeft` sync is skipped so the offset isn't applied twice; it stays as
-     * the fallback for browsers without scroll-driven animations.
+     * First visible row index, kept current from `viewport.scrolledIndexChange` (no layout read) rather
+     * than `viewport.getRenderedRange().start`, which includes CDK's read-ahead buffer.
      */
-    private readonly usesScrollTimelineHeaderSync;
+    private firstVisibleIndex;
     protected readonly skeletonTheme: {
         background: string;
         'border-radius': string;
         height: string;
         'margin-bottom': string;
     };
-    protected readonly lastStickyKey: _angular_core.Signal<string | undefined>;
-    protected readonly firstStickyKey: _angular_core.Signal<string | undefined>;
-    /** Real rows, with skeleton placeholders in first-load / load-more states, as one virtual list. */
+    protected readonly stickyStartKey: _angular_core.Signal<string | undefined>;
+    protected readonly stickyEndKey: _angular_core.Signal<string | undefined>;
+    protected readonly defaultColumnWidth = "160px";
+    protected readonly effectiveMinBufferPx: _angular_core.Signal<number>;
+    /**
+     * The `Math.max` is load-bearing: CDK throws in dev mode when `maxBufferPx < minBufferPx`, which a
+     * consumer triggers just by raising `minBufferPx` above the derived default.
+     */
+    protected readonly effectiveMaxBufferPx: _angular_core.Signal<number>;
+    /** Stable keys for the placeholder columns, so `@for` can track them across renders. */
+    protected readonly loadingColumns: _angular_core.Signal<string[]>;
     protected readonly renderRows: _angular_core.Signal<RenderRow<T>[]>;
     protected readonly hasData: _angular_core.Signal<boolean>;
-    /** The virtualized body is shown for the first-load skeletons and whenever there are rows. */
     protected readonly showViewport: _angular_core.Signal<boolean>;
+    /**
+     * `loadingMore` counts as loading here too: a consumer that retries a failed first page through the same
+     * flag it uses for every page would otherwise render "no rows" with `aria-busy` set and the live region
+     * announcing a fetch.
+     */
     protected readonly showEmptyState: _angular_core.Signal<boolean>;
     protected readonly showErrorState: _angular_core.Signal<boolean>;
     protected readonly showErrorFooter: _angular_core.Signal<boolean>;
     /**
-     * Viewport height shrinks to the content and is capped at `maxHeight` (CSS `min()` mixes units).
-     * When a horizontal scrollbar is present it reserves that scrollbar's measured height on top of the
-     * content, so a short list doesn't overflow and grow a spurious vertical scrollbar. Still capped at
-     * `maxHeight`.
+     * The negative clauses keep this out of slots other states own, and `!loadingMore()` closes a one-tick
+     * flash: a fetch completing and the consumer flipping `hasMore` need not land in the same cycle.
+     */
+    protected readonly showEndOfList: _angular_core.Signal<boolean>;
+    /**
+     * CSS `min()` because the cap mixes units. The scrollbar reserve stops a short list from growing a
+     * spurious vertical scrollbar; fill mode returns `null` so flex owns the sizing and the reserve is moot.
      */
-    protected readonly viewportHeight: _angular_core.Signal<string>;
-    /** Screen-reader announcement for the busy states. */
-    protected readonly statusMessage: _angular_core.Signal<"Loading" | "Loading more rows" | "">;
+    protected readonly viewportHeight: _angular_core.Signal<string | null>;
+    protected readonly translationContext = "INFINITE_SCROLL_TABLE.";
+    /** A translation key, resolved in the template: screen-reader users are not all English speakers. */
+    protected readonly statusMessageKey: _angular_core.Signal<string>;
     protected readonly errorContext: InfiniteScrollTableErrorContext;
     protected readonly renderRowTrackBy: TrackByFunction<RenderRow<T>>;
     constructor();
-    protected getCellValue(item: T, key: string): unknown;
+    private cancelResetScrollFrame;
+    /** No-ops only when no rows are rendered: the empty state, or an error with no rows. */
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    scrollToTop(behavior?: ScrollBehavior): void;
     /**
-     * The single authoritative width for a column: its declared width, else its min-width, else the
-     * default. The template applies this identically as `flex-basis`, `min-width` AND `max-width` (with
-     * `flex-grow:0; flex-shrink:0; overflow:hidden`) to the header cell and every body cell, so a column
-     * is exactly this width in both containers — content is clipped and can never widen it. This is what
-     * keeps header and body columns aligned end-to-end regardless of cell content or horizontal scroll.
+     * The single place `T` is widened to its structural contract. Every field read on a row goes through
+     * here, so the assertion exists once instead of at each call site.
      */
+    private asRowLike;
+    protected getCellValue(item: T, key: string): unknown;
+    /** Applied as `flex-basis`, `min-width` AND `max-width` on header and body cells alike — see the SCSS. */
     protected columnWidth(column: InfiniteScrollTableColumn<T>): string;
-    protected onRowClick(row: RenderRow<T>): void;
-    /**
-     * Whether a row should show the selected highlight. Mirrors `ui-table`: only when `selectable` is
-     * enabled and the row's data carries a truthy `selected` property. Skeleton rows are never selected.
-     */
+    protected emitRowClick(event: Event, row: RenderRow<T>): void;
     protected isRowSelected(row: RenderRow<T>): boolean;
-    /** Emits the new selection state when a row's checkbox is toggled. Consumer-managed, like `ui-table`. */
-    protected onSelectionToggle(row: RenderRow<T>, selected: boolean): void;
+    protected emitSelectionChange(row: RenderRow<T>, selected: boolean): void;
+    /** Reads `--ui-ist-checkbox-width` so the offset cannot drift from the checkbox column's own width. */
+    protected stickyStartLeft(column: InfiniteScrollTableColumn<T>): string | null;
     /**
-     * Left offset (px) for a sticky-start consumer column: when the checkbox column is present it must
-     * sit to the right of it, so the first sticky column is pushed over by the checkbox column width.
+     * Only the outermost start-pinned cell may cast the sticky shadow: the checkbox cell is pinned too, and
+     * shadowing both would drop a shadow across the column beside it.
      */
-    protected stickyStartOffset(column: InfiniteScrollTableColumn<T>): number | null;
-    /** Keyboard equivalent of a row click (Enter/Space) for the currently focused data row. */
-    protected onRowActivate(event: Event, row: RenderRow<T>): void;
+    protected isStickyStartEdge(column: InfiniteScrollTableColumn<T>): boolean;
+    protected activateRow(event: Event, row: RenderRow<T>): void;
+    /** A clickable row matches `[tabindex]` itself, so `currentTarget` must be excluded explicitly. */
+    private isInteractiveTarget;
+    /** Whether the user is selecting text, in which case a click is a selection gesture, not activation. */
+    private hasTextSelection;
     /**
-     * Re-measure the CDK virtual viewport after its box may have changed. Deferred to the next frame so
-     * it reads the settled layout and never fires a "ResizeObserver loop limit exceeded" warning when
-     * driven from the ResizeObserver; repeated triggers coalesce to a single measure. The re-measure is
-     * what makes CDK recompute the rendered range to fill a viewport whose height grew at runtime.
+     * Deferred a frame to read the settled layout and never trip "ResizeObserver loop limit exceeded";
+     * repeated triggers coalesce to one measure.
      */
     private scheduleViewportRemeasure;
-    private updateHeaderScrollMetric;
-    private onRetry;
-    /** Keep the header horizontally aligned with the body and update the sticky-shadow state. */
+    /**
+     * The third `checkLoadMore` trigger, and the only one that survives a page landing without a rendered-range
+     * change. CDK emits a range only when the virtual-for LENGTH changes, so a page whose row count exactly
+     * replaces the load-more skeletons (`data + skeletons` before, `data` after) moves nothing CDK watches —
+     * and when the new rows add no scrollable height, no scroll event can ever arrive either. Runs after the
+     * re-measure so the zone is tested against the size CDK just settled on.
+     */
+    private settleLoadMore;
+    private emitRetry;
+    /**
+     * The index fallback is identity-in-name-only — it cannot tell rows apart after a reorder — which is why
+     * the automatic scroll reset cannot work without `trackBy` or `rowIdKey`.
+     */
+    private rowIdentity;
+    /**
+     * Assigning an absolute `scrollLeft` is drift-free by construction: it self-corrects every scroll event
+     * and the browser clamps when the header's maximum is momentarily smaller. A progress-normalized CSS
+     * scroll-timeline cannot guarantee that, which is why it was removed — do not reintroduce one.
+     */
     private syncHorizontalScroll;
     /**
-     * Emits `loadMore` once when the rendered range reaches the trigger zone near the end,
-     * re-arming when the user scrolls back out. Mirrors the app's `ngx-infinite-scroll` semantics.
+     * How many rows the viewport shows. Zero until CDK has measured, which callers must treat as
+     * "unknown" rather than "none".
+     */
+    private visibleRowCount;
+    /**
+     * Rows from the end that count as "approaching it". Capped at a screenful: a threshold wider than the
+     * viewport cannot mean approaching, and uncapped it made the zone unleavable at every scroll position,
+     * which is how an oversized `loadMoreThreshold` used to walk a whole dataset unattended. Clamped at 0 so
+     * a negative value can't push the trigger point past the end and disable paging outright.
+     */
+    private triggerZoneRows;
+    /**
+     * The rendered range includes CDK's read-ahead buffer, so measuring it conflates the user reaching the
+     * end with CDK merely pre-rendering it. The visible end has no such slack, so it tracks the user's
+     * actual scroll position instead.
+     */
+    private isInTriggerZone;
+    /**
+     * Re-arms the latch when something other than scrolling has to do it. Two cases, both of which used to
+     * be terminal stalls:
+     *
+     * - **The requested page landed.** `data` grew past its length at the last emission, so that emission is
+     *   spent. Without this, re-arming needed the user to scroll *out* of the zone and back — impossible when
+     *   the page was smaller than the threshold, and impossible to even attempt when the new rows added no
+     *   scrollable height.
+     * - **The zone can't be left.** `visibleEnd` bottoms out at `visibleRows`, so while that floor sits
+     *   inside the zone no amount of scrolling re-arms anything. Also covers a not-yet-measured viewport,
+     *   which must count as unleavable or the first fill never starts.
+     *
+     * Deliberately not driven by `loadingMore` or `error`: a failed fetch clears `loadingMore` without
+     * growing `data`, and must stay disarmed rather than re-fire in a loop.
      */
+    private rearmLoadMoreIfUnreachable;
+    /** Emits at most once per page that lands while the user is inside the trigger zone. */
     private checkLoadMore;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfiniteScrollTableComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfiniteScrollTableComponent<any>, "ui-infinite-scroll-table", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "rowIdKey": { "alias": "rowIdKey"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "isCondensed": { "alias": "isCondensed"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMore": { "alias": "loadingMore"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "skeletonRowCount": { "alias": "skeletonRowCount"; "required": false; "isSignal": true; }; "loadMoreThreshold": { "alias": "loadMoreThreshold"; "required": false; "isSignal": true; }; "noDataTemplate": { "alias": "noDataTemplate"; "required": false; "isSignal": true; }; "errorTemplate": { "alias": "errorTemplate"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; "retry": "retry"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfiniteScrollTableComponent<any>, "ui-infinite-scroll-table", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "rowIdKey": { "alias": "rowIdKey"; "required": false; "isSignal": true; }; "minBufferPx": { "alias": "minBufferPx"; "required": false; "isSignal": true; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "fillHeight": { "alias": "fillHeight"; "required": false; "isSignal": true; }; "isCondensed": { "alias": "isCondensed"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "rowsClickable": { "alias": "rowsClickable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMore": { "alias": "loadingMore"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": true; "isSignal": true; }; "skeletonRowCount": { "alias": "skeletonRowCount"; "required": false; "isSignal": true; }; "loadMoreSkeletonCount": { "alias": "loadMoreSkeletonCount"; "required": false; "isSignal": true; }; "loadingColumnCount": { "alias": "loadingColumnCount"; "required": false; "isSignal": true; }; "loadMoreThreshold": { "alias": "loadMoreThreshold"; "required": false; "isSignal": true; }; "noDataTemplate": { "alias": "noDataTemplate"; "required": false; "isSignal": true; }; "errorTemplate": { "alias": "errorTemplate"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "endOfListTemplate": { "alias": "endOfListTemplate"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; "retry": "retry"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; }, never, never, true, never>;
 }
 
 declare class InfiniteScrollTableComponentModule {
@@ -252,4 +324,4 @@ declare class InfiniteScrollTableComponentModule {
 }
 
 export { InfiniteScrollTableComponent, InfiniteScrollTableComponentModule };
-export type { InfiniteScrollTableColumn, InfiniteScrollTableColumnAlignment, InfiniteScrollTableColumnStyles, InfiniteScrollTableErrorContext, InfiniteScrollTableRowClick, InfiniteScrollTableRowSelection };
+export type { InfiniteScrollTableColumn, InfiniteScrollTableColumnAlignment, InfiniteScrollTableColumnStyles, InfiniteScrollTableErrorContext, InfiniteScrollTableHeaderCellContext, InfiniteScrollTableRowCellContext, InfiniteScrollTableRowClick, InfiniteScrollTableRowLike, InfiniteScrollTableRowSelection };