@rickcedwhat/playwright-smart-table 6.20.1 → 6.21.0

package/dist/strategies/contentReady.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentReadyStrategies = void 0;
+exports.ContentReadyStrategies = {
+    /**
+     * Polls the row's text content until two consecutive reads match.
+     */
+    textStable: (options = {}) => {
+        var _a, _b;
+        const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 500;
+        const interval = (_b = options.interval) !== null && _b !== void 0 ? _b : 50;
+        return async (row, page) => {
+            const deadline = Date.now() + timeout;
+            const remaining = () => Math.max(0, deadline - Date.now());
+            let prev = await row.innerText({ timeout: remaining() || timeout });
+            while (remaining() > 0) {
+                await page.waitForTimeout(Math.min(interval, remaining()));
+                if (remaining() <= 0)
+                    break;
+                const cur = await row.innerText({ timeout: remaining() });
+                if (cur === prev)
+                    return;
+                prev = cur;
+            }
+        };
+    },
+    /**
+     * Uses MutationObserver to wait for DOM mutations on the row's subtree
+     * to settle. Resolves when no mutations occur for `quietPeriod` ms, or
+     * when `timeout` expires.
+     */
+    mutationSettled: (options = {}) => {
+        var _a, _b;
+        const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 500;
+        const quietPeriod = (_b = options.quietPeriod) !== null && _b !== void 0 ? _b : 100;
+        return async (row) => {
+            await row.evaluate((el, opts) => {
+                return new Promise((resolve) => {
+                    let quietTimer;
+                    let deadlineTimer;
+                    const done = () => {
+                        clearTimeout(quietTimer);
+                        clearTimeout(deadlineTimer);
+                        observer.disconnect();
+                        resolve();
+                    };
+                    const observer = new MutationObserver(() => {
+                        clearTimeout(quietTimer);
+                        quietTimer = setTimeout(done, opts.quietPeriod);
+                    });
+                    observer.observe(el, {
+                        childList: true,
+                        subtree: true,
+                        characterData: true,
+                    });
+                    quietTimer = setTimeout(done, opts.quietPeriod);
+                    deadlineTimer = setTimeout(done, opts.timeout);
+                });
+            }, { timeout, quietPeriod });
+        };
+    },
+};

package/dist/strategies/filter.d.ts

@@ -2,12 +2,8 @@ import type { FilterStrategy } from '../types';
 /**
  * Example filter strategies.
  * - default: small convenience wrapper that mirrors the engine's default behavior.
- * - spy(factory): returns a strategy that marks `calledRef.called = true` when invoked.
  */
 export declare const FilterStrategies: {
     default: FilterStrategy;
-    spy: (calledRef?: {
-        called?: boolean;
-    }) => FilterStrategy;
 };
 export type { FilterStrategy } from '../types';

package/dist/strategies/filter.js

@@ -4,7 +4,6 @@ exports.FilterStrategies = void 0;
 /**
  * Example filter strategies.
  * - default: small convenience wrapper that mirrors the engine's default behavior.
- * - spy(factory): returns a strategy that marks `calledRef.called = true` when invoked.
  */
 exports.FilterStrategies = {
     default: {
@@ -20,19 +19,4 @@ exports.FilterStrategies = {
             return rows.filter({ has: targetCell.getByText(textVal, { exact: true }) });
         }
     },
-    spy: (calledRef = {}) => ({
-        apply({ rows, filter, colIndex, tableContext }) {
-            calledRef.called = true;
-            // Delegate to default behaviour for actual filtering
-            const page = tableContext.page;
-            const resolve = tableContext.resolve;
-            const cellTemplate = resolve(tableContext.config.cellSelector, page);
-            const targetCell = cellTemplate.nth(colIndex);
-            if (typeof filter.value === 'function') {
-                return rows.filter({ has: filter.value(targetCell) });
-            }
-            const textVal = typeof filter.value === 'number' ? String(filter.value) : filter.value;
-            return rows.filter({ has: targetCell.getByText(textVal, { exact: true }) });
-        }
-    }),
 };

package/dist/strategies/headers.d.ts

@@ -13,6 +13,11 @@ export declare const HeaderStrategies: {
     /**
      * Physically scrolls the table horizontally to force virtualized columns to mount,
      * collecting their names along the way.
+     *
+     * **Requires `selector`** — the CSS selector for the horizontal scroll container
+     * (e.g. `.dvn-scroller` for Glide, `.rdg-viewport` for RDG). Framework class names
+     * belong in presets / your config, not in this generic factory. Without `selector`,
+     * only currently visible headers are returned (no scrolling).
      */
     horizontalScroll: (options?: {
         limit?: number;

package/dist/strategies/headers.js

@@ -22,6 +22,11 @@ exports.HeaderStrategies = {
     /**
      * Physically scrolls the table horizontally to force virtualized columns to mount,
      * collecting their names along the way.
+     *
+     * **Requires `selector`** — the CSS selector for the horizontal scroll container
+     * (e.g. `.dvn-scroller` for Glide, `.rdg-viewport` for RDG). Framework class names
+     * belong in presets / your config, not in this generic factory. Without `selector`,
+     * only currently visible headers are returned (no scrolling).
      */
     horizontalScroll: (options) => {
         return async (context) => {
@@ -37,19 +42,22 @@ exports.HeaderStrategies = {
             };
             let currentHeaders = await getVisible();
             currentHeaders.forEach(h => collectedHeaders.add(h));
-            const scrollerHandle = await root.evaluateHandle((el, selector) => {
-                if (selector && el.matches(selector))
+            const selector = options === null || options === void 0 ? void 0 : options.selector;
+            if (!selector) {
+                (0, debugUtils_1.logDebug)(config, 'info', 'HeaderStrategies.horizontalScroll: no selector provided — returning visible headers only. Pass { selector } for the scroll container (e.g. ".dvn-scroller").');
+                return Array.from(collectedHeaders);
+            }
+            const scrollerHandle = await root.evaluateHandle((el, sel) => {
+                if (el.matches(sel))
                     return el;
-                // Try finding common scrollable containers or fallback to root
-                const effectiveSelector = selector || '.dvn-scroller, .rdg-viewport, [role="grid"]';
-                const ancestor = el.closest(effectiveSelector);
+                const ancestor = el.closest(sel);
                 if (ancestor)
                     return ancestor;
-                const child = el.querySelector(effectiveSelector);
+                const child = el.querySelector(sel);
                 if (child)
                     return child;
-                return el;
-            }, options === null || options === void 0 ? void 0 : options.selector);
+                return null;
+            }, selector);
             const isScrollerFound = await scrollerHandle.evaluate(el => !!el);
             if (isScrollerFound) {
                 await scrollerHandle.evaluate(el => el.scrollLeft = 0);
@@ -71,7 +79,7 @@ exports.HeaderStrategies = {
                 }
             }
             else {
-                (0, debugUtils_1.logDebug)(config, 'info', "HeaderStrategies.horizontalScroll: Could not find scroller. Returning visible headers.");
+                (0, debugUtils_1.logDebug)(config, 'info', `HeaderStrategies.horizontalScroll: Could not find scroller matching "${selector}". Returning visible headers.`);
             }
             if (isScrollerFound) {
                 await scrollerHandle.evaluate(el => el.scrollLeft = 0);

package/dist/strategies/index.d.ts

@@ -3,12 +3,19 @@ export * from './sorting';
 export * from './columns';
 export * from './headers';
 export * from './fill';
-export * from './resolution';
+export type { ColumnResolutionStrategy } from './resolution';
 export * from './dedupe';
 export * from './loading';
 export * from './stabilization';
 export * from './filter';
 export * from './viewport';
+export * from './contentReady';
+/**
+ * Built-in strategy factories.
+ * @note `CellNavigation` / `Resolution` removed from this namespace in #428 (dead/no-op).
+ * Use `strategies.navigation` (NavigationPrimitives) and header maps instead.
+ * `Filter.spy` was test-only and is no longer shipped.
+ */
 export declare const Strategies: {
     Pagination: {
         click: (selectors: {
@@ -26,21 +33,18 @@ export declare const Strategies: {
             detectCurrentPage?: (root: import("@playwright/test").Locator) => number | Promise<number>;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
-        }) => import("../types").PaginationStrategy;
+        }) => import("..").PaginationStrategy;
         infiniteScroll: (options?: {
             action?: "scroll" | "js-scroll";
             scrollTarget?: import("..").Selector;
             scrollAmount?: number;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
-        }) => import("../types").PaginationStrategy;
+        }) => import("..").PaginationStrategy;
     };
     Sorting: {
         AriaSort: () => import("..").SortingStrategy;
     };
-    CellNavigation: {
-        default: () => Promise<void>;
-    };
     Header: {
         visible: ({ config, resolve, root }: import("..").StrategyContext) => Promise<string[]>;
         horizontalScroll: (options?: {
@@ -50,13 +54,10 @@ export declare const Strategies: {
         }) => import("./headers").HeaderStrategy;
     };
     Fill: {
-        default: ({ row, columnName, value, fillOptions, config, table }: Parameters<import("../types").FillStrategy>[0]) => Promise<void>;
-    };
-    Resolution: {
-        default: import("./resolution").ColumnResolutionStrategy;
+        default: ({ row, columnName, value, fillOptions, config, table }: Parameters<import("..").FillStrategy>[0]) => Promise<void>;
     };
     Dedupe: {
-        byTopPosition: (tolerance?: number) => import("../types").DedupeStrategy;
+        byTopPosition: (tolerance?: number) => import("..").DedupeStrategy;
     };
     Loading: {
         Table: {
@@ -93,11 +94,18 @@ export declare const Strategies: {
     };
     Filter: {
         default: import("./filter").FilterStrategy;
-        spy: (calledRef?: {
-            called?: boolean;
-        }) => import("./filter").FilterStrategy;
     };
     Viewport: {
-        dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("../types").ViewportStrategy;
+        dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("..").ViewportStrategy;
+    };
+    ContentReady: {
+        textStable: (options?: {
+            timeout?: number;
+            interval?: number;
+        }) => import("./contentReady").ContentReadyStrategy;
+        mutationSettled: (options?: {
+            timeout?: number;
+            quietPeriod?: number;
+        }) => import("./contentReady").ContentReadyStrategy;
     };
 };

package/dist/strategies/index.js

@@ -17,36 +17,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strategies = void 0;
 const pagination_1 = require("./pagination");
 const sorting_1 = require("./sorting");
-const columns_1 = require("./columns");
 const headers_1 = require("./headers");
 const fill_1 = require("./fill");
-const resolution_1 = require("./resolution");
 const dedupe_1 = require("./dedupe");
 const loading_1 = require("./loading");
 const stabilization_1 = require("./stabilization");
 const filter_1 = require("./filter");
 const viewport_1 = require("./viewport");
+const contentReady_1 = require("./contentReady");
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./sorting"), exports);
 __exportStar(require("./columns"), exports);
 __exportStar(require("./headers"), exports);
 __exportStar(require("./fill"), exports);
-__exportStar(require("./resolution"), exports);
 __exportStar(require("./dedupe"), exports);
 __exportStar(require("./loading"), exports);
 __exportStar(require("./stabilization"), exports);
 __exportStar(require("./filter"), exports);
 __exportStar(require("./viewport"), exports);
+__exportStar(require("./contentReady"), exports);
+/**
+ * Built-in strategy factories.
+ * @note `CellNavigation` / `Resolution` removed from this namespace in #428 (dead/no-op).
+ * Use `strategies.navigation` (NavigationPrimitives) and header maps instead.
+ * `Filter.spy` was test-only and is no longer shipped.
+ */
 exports.Strategies = {
     Pagination: pagination_1.PaginationStrategies,
     Sorting: sorting_1.SortingStrategies,
-    CellNavigation: columns_1.CellNavigationStrategies,
     Header: headers_1.HeaderStrategies,
     Fill: fill_1.FillStrategies,
-    Resolution: resolution_1.ResolutionStrategies,
     Dedupe: dedupe_1.DedupeStrategies,
     Loading: loading_1.LoadingStrategies,
     Stabilization: stabilization_1.StabilizationStrategies,
     Filter: filter_1.FilterStrategies,
     Viewport: viewport_1.ViewportStrategies,
+    ContentReady: contentReady_1.ContentReadyStrategies,
 };

package/dist/strategies/pagination.js

@@ -83,6 +83,7 @@ exports.PaginationStrategies = {
                 const scrollTarget = options.scrollTarget
                     ? resolve(options.scrollTarget, root)
                     : root;
+                const beforeScrollTop = await scrollTarget.evaluate((el) => el.scrollTop);
                 const doScroll = async () => {
                     const box = await scrollTarget.boundingBox();
                     const scrollValue = amount * directionMultiplier;
@@ -98,8 +99,16 @@ exports.PaginationStrategies = {
                         await page.mouse.wheel(0, scrollValue);
                     }
                 };
-                // Stabilization: Wait
-                return await stabilization(context, doScroll);
+                // Stabilization: Wait for content to settle
+                const stabilizationResult = await stabilization(context, doScroll);
+                // EOF detection: use scroll position, not stabilization result.
+                // Stabilization may time out for recycling virtualizers when the scroll
+                // amount is small enough to stay within the overscan window (no new rows
+                // rendered), but the scroll position still changed — we haven't reached
+                // the end of the data.
+                const afterScrollTop = await scrollTarget.evaluate((el) => el.scrollTop);
+                const scrollMoved = Math.abs(afterScrollTop - beforeScrollTop) >= 1;
+                return scrollMoved || stabilizationResult;
             };
         };
         const createGoToFirst = () => {

package/dist/strategies/viewport.d.ts

@@ -3,7 +3,10 @@ export type DataAttributeViewportOptions = {
     /**
      * CSS selector for the scroll container (the element with overflow: auto/scroll).
      * Resolved with `closest()` from the root element, so ancestors are found automatically.
-     * Defaults to 'div[class*="overflow-auto"]'.
+     *
+     * **No framework default** — pass the selector for your table (e.g. Tailwind
+     * `div[class*="overflow-auto"]`, MUI `.MuiDataGrid-virtualScroller`). Omitting it
+     * means geometry filtering treats all mounted rows as visible and `scrollTo*` is a no-op.
      */
     scrollContainer?: string;
     /**

package/dist/strategies/viewport.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewportStrategies = void 0;
+const debugUtils_1 = require("../utils/debugUtils");
 /**
  * Viewport strategies for tables where row and cell elements carry a DOM attribute
  * equal to their index (e.g. Braintrust logs table, TanStack-style grids).
@@ -11,17 +12,30 @@ exports.ViewportStrategies = void 0;
  *   - scrollToColumn       — aligns header's left edge to container left, waits for cell mount
  *   - scrollToRow          — scrolls row into view, waits for row mount
  *
+ * **Important:** `rowAttribute` must be present on the elements matched by `rowSelector`,
+ * not on child cells. If row elements lack the attribute, `getVisibleRowRange` returns
+ * `{first:0, last:0}` and logs a warning at the `error` log level.
+ *
  * @example
- * // TanStack / Braintrust (data-index, 0-based — default)
- * viewport: Strategies.Viewport.dataAttribute()
+ * // TanStack / Braintrust — pass your scroll container explicitly (no Tailwind default)
+ * viewport: Strategies.Viewport.dataAttribute({
+ *   scrollContainer: 'div[class*="overflow-auto"]',
+ * })
  *
  * @example
  * // ARIA grid (aria-rowindex / aria-colindex, 1-based)
- * viewport: Strategies.Viewport.dataAttribute({ rowAttribute: 'aria-rowindex', columnAttribute: 'aria-colindex', rowOffset: 1, columnOffset: 1 })
+ * viewport: Strategies.Viewport.dataAttribute({
+ *   scrollContainer: '.MuiDataGrid-virtualScroller',
+ *   rowAttribute: 'aria-rowindex',
+ *   columnAttribute: 'aria-colindex',
+ *   rowOffset: 1,
+ *   columnOffset: 1,
+ * })
  */
 const dataAttribute = (options) => {
     var _a, _b, _c, _d, _e, _f, _g;
-    const containerSel = (_a = options === null || options === void 0 ? void 0 : options.scrollContainer) !== null && _a !== void 0 ? _a : 'div[class*="overflow-auto"]';
+    // null = no container: geometry filter keeps all mounted rows; scrollTo* no-ops (#431)
+    const containerSel = (_a = options === null || options === void 0 ? void 0 : options.scrollContainer) !== null && _a !== void 0 ? _a : null;
     const attachTimeout = (_b = options === null || options === void 0 ? void 0 : options.attachTimeout) !== null && _b !== void 0 ? _b : 3000;
     const rowAttr = (_c = options === null || options === void 0 ? void 0 : options.rowAttribute) !== null && _c !== void 0 ? _c : 'data-index';
     const colAttr = (_d = options === null || options === void 0 ? void 0 : options.columnAttribute) !== null && _d !== void 0 ? _d : 'data-index';
@@ -34,17 +48,22 @@ const dataAttribute = (options) => {
         getVisibleColumnRange: async ({ root, config }) => {
             const rowSel = config.rowSelector;
             const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : `[${colAttr}]`;
-            return root.evaluate((el, { rowSel, cellSel, colAttr, colOffset }) => {
+            const result = await root.evaluate((el, { rowSel, cellSel, colAttr, colOffset }) => {
                 const firstRow = el.querySelector(rowSel);
                 if (!firstRow)
-                    return { first: 0, last: 0 };
-                const indices = Array.from(firstRow.querySelectorAll(cellSel))
+                    return { first: 0, last: 0, _cellCount: 0, _validCount: 0 };
+                const cells = Array.from(firstRow.querySelectorAll(cellSel));
+                const indices = cells
                     .map(c => Number(c.getAttribute(colAttr)) - colOffset)
                     .filter(n => !isNaN(n));
                 if (!indices.length)
-                    return { first: 0, last: 0 };
-                return { first: Math.min(...indices), last: Math.max(...indices) };
+                    return { first: 0, last: 0, _cellCount: cells.length, _validCount: 0 };
+                return { first: Math.min(...indices), last: Math.max(...indices), _cellCount: cells.length, _validCount: indices.length };
             }, { rowSel, cellSel, colAttr, colOffset });
+            if (result._cellCount > 0 && result._validCount === 0) {
+                (0, debugUtils_1.logDebug)(config, 'error', `dataAttribute viewport: ${result._cellCount} cell(s) found but none have attribute "${colAttr}". Check that columnAttribute targets cell elements matched by cellSelector.`);
+            }
+            return { first: result.first, last: result.last };
         },
         getVisibleRowIndices: async ({ root, config }) => {
             const rowSel = config.rowSelector;
@@ -52,7 +71,9 @@ const dataAttribute = (options) => {
             // the rows' DOM positions so the iteration engine can drop overscan rows (#353/#357).
             return root.evaluate((el, { rowSel, containerSel }) => {
                 const rows = Array.from(el.querySelectorAll(rowSel));
-                const container = el.closest(containerSel);
+                const container = containerSel
+                    ? el.closest(containerSel)
+                    : null;
                 const containerRect = container ? container.getBoundingClientRect() : null;
                 const visible = [];
                 rows.forEach((r, i) => {
@@ -72,41 +93,42 @@ const dataAttribute = (options) => {
         },
         getVisibleRowRange: async ({ root, config }) => {
             const rowSel = config.rowSelector;
-            return root.evaluate((el, { rowSel, rowAttr, rowOffset, containerSel }) => {
+            const result = await root.evaluate((el, { rowSel, rowAttr, rowOffset, containerSel }) => {
                 const rows = Array.from(el.querySelectorAll(rowSel));
-                // #353: report only rows actually within the scroll container's vertical
-                // bounds, not every mounted row. Previously overscan rows (kept mounted by
-                // the virtual scroller above/below the fold) were counted as "visible".
-                // Inclusive: a row with ANY vertical overlap counts as visible; only rows
-                // entirely above or below the container are dropped — so we never drop a
-                // partially-visible real row.
-                const container = el.closest(containerSel);
+                const container = containerSel
+                    ? el.closest(containerSel)
+                    : null;
                 const containerRect = container ? container.getBoundingClientRect() : null;
-                const indices = rows
+                const visibleRows = rows
                     .filter(r => {
-                    // Container not resolvable — can't measure, so keep all rows (safe
-                    // fallback, preserves pre-#353 behavior rather than risk dropping real rows).
                     if (!containerRect)
                         return true;
                     const rect = r.getBoundingClientRect();
                     if (rect.height === 0)
-                        return false; // unrendered / detached
+                        return false;
                     return rect.bottom > containerRect.top && rect.top < containerRect.bottom;
-                })
+                });
+                const indices = visibleRows
                     .map(r => Number(r.getAttribute(rowAttr)) - rowOffset)
                     .filter(n => !isNaN(n));
                 if (!indices.length)
-                    return { first: 0, last: 0 };
-                return { first: Math.min(...indices), last: Math.max(...indices) };
+                    return { first: 0, last: 0, _rowCount: visibleRows.length, _validCount: 0 };
+                return { first: Math.min(...indices), last: Math.max(...indices), _rowCount: visibleRows.length, _validCount: indices.length };
             }, { rowSel, rowAttr, rowOffset, containerSel });
+            if (result._rowCount > 0 && result._validCount === 0) {
+                (0, debugUtils_1.logDebug)(config, 'error', `dataAttribute viewport: ${result._rowCount} row(s) found but none have attribute "${rowAttr}". Check that rowAttribute targets row elements matched by rowSelector, not child cells. getVisibleRowRange returning {first:0, last:0}.`);
+            }
+            return { first: result.first, last: result.last };
         },
         scrollToColumn: async ({ root, config }, colIndex) => {
             const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;
+            if (!containerSel || !headerSel)
+                return;
             const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : `[${colAttr}]`;
-            await root.evaluate((el, { containerSel, headerSel, cellSel, idx, columnWidth, scrollPadding }) => {
+            const canScroll = await root.evaluate((el, { containerSel, headerSel, cellSel, idx, columnWidth, scrollPadding }) => {
                 const container = el.closest(containerSel);
-                if (!container || !headerSel)
-                    return;
+                if (!container)
+                    return false;
                 const headers = Array.from(el.querySelectorAll(headerSel));
                 const target = headers[idx];
                 if (!target) {
@@ -118,7 +140,7 @@ const dataAttribute = (options) => {
                         ? widths.reduce((sum, width) => sum + width, 0) / widths.length
                         : 120);
                     container.scrollLeft = Math.max(0, idx * estimatedWidth - scrollPadding);
-                    return;
+                    return true;
                 }
                 const cRect = container.getBoundingClientRect();
                 const tRect = target.getBoundingClientRect();
@@ -130,7 +152,10 @@ const dataAttribute = (options) => {
                     // Scrolling right: reveal the target's right edge with padding.
                     container.scrollLeft += (tRect.right - cRect.right) + scrollPadding;
                 }
+                return true;
             }, { containerSel, headerSel, cellSel, idx: colIndex, columnWidth, scrollPadding });
+            if (!canScroll)
+                return;
             // Wait for a cell at this column index to mount in any row
             await root
                 .locator(`${config.rowSelector} [${colAttr}="${colIndex + colOffset}"]`)
@@ -138,15 +163,17 @@ const dataAttribute = (options) => {
                 .waitFor({ state: 'attached', timeout: attachTimeout });
         },
         scrollToRow: async ({ root, config }, rowIndex) => {
+            if (!containerSel)
+                return;
             const rowSel = config.rowSelector;
-            await root.evaluate((el, { containerSel, rowSel, rowAttr, idx, rowOffset, rowHeight, scrollPadding }) => {
+            const canScroll = await root.evaluate((el, { containerSel, rowSel, rowAttr, idx, rowOffset, rowHeight, scrollPadding }) => {
                 const container = el.closest(containerSel);
                 if (!container)
-                    return;
+                    return false;
                 const row = container.querySelector(`${rowSel}[${rowAttr}="${idx + rowOffset}"]`);
                 if (row) {
                     row.scrollIntoView({ block: 'nearest', inline: 'nearest' });
-                    return;
+                    return true;
                 }
                 const visibleRows = Array.from(container.querySelectorAll(rowSel));
                 const heights = visibleRows
@@ -156,7 +183,10 @@ const dataAttribute = (options) => {
                     ? heights.reduce((sum, height) => sum + height, 0) / heights.length
                     : 40);
                 container.scrollTop = Math.max(0, idx * estimatedHeight - scrollPadding);
+                return true;
             }, { containerSel, rowSel, rowAttr, idx: rowIndex, rowOffset, rowHeight, scrollPadding });
+            if (!canScroll)
+                return;
             await root
                 .locator(`${rowSel}[${rowAttr}="${rowIndex + rowOffset}"]`)
                 .waitFor({ state: 'attached', timeout: attachTimeout });