@rickcedwhat/playwright-smart-table 6.21.0 → 6.22.0-next.28cae60

package/dist/engine/rowFinder.d.ts

@@ -13,7 +13,7 @@ export declare class RowFinder<T = any> {
     private tableState;
     private advancePage;
     private resolve;
-    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number | undefined, tablePageIndex?: number, barrier?: NavigationBarrier, rowSelector?: string) => SmartRow<T>, tableState?: {
+    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number | undefined, tablePageIndex?: number, barrier?: NavigationBarrier, healSelector?: string) => SmartRow<T>, tableState?: {
         currentPageIndex: number;
     }, advancePage?: (useBulk: boolean) => Promise<boolean>);
     private splitFilters;
@@ -38,8 +38,8 @@ export declare class RowFinder<T = any> {
      * every row calling elementHandle() + evaluate() per row (O(n) CDP roundtrips, and
      * elementHandle() is soft-deprecated). We resolve the target once and let evaluateAll
      * compare it against the full row set in the browser. The row set is resolved through the
-     * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
-     * all behave identically. (#350)
+     * same selector/scope as everywhere else, so a string or function rowSelector behave
+     * identically. (#350)
      */
     private throwIfAmbiguous;
     private scanDomPosition;

package/dist/engine/rowFinder.js

@@ -9,6 +9,7 @@ const navigationBarrier_1 = require("../utils/navigationBarrier");
 const rowResolution_1 = require("./rowResolution");
 const resolveCellLocator_1 = require("../utils/resolveCellLocator");
 const scanPages_1 = require("./scanPages");
+const loadingWait_1 = require("../utils/loadingWait");
 class RowFinder {
     constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }, advancePage = async () => false) {
         this.rootLocator = rootLocator;
@@ -131,10 +132,7 @@ class RowFinder {
             page: this.rootLocator.page(),
             resolve: this.resolve
         };
-        while (await isTableLoading(context)) {
-            (0, debugUtils_1.logDebug)(this.config, 'verbose', 'Table is loading... waiting');
-            await this.rootLocator.page().waitForTimeout(200);
-        }
+        await (0, loadingWait_1.waitWhileTableLoading)(this.config, context, this.rootLocator.page(), 'waitForTableReady');
     }
     async findRows(filters = {}, options) {
         var _a, _b, _c;
@@ -271,8 +269,8 @@ class RowFinder {
      * every row calling elementHandle() + evaluate() per row (O(n) CDP roundtrips, and
      * elementHandle() is soft-deprecated). We resolve the target once and let evaluateAll
      * compare it against the full row set in the browser. The row set is resolved through the
-     * same selector/scope as everywhere else, so a string, function, or Locator rowSelector
-     * all behave identically. (#350)
+     * same selector/scope as everywhere else, so a string or function rowSelector behave
+     * identically. (#350)
      */
     async throwIfAmbiguous(rows, filters, map) {
         const sampleData = [];

package/dist/engine/tableIteration.d.ts

@@ -7,7 +7,7 @@ export interface TableIterationEnv<T = any> {
     getRowLocators: () => Locator;
     getMap: () => Map<string, number>;
     advancePage: (useBulk: boolean) => Promise<boolean>;
-    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number, barrier?: NavigationBarrier, rowSelector?: string) => SmartRow<T>;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number, barrier?: NavigationBarrier, healSelector?: string) => SmartRow<T>;
     createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
     config: FinalTableConfig<T>;
     getPage: () => Page;

package/dist/engine/tableIteration.js

@@ -9,6 +9,7 @@ const navigationBarrier_1 = require("../utils/navigationBarrier");
 const mutex_1 = require("../utils/mutex");
 const rowResolution_1 = require("./rowResolution");
 const scanPages_1 = require("./scanPages");
+const smartRowInternals_1 = require("../utils/smartRowInternals");
 function log(config, msg) {
     (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 }
@@ -28,8 +29,8 @@ async function runMap(env, callback, options = {}, label = 'map') {
     const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
     const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
     const dedupeKeys = dedupeStrategy ? new Set() : null;
-    const defaultMode = label === 'map' ? 'parallel' : 'sequential';
-    const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : defaultMode;
+    // Sequential by default for all iteration labels (#434) — parallel is opt-in for read-only maps.
+    const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : 'sequential';
     const useBarrier = concurrency === 'synchronized';
     // Mutex must not pair with the navigation barrier: synchronized mode needs every row
     // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
@@ -112,7 +113,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
                     const sr = env.makeSmartRow(pageRows[idx], map, logicalIndex, env.getCurrentPageIndex(), barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                     // Mark as part of an iteration batch so toJSON's #366 re-pin uses rescan-only recovery
                     // (no scroll-back) — scrolling here would disrupt sibling rows' positional locators.
-                    sr._inBatch = true;
+                    (0, smartRowInternals_1.internals)(sr)._inBatch = true;
                     return sr;
                 }));
                 // enumIndex = visit-order counter (ctx.index); row.rowIndex = logical (ctx.rowIndex).

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { PLAYWRIGHT_SMART_TABLE_VERSION } from './packageVersion';
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /**

package/dist/packageVersion.d.ts

@@ -3,4 +3,4 @@
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.21.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.22.0-next.28cae60";

package/dist/packageVersion.js

@@ -6,4 +6,4 @@ exports.PLAYWRIGHT_SMART_TABLE_VERSION = void 0;
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.21.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.22.0-next.28cae60";

package/dist/plugins/index.d.ts

@@ -27,9 +27,9 @@ export declare const Plugins: {
             };
             pagination: import("..").PaginationPrimitives;
         };
-        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
-        rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
+        headerSelector?: import("..").TableSelector | undefined;
+        rowSelector?: import("..").TableSelector | undefined;
+        cellSelector?: import("..").TableSelector | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
@@ -68,9 +68,9 @@ export declare const Plugins: {
                 locator: any;
             } | null>;
         };
-        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
-        rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
+        headerSelector?: import("..").TableSelector | undefined;
+        rowSelector?: import("..").TableSelector | undefined;
+        cellSelector?: import("..").TableSelector | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
@@ -93,9 +93,9 @@ export declare const Plugins: {
      */
     MUI: {
         Strategies: import("..").TableStrategies | undefined;
-        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
-        rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
+        headerSelector?: import("..").TableSelector | undefined;
+        rowSelector?: import("..").TableSelector | undefined;
+        cellSelector?: import("..").TableSelector | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {

package/dist/presets/mui.js

@@ -4,6 +4,12 @@ exports.muiDataGrid = exports.muiTable = void 0;
 exports.createMuiTable = createMuiTable;
 exports.createMuiDataGrid = createMuiDataGrid;
 const debugUtils_1 = require("../utils/debugUtils");
+const cssSelector_1 = require("../utils/cssSelector");
+// Fallbacks for in-browser queries when the configured selector is a function.
+// Only DataGrid rows carry data-rowindex, so this can't match cells or headers.
+const MUI_ROW_CSS = '[data-rowindex]';
+const MUI_HEADER_CSS = '.MuiDataGrid-columnHeader';
+const cssOr = (selector, fallback) => typeof selector === 'string' ? selector : fallback;
 const DEFAULT_LABELS = {
     nextPage: 'Go to next page',
     previousPage: 'Go to previous page',
@@ -146,22 +152,14 @@ function createMuiTable(opts) {
                         return 'asc';
                     return 'none';
                 },
-                doSort: async ({ columnName, direction, context }) => {
-                    var _a, _b;
+                doSort: async ({ columnName, context }) => {
+                    // Trigger-only: core `sorting.apply` owns retries + state checks (#434).
                     if (!context.getHeaderCell)
                         return;
                     const header = await context.getHeaderCell(columnName);
                     const sortLabel = header.locator('.MuiTableSortLabel-root').first();
                     const target = await sortLabel.isVisible().catch(() => false) ? sortLabel : header;
-                    let current = await ((_a = context.config.strategies.sorting) === null || _a === void 0 ? void 0 : _a.getSortState({ columnName, context })) || 'none';
-                    let attempts = 0;
-                    // Click until the state matches the target direction, max 3 times (none -> asc -> desc)
-                    while (current !== direction && attempts < 3) {
-                        await target.click();
-                        await context.page.waitForTimeout(100);
-                        current = await ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context })) || 'none';
-                        attempts++;
-                    }
+                    await target.click();
                 }
             },
             dedupe: async (row) => {
@@ -303,28 +301,22 @@ function createMuiDataGrid(opts) {
                         return 'desc';
                     return 'none';
                 },
-                doSort: async ({ columnName, direction, context }) => {
-                    var _a, _b;
+                doSort: async ({ columnName, context }) => {
+                    // Trigger-only: core `sorting.apply` owns retries + state checks (#434).
                     if (!context.getHeaderCell)
                         return;
                     const header = await context.getHeaderCell(columnName);
-                    let current = await ((_a = context.config.strategies.sorting) === null || _a === void 0 ? void 0 : _a.getSortState({ columnName, context })) || 'none';
-                    let attempts = 0;
-                    while (current !== direction && attempts < 3) {
-                        const clickTarget = header.locator('.MuiDataGrid-columnHeaderTitleContainer').first();
-                        if (await clickTarget.isVisible()) {
-                            await clickTarget.click({ force: true });
-                        }
-                        else {
-                            await header.click({ force: true });
-                        }
-                        // Wait for stabilization (using DataGrid specific overlay check inside helper)
-                        const displayedRows = context.root.locator('.MuiTablePagination-displayedRows');
-                        const text = await displayedRows.innerText().catch(() => '');
-                        await waitForMuiPaginationStabilization(context, displayedRows, text);
-                        current = await ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context })) || 'none';
-                        attempts++;
+                    const clickTarget = header.locator('.MuiDataGrid-columnHeaderTitleContainer').first();
+                    if (await clickTarget.isVisible()) {
+                        await clickTarget.click({ force: true });
                     }
+                    else {
+                        await header.click({ force: true });
+                    }
+                    // One stabilization wait after the click; core also polls isTableLoading.
+                    const displayedRows = context.root.locator('.MuiTablePagination-displayedRows');
+                    const text = await displayedRows.innerText().catch(() => '');
+                    await waitForMuiPaginationStabilization(context, displayedRows, text);
                 }
             },
             dedupe: async (row) => {
@@ -345,7 +337,7 @@ function createMuiDataGrid(opts) {
             // scroll methods use querySelector rather than closest().
             viewport: {
                 getVisibleRowRange: async ({ root, config }) => {
-                    const rowSel = config.rowSelector;
+                    const rowSel = cssOr(config.rowSelector, MUI_ROW_CSS);
                     return root.evaluate((el, rowSel) => {
                         const indices = Array.from(el.querySelectorAll(rowSel))
                             .map(r => Number(r.getAttribute('data-rowindex')))
@@ -359,8 +351,13 @@ function createMuiDataGrid(opts) {
                 // the DOM positions of rows overlapping the virtualScroller's bounds so map/forEach
                 // skip the overscan rows MUI keeps mounted above/below the fold. The scroller is a
                 // descendant of root, so querySelector (not closest).
-                getVisibleRowIndices: async ({ root, config }) => {
-                    const rowSel = config.rowSelector;
+                getVisibleRowIndices: async ({ root, config, resolve }) => {
+                    // Positions must index into the configured row set, so no CSS fallback here.
+                    const rowSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'rowSelector', 'MUI DataGrid overscan filtering');
+                    if (!rowSel) {
+                        const count = await resolve(config.rowSelector, root).count();
+                        return Array.from({ length: count }, (_, i) => i);
+                    }
                     return root.evaluate((el, rowSel) => {
                         const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
                         const rows = Array.from(el.querySelectorAll(rowSel));
@@ -381,7 +378,7 @@ function createMuiDataGrid(opts) {
                     }, rowSel);
                 },
                 getVisibleColumnRange: async ({ root, config }) => {
-                    const rowSel = config.rowSelector;
+                    const rowSel = cssOr(config.rowSelector, MUI_ROW_CSS);
                     const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : '[aria-colindex]';
                     return root.evaluate((el, { rowSel, cellSel }) => {
                         const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
@@ -423,7 +420,7 @@ function createMuiDataGrid(opts) {
                     }, { rowSel, cellSel });
                 },
                 scrollToRow: async ({ root, config }, rowIndex) => {
-                    const rowSel = config.rowSelector;
+                    const rowSel = cssOr(config.rowSelector, MUI_ROW_CSS);
                     await root.evaluate((el, { rowSel, idx }) => {
                         const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
                         if (!scroller)
@@ -477,10 +474,10 @@ function createMuiDataGrid(opts) {
                         .catch(() => { });
                 },
                 scrollToColumn: async ({ root, config, page }, colIndex) => {
-                    const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;
+                    const headerSel = cssOr(config.headerSelector, MUI_HEADER_CSS);
                     await root.evaluate((el, { headerSel, idx }) => {
                         const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
-                        if (!scroller || !headerSel)
+                        if (!scroller)
                             return;
                         const headers = Array.from(el.querySelectorAll(headerSel));
                         const targetAriaIdx = idx + 1; // aria-colindex is 1-based

package/dist/smartRow.js

@@ -7,13 +7,20 @@ const stringUtils_1 = require("./utils/stringUtils");
 const debugUtils_1 = require("./utils/debugUtils");
 const paginationPath_1 = require("./utils/paginationPath");
 const sentinel_1 = require("./utils/sentinel");
+const pageIndex_1 = require("./utils/pageIndex");
 /**
  * Internal helper to navigate to a cell with active cell optimization.
  * Uses `strategies.navigation` primitives (goUp/goDown/goLeft/goRight, optional snap/seek/goHome).
  * Returns the target cell locator after navigation.
  */
 const _navigateToCell = async (params) => {
-    const { config, rootLocator, page, resolve, getHeaders, column, index, rowLocator, rowIndex, barrier, allowMissingCell } = params;
+    var _a;
+    const { config, rootLocator, page, resolve, getHeaders, column, index, rowLocator, barrier, allowMissingCell } = params;
+    // getRowByIndex supplies a position in the mounted row set. Resolve it while the
+    // selected row is still mounted, before horizontal scrolling can evict it.
+    const rowIndex = params.renderWindowPosition && config.strategies.viewport && config.strategies.resolveRowIndex
+        ? (_a = (await (0, rowResolution_1.resolveLogicalRowIndex)(rowLocator, config, () => undefined))) === null || _a === void 0 ? void 0 : _a.index
+        : params.rowIndex;
     const rowLabel = typeof rowIndex === 'number' ? `row ${rowIndex}` : 'row ?';
     (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: resolving column "${column}" (colIndex ${index}), ${rowLabel}`);
     // Get active cell if strategy is available
@@ -357,6 +364,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 index: idx,
                 rowLocator,
                 rowIndex,
+                renderWindowPosition,
                 barrier: smart._barrier
             });
             // Run beforeCellRead hook (same as toJSON does after navigation).
@@ -418,6 +426,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             index: idx,
             rowLocator,
             rowIndex,
+            renderWindowPosition,
             barrier: smart._barrier,
             allowMissingCell: !!(columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read),
         });
@@ -717,6 +726,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 index: idx,
                 rowLocator: stableRow,
                 rowIndex,
+                renderWindowPosition,
                 barrier: smart._barrier,
                 allowMissingCell: !!mapper,
             });
@@ -833,6 +843,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 index: colIdx,
                 rowLocator,
                 rowIndex,
+                renderWindowPosition,
                 barrier: smart._barrier
             });
             const columnOverride = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[colName];
@@ -885,7 +896,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             const primitives = config.strategies.pagination;
             const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
             const getCurrent = () => parentTable.currentPageIndex;
-            const setCurrent = (n) => { parentTable.currentPageIndex = n; };
+            const setCurrent = (n) => { (0, pageIndex_1.setCurrentPageIndex)(parentTable, n); };
             if (primitives.goToPage) {
                 (0, debugUtils_1.logDebug)(config, 'info', `bringIntoView: Navigating to page ${tablePageIndex} (goToPage retry loop)`);
                 await (0, paginationPath_1.executeNavigationWithGoToPageRetry)(tablePageIndex, primitives, context, getCurrent, setCurrent);
@@ -910,7 +921,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                         if (!ok)
                             throw new Error(`bringIntoView: goNext failed before reaching page ${tablePageIndex}.`);
                     }
-                    parentTable.currentPageIndex = tablePageIndex;
+                    (0, pageIndex_1.setCurrentPageIndex)(parentTable, tablePageIndex);
                 }
                 else {
                     (0, debugUtils_1.logDebug)(config, 'error', `Cannot bring row on page ${tablePageIndex} into view. No backwards pagination strategies (goToPage, goPrevious, goPreviousBulk, or goToFirst+goNext) provided.`);

package/dist/strategies/filter.js

@@ -8,9 +8,8 @@ exports.FilterStrategies = void 0;
 exports.FilterStrategies = {
     default: {
         apply({ rows, filter, colIndex, tableContext }) {
-            const page = tableContext.page;
-            const resolve = tableContext.resolve;
-            const cellTemplate = resolve(tableContext.config.cellSelector, page);
+            const scopeRow = tableContext.page.locator(':scope');
+            const cellTemplate = tableContext.resolve(tableContext.config.cellSelector, scopeRow);
             const targetCell = cellTemplate.nth(colIndex);
             if (typeof filter.value === 'function') {
                 return rows.filter({ has: filter.value(targetCell) });

package/dist/strategies/viewport.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewportStrategies = void 0;
 const debugUtils_1 = require("../utils/debugUtils");
+const cssSelector_1 = require("../utils/cssSelector");
 /**
  * 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).
@@ -46,7 +47,9 @@ const dataAttribute = (options) => {
     const scrollPadding = (_g = options === null || options === void 0 ? void 0 : options.scrollPadding) !== null && _g !== void 0 ? _g : 20;
     return {
         getVisibleColumnRange: async ({ root, config }) => {
-            const rowSel = config.rowSelector;
+            const rowSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'rowSelector', 'dataAttribute viewport column range');
+            if (!rowSel)
+                return cssSelector_1.UNKNOWN_RANGE;
             const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : `[${colAttr}]`;
             const result = await root.evaluate((el, { rowSel, cellSel, colAttr, colOffset }) => {
                 const firstRow = el.querySelector(rowSel);
@@ -65,8 +68,12 @@ const dataAttribute = (options) => {
             }
             return { first: result.first, last: result.last };
         },
-        getVisibleRowIndices: async ({ root, config }) => {
-            const rowSel = config.rowSelector;
+        getVisibleRowIndices: async ({ root, config, resolve }) => {
+            const rowSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'rowSelector', 'dataAttribute viewport overscan filtering');
+            if (!rowSel) {
+                const count = await resolve(config.rowSelector, root).count();
+                return Array.from({ length: count }, (_, i) => i);
+            }
             // Geometry-based (mirrors getVisibleRowRange's inclusive intersection), but returns
             // the rows' DOM positions so the iteration engine can drop overscan rows (#353/#357).
             return root.evaluate((el, { rowSel, containerSel }) => {
@@ -92,7 +99,9 @@ const dataAttribute = (options) => {
             }, { rowSel, containerSel });
         },
         getVisibleRowRange: async ({ root, config }) => {
-            const rowSel = config.rowSelector;
+            const rowSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'rowSelector', 'dataAttribute viewport row range');
+            if (!rowSel)
+                return cssSelector_1.UNKNOWN_RANGE;
             const result = await root.evaluate((el, { rowSel, rowAttr, rowOffset, containerSel }) => {
                 const rows = Array.from(el.querySelectorAll(rowSel));
                 const container = containerSel
@@ -120,9 +129,11 @@ const dataAttribute = (options) => {
             }
             return { first: result.first, last: result.last };
         },
-        scrollToColumn: async ({ root, config }, colIndex) => {
-            const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;
-            if (!containerSel || !headerSel)
+        scrollToColumn: async ({ root, config, resolve }, colIndex) => {
+            if (!containerSel)
+                return;
+            const headerSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'headerSelector', 'dataAttribute viewport scrollToColumn');
+            if (!headerSel)
                 return;
             const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : `[${colAttr}]`;
             const canScroll = await root.evaluate((el, { containerSel, headerSel, cellSel, idx, columnWidth, scrollPadding }) => {
@@ -157,15 +168,20 @@ const dataAttribute = (options) => {
             if (!canScroll)
                 return;
             // Wait for a cell at this column index to mount in any row
-            await root
-                .locator(`${config.rowSelector} [${colAttr}="${colIndex + colOffset}"]`)
+            const rows = typeof config.rowSelector === 'string'
+                ? root.locator(config.rowSelector)
+                : resolve(config.rowSelector, root);
+            await rows
+                .locator(`[${colAttr}="${colIndex + colOffset}"]`)
                 .first()
                 .waitFor({ state: 'attached', timeout: attachTimeout });
         },
         scrollToRow: async ({ root, config }, rowIndex) => {
             if (!containerSel)
                 return;
-            const rowSel = config.rowSelector;
+            const rowSel = (0, cssSelector_1.cssSelectorOrWarn)(config, 'rowSelector', 'dataAttribute viewport scrollToRow');
+            if (!rowSel)
+                return;
             const canScroll = await root.evaluate((el, { containerSel, rowSel, rowAttr, idx, rowOffset, rowHeight, scrollPadding }) => {
                 const container = el.closest(containerSel);
                 if (!container)