@testgorilla/tgo-ui 11.0.1 → 11.0.2

package/package.json

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

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

@@ -156,8 +156,23 @@ declare class InfiniteScrollTableComponent<T> {
      * the last — aligned between header and body regardless of browser/scrollbar behaviour.
      */
     protected readonly scrollbarWidth: _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`.
+     */
+    protected readonly hScrollbarHeight: _angular_core.WritableSignal<number>;
     /** Guards `loadMore` to a single emission per approach to the end. */
     private loadMoreArmed;
+    /** Pending frame for a deferred CDK viewport re-measure, so repeated triggers coalesce to one. */
+    private remeasureFrame;
+    /**
+     * 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.
+     */
+    private readonly usesScrollTimelineHeaderSync;
     protected readonly skeletonTheme: {
         background: string;
         'border-radius': string;
@@ -174,7 +189,12 @@ declare class InfiniteScrollTableComponent<T> {
     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). */
+    /**
+     * 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`.
+     */
     protected readonly viewportHeight: _angular_core.Signal<string>;
     /** Screen-reader announcement for the busy states. */
     protected readonly statusMessage: _angular_core.Signal<"Loading" | "Loading more rows" | "">;
@@ -183,11 +203,13 @@ declare class InfiniteScrollTableComponent<T> {
     constructor();
     protected getCellValue(item: T, key: string): unknown;
     /**
-     * Content-independent flex-basis for a column: its declared width, else its min-width, else the
-     * default. Using this (instead of `flex-basis: auto`) makes header and body cells size identically
-     * so every column stays aligned regardless of the text inside header vs body cells.
+     * 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.
      */
-    protected cellBasis(column: InfiniteScrollTableColumn<T>): string;
+    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
@@ -203,6 +225,14 @@ declare class InfiniteScrollTableComponent<T> {
     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;
+    /**
+     * 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.
+     */
+    private scheduleViewportRemeasure;
+    private updateHeaderScrollMetric;
     private onRetry;
     /** Keep the header horizontally aligned with the body and update the sticky-shadow state. */
     private syncHorizontalScroll;