@rickcedwhat/playwright-smart-table 6.20.1 → 6.21.0-next.3ab7a18

package/dist/engine/rowFinder.d.ts

@@ -24,6 +24,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRow<T>>;
+    private waitForTableReady;
     findRows(filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;

package/dist/engine/rowFinder.js

@@ -7,6 +7,9 @@ const elementTracker_1 = require("../utils/elementTracker");
 const sentinel_1 = require("../utils/sentinel");
 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;
@@ -56,12 +59,26 @@ class RowFinder {
             if (colIndex === undefined)
                 continue;
             const override = this.config.columnOverrides[colName];
-            const cell = this.resolve(this.config.cellSelector, rowLocator).nth(colIndex);
+            const cell = (0, resolveCellLocator_1.resolveCellLocator)({
+                config: this.config,
+                resolve: this.resolve,
+                row: rowLocator,
+                root: this.rootLocator,
+                columnName: colName,
+                columnIndex: colIndex,
+            });
             const getCell = (name) => {
                 const idx = map.get(name);
                 if (idx === undefined)
                     throw new Error(`Column "${name}" not found`);
-                return this.resolve(this.config.cellSelector, rowLocator).nth(idx);
+                return (0, resolveCellLocator_1.resolveCellLocator)({
+                    config: this.config,
+                    resolve: this.resolve,
+                    row: rowLocator,
+                    root: this.rootLocator,
+                    columnName: name,
+                    columnIndex: idx,
+                });
             };
             const context = {
                 row: this.makeSmartRow(rowLocator, map, undefined),
@@ -104,44 +121,59 @@ class RowFinder {
         smartRow[sentinel_1.SENTINEL_ROW] = true;
         return smartRow;
     }
+    async waitForTableReady() {
+        var _a;
+        const isTableLoading = (_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading;
+        if (!isTableLoading)
+            return;
+        const context = {
+            root: this.rootLocator,
+            config: this.config,
+            page: this.rootLocator.page(),
+            resolve: this.resolve
+        };
+        await (0, loadingWait_1.waitWhileTableLoading)(this.config, context, this.rootLocator.page(), 'waitForTableReady');
+    }
     async findRows(filters = {}, options) {
         var _a, _b, _c;
         const filtersRecord = filters;
         const map = await this.tableMapper.getMap();
         const allRows = [];
         const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
-        let pagesScanned = 1;
+        const useBulk = (options === null || options === void 0 ? void 0 : options.useBulkPagination) === true && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
+        const hasPagination = !!this.config.strategies.pagination;
         (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
         const tracker = new elementTracker_1.ElementTracker('findRows');
         try {
             const { domFilters, overrideFilters, syntheticFilters } = this.splitFilters(filtersRecord);
             const hasOverrideFilters = Object.keys(overrideFilters).length > 0;
             const hasSyntheticFilters = Object.keys(syntheticFilters).length > 0;
-            const collectMatches = async () => {
+            const { pagesScanned } = await (0, scanPages_1.scanPages)({
+                advancePage: this.advancePage,
+                getCurrentPageIndex: () => this.tableState.currentPageIndex,
+                config: this.config,
+                waitForReady: () => this.waitForTableReady(),
+            }, async () => {
                 var _a, _b, _c, _d;
                 let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
                 if (Object.keys(domFilters).length > 0) {
                     rowLocators = this.filterEngine.applyFilters(rowLocators, domFilters, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page(), this.rootLocator);
                 }
-                // Get only newly seen matched rows
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
                 const currentRows = await rowLocators.all();
                 let added = 0;
-                // One barrier per batch — synchronizes cell navigation across all rows in this page's results
                 const useBarrier = this.config.concurrency === 'synchronized' && newIndices.length > 1;
                 const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(newIndices.length) : undefined;
                 for (const idx of newIndices) {
                     const resolved = await (0, rowResolution_1.resolveLogicalRowIndex)(currentRows[idx], this.config, () => allRows.length);
                     const smartRow = this.makeSmartRow(currentRows[idx], map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
-                    // findRows skips a still-loading row when no timeout is configured (legacy
-                    // behavior) — see resolveRowLoading's `noTimeoutAction: 'skip'`.
                     const loadingOutcome = await (0, rowResolution_1.resolveRowLoading)(smartRow, this.config.strategies.loading, 'skip', (msg) => (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: ${msg}`));
                     if (loadingOutcome !== 'process') {
                         barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                         if (loadingOutcome === 'throw') {
                             throw new Error(`[SmartTable] Row ${allRows.length} did not finish loading within ${(_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.rowLoadingTimeout}ms`);
                         }
-                        continue; // 'skip'
+                        continue;
                     }
                     if (hasOverrideFilters && !await this.matchesOverrideFilters(currentRows[idx], overrideFilters, map, (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false)) {
                         barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
@@ -155,57 +187,33 @@ class RowFinder {
                     added++;
                 }
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: page ${this.tableState.currentPageIndex} — ${added} new match(es) (total: ${allRows.length})`);
-            };
-            // Scan first page
-            await collectMatches();
-            // Pagination Loop
-            while (pagesScanned < effectiveMaxPages && this.config.strategies.pagination) {
-                // Default to single-step goNext; bulk is opt-in via useBulkPagination: true (#349).
-                // Bulk-by-default made findRows jump N pages per advance and silently skip the
-                // rows on intermediate pages. When only a bulk primitive exists, _advancePage
-                // still falls back to it.
-                const useBulk = (options === null || options === void 0 ? void 0 : options.useBulkPagination) === true && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
-                const prevPage = this.tableState.currentPageIndex;
-                const didPaginate = await this.advancePage(useBulk);
-                if (!didPaginate) {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: pagination returned false — final scan`);
-                    await collectMatches();
-                    break;
-                }
-                const pagesJumped = this.tableState.currentPageIndex - prevPage;
-                pagesScanned += pagesJumped;
-                (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
-                await (0, debugUtils_1.debugDelay)(this.config, 'pagination');
-                await collectMatches();
-            }
+                return 'continue';
+            }, {
+                maxPages: hasPagination ? effectiveMaxPages : 1,
+                useBulk,
+                label: 'findRows',
+                finalScanOnEof: hasPagination,
+            });
+            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
         }
         finally {
             await tracker.cleanup(this.rootLocator.page());
         }
-        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
         return (0, smartRowArray_1.createSmartRowArray)(allRows);
     }
     async findRowLocator(filters, options = {}) {
-        var _a, _b, _c;
+        var _a, _b;
         const map = await this.tableMapper.getMap();
         const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
-        let pagesScanned = 1;
+        const useBulk = options.useBulkPagination === true && !!((_b = this.config.strategies.pagination) === null || _b === void 0 ? void 0 : _b.goNextBulk);
+        let found = null;
         (0, debugUtils_1.logDebug)(this.config, 'verbose', `Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
-        while (true) {
-            // Check Loading
-            if ((_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isTableLoading) {
-                const isLoading = await this.config.strategies.loading.isTableLoading({
-                    root: this.rootLocator,
-                    config: this.config,
-                    page: this.rootLocator.page(),
-                    resolve: this.resolve
-                });
-                if (isLoading) {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', 'Table is loading... waiting');
-                    await this.rootLocator.page().waitForTimeout(200);
-                    continue;
-                }
-            }
+        await (0, scanPages_1.scanPages)({
+            advancePage: this.advancePage,
+            getCurrentPageIndex: () => this.tableState.currentPageIndex,
+            config: this.config,
+            waitForReady: () => this.waitForTableReady(),
+        }, async () => {
             const allRows = this.resolve(this.config.rowSelector, this.rootLocator);
             const { domFilters, overrideFilters, syntheticFilters } = this.splitFilters(filters);
             const hasPostFilters = Object.keys(overrideFilters).length > 0 || Object.keys(syntheticFilters).length > 0;
@@ -218,8 +226,10 @@ class RowFinder {
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
                 if (count > 1)
                     await this.throwIfAmbiguous(await matchedRows.all(), filters, map);
-                if (count === 1)
-                    return matchedRows.first();
+                if (count === 1) {
+                    found = matchedRows.first();
+                    return 'stop';
+                }
             }
             else {
                 const candidates = await matchedRows.all();
@@ -235,31 +245,19 @@ class RowFinder {
                 (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: ${postFilterMatches.length} match(es) after post-filter`);
                 if (postFilterMatches.length > 1)
                     await this.throwIfAmbiguous(postFilterMatches, filters, map);
-                if (postFilterMatches.length === 1)
-                    return postFilterMatches[0];
-            }
-            if (pagesScanned < effectiveMaxPages) {
-                (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Not found. Attempting pagination...`);
-                // Default to single-step goNext; bulk is opt-in via useBulkPagination: true (#349).
-                // Bulk-by-default made findRow jump past the page holding the target row.
-                const useBulk = options.useBulkPagination === true && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
-                const prevPage = this.tableState.currentPageIndex;
-                const didLoadMore = await this.advancePage(useBulk);
-                if (didLoadMore) {
-                    const pagesJumped = this.tableState.currentPageIndex - prevPage;
-                    pagesScanned += pagesJumped;
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRowLocator: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
-                    await (0, debugUtils_1.debugDelay)(this.config, 'pagination');
-                    continue;
-                }
-                else {
-                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: pagination returned false — final scan`);
-                    pagesScanned = effectiveMaxPages;
-                    continue;
+                if (postFilterMatches.length === 1) {
+                    found = postFilterMatches[0];
+                    return 'stop';
                 }
             }
-            return null;
-        }
+            return 'continue';
+        }, {
+            maxPages: effectiveMaxPages,
+            useBulk,
+            label: 'findRow',
+            finalScanOnEof: true,
+        });
+        return found;
     }
     resolveRowIndex(rowLocator) {
         // Shared resolver: resolveRowIndex strategy first, else the DOM-position fallback.

package/dist/engine/scanPages.d.ts

@@ -0,0 +1,58 @@
+import type { FinalTableConfig } from '../types';
+/**
+ * Page-walk primitive (#427).
+ *
+ * Owns the shared pagination shell used by map/forEach/filter, findRow(s),
+ * countRows, and the public async iterator:
+ * - `maxPages` budget
+ * - `advancePage(useBulk)` with bulk page-jump accounting
+ * - EOF final scan (one more `onPage` after `advancePage` returns false)
+ * - optional `waitForReady` before each page
+ *
+ * Per-page collection (overscan, dedupe, loading, filters) stays in the caller
+ * so find vs map can keep their different row policies.
+ *
+ * ## Feature matrix (public APIs → this shell)
+ *
+ * | API | final-scan | bulk opt-in | waitForReady | overscan/dedupe/loading |
+ * |-----|------------|-------------|--------------|-------------------------|
+ * | map / forEach / filter | yes | options.useBulkPagination | via caller | in runMap |
+ * | findRows | yes | options.useBulkPagination | yes | findRows policy (skip loading) |
+ * | findRow | yes | options.useBulkPagination | yes | DOM/post filters only |
+ * | countRows | yes | no (single-step) | yes | count-only / post filters |
+ * | async iterator | yes | no | via runMap path | same as map |
+ * | findRowByIndex | no* | no | n/a | scroll/search, not a full scan |
+ * | bringIntoView | n/a | path planner | n/a | not a page scan |
+ *
+ * \* findRowByIndex stops when the target index is mounted; it does not collect rows.
+ */
+export type ScanDecision = 'continue' | 'stop';
+export interface ScanPageContext {
+    /** 1-based count of pages visited so far (includes the current page). */
+    pagesScanned: number;
+    /** `tableState.currentPageIndex` at the start of this page callback. */
+    pageIndex: number;
+    /** True when this is the post-EOF extra pass after `advancePage` returned false. */
+    isFinalScan: boolean;
+}
+export interface ScanPagesEnv {
+    advancePage: (useBulk: boolean) => Promise<boolean>;
+    getCurrentPageIndex: () => number;
+    config: FinalTableConfig;
+    /** Optional gate before each page (e.g. `isTableLoading` poll). */
+    waitForReady?: () => Promise<void>;
+}
+export interface ScanPagesOptions {
+    maxPages: number;
+    /** Prefer goNextBulk when the advance helper supports it. @default false */
+    useBulk?: boolean;
+    label?: string;
+    /**
+     * When `advancePage` returns false, invoke `onPage` once more before stopping.
+     * Matches runMap / findRows EOF behavior. @default true
+     */
+    finalScanOnEof?: boolean;
+}
+export declare function scanPages(env: ScanPagesEnv, onPage: (ctx: ScanPageContext) => Promise<ScanDecision>, options: ScanPagesOptions): Promise<{
+    pagesScanned: number;
+}>;

package/dist/engine/scanPages.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanPages = scanPages;
+const debugUtils_1 = require("../utils/debugUtils");
+async function scanPages(env, onPage, options) {
+    var _a, _b;
+    const maxPages = options.maxPages;
+    const useBulk = (_a = options.useBulk) !== null && _a !== void 0 ? _a : false;
+    const finalScanOnEof = options.finalScanOnEof !== false;
+    const label = (_b = options.label) !== null && _b !== void 0 ? _b : 'scanPages';
+    let pagesScanned = 1;
+    let reachedEnd = false;
+    (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: starting (maxPages=${maxPages}, useBulk=${useBulk}, finalScanOnEof=${finalScanOnEof})`);
+    while (true) {
+        if (env.waitForReady) {
+            await env.waitForReady();
+        }
+        const decision = await onPage({
+            pagesScanned,
+            pageIndex: env.getCurrentPageIndex(),
+            isFinalScan: reachedEnd,
+        });
+        if (decision === 'stop') {
+            (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: onPage returned stop at page ${env.getCurrentPageIndex()}`);
+            break;
+        }
+        if (pagesScanned >= maxPages || reachedEnd) {
+            break;
+        }
+        const prevPage = env.getCurrentPageIndex();
+        const didAdvance = await env.advancePage(useBulk);
+        if (!didAdvance) {
+            if (finalScanOnEof) {
+                (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: pagination returned false — final scan`);
+                reachedEnd = true;
+                continue;
+            }
+            break;
+        }
+        const pagesJumped = env.getCurrentPageIndex() - prevPage;
+        pagesScanned += pagesJumped > 0 ? pagesJumped : 1;
+        (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: advanced ${pagesJumped > 0 ? pagesJumped : 1} page(s), now at page ${env.getCurrentPageIndex()} (scanned=${pagesScanned})`);
+    }
+    (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: done — ${pagesScanned} page(s) scanned`);
+    return { pagesScanned };
+}

package/dist/engine/tableIteration.d.ts

@@ -20,6 +20,7 @@ export declare function runForEach<T>(env: TableIterationEnv<T>, callback: (ctx:
 /**
  * Row iteration for map (and forEach/filter via label).
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
+ * Page walking is owned by {@link scanPages} (#427).
  */
 export declare function runMap<T, R>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => R | Promise<R>, options?: RowIterationOptions, label?: string): Promise<R[]>;
 /** Filter via map; returns matched rows as {@link SmartRowArray}. */

package/dist/engine/tableIteration.js

@@ -8,6 +8,7 @@ const debugUtils_1 = require("../utils/debugUtils");
 const navigationBarrier_1 = require("../utils/navigationBarrier");
 const mutex_1 = require("../utils/mutex");
 const rowResolution_1 = require("./rowResolution");
+const scanPages_1 = require("./scanPages");
 function log(config, msg) {
     (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 }
@@ -19,15 +20,16 @@ async function runForEach(env, callback, options = {}) {
 /**
  * Row iteration for map (and forEach/filter via label).
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
+ * Page walking is owned by {@link scanPages} (#427).
  */
 async function runMap(env, callback, options = {}, label = 'map') {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e;
     const map = env.getMap();
     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
@@ -37,12 +39,11 @@ async function runMap(env, callback, options = {}, label = 'map') {
     const tracker = new elementTracker_1.ElementTracker(label);
     log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
     const results = [];
+    const seenLogicalIndices = new Set();
     try {
         let rowIndex = 0;
         let stopped = false;
         let stoppedIndex = Infinity;
-        let pagesScanned = 1;
-        let reachedEnd = false;
         const stop = (idx) => {
             if (!stopped) {
                 log(env.config, `${label}: stop() called at row ${idx} — halting`);
@@ -50,7 +51,14 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 stoppedIndex = idx;
             }
         };
-        while (!stopped) {
+        const { pagesScanned } = await (0, scanPages_1.scanPages)({
+            advancePage: env.advancePage,
+            getCurrentPageIndex: env.getCurrentPageIndex,
+            config: env.config,
+        }, async ({ pagesScanned: pageNum, isFinalScan }) => {
+            var _a;
+            if (stopped)
+                return 'stop';
             const rowLocators = env.getRowLocators();
             const allIndices = await tracker.peekUnseenIndices(rowLocators);
             const pageRows = await rowLocators.all();
@@ -63,9 +71,12 @@ async function runMap(env, callback, options = {}, label = 'map') {
             // #384: overscan rows ABOVE the visible range have already scrolled past and will never
             // re-enter the viewport — collect them now. Only defer rows BELOW the visible range
             // (they'll scroll into view on a later page).
+            //
+            // #417 follow-up: skip viewport filtering on the final scan — there are no more pages
+            // to defer to, so collect all remaining unseen rows regardless of visibility.
             let candidateIndices = allIndices;
-            const getVisibleRowIndices = (_f = env.config.strategies.viewport) === null || _f === void 0 ? void 0 : _f.getVisibleRowIndices;
-            if (getVisibleRowIndices) {
+            const getVisibleRowIndices = (_a = env.config.strategies.viewport) === null || _a === void 0 ? void 0 : _a.getVisibleRowIndices;
+            if (getVisibleRowIndices && !isFinalScan) {
                 const visible = new Set(await getVisibleRowIndices(env.getContext()));
                 const minVisible = visible.size > 0 ? Math.min(...visible) : Infinity;
                 candidateIndices = allIndices.filter(idx => visible.has(idx) || idx < minVisible);
@@ -82,10 +93,10 @@ async function runMap(env, callback, options = {}, label = 'map') {
             await tracker.commitIndices(rowLocators, newIndices);
             const batchSize = newIndices.length;
             if (batchSize === 0) {
-                log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
+                log(env.config, `${label}: page ${pageNum} — no new row(s) found`);
             }
             else {
-                log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
+                log(env.config, `${label}: scanning page ${pageNum} — ${batchSize} new row(s)`);
                 const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
                 const actionMutex = useMutex ? new mutex_1.Mutex() : null;
                 // `index` (ctx.index) is the enumeration counter — the order rows are visited,
@@ -111,6 +122,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                         if (stopped && enumIndex > stoppedIndex) {
                             return SKIP;
                         }
+                        // When resolveRowIndex is configured, identical logical indices across pages
+                        // indicate the same record (e.g. re-created DOM elements in recycling
+                        // virtualizers whose WeakMap entry was GC'd). Skip without processing.
+                        if (row.rowIndex !== undefined && seenLogicalIndices.has(row.rowIndex)) {
+                            log(env.config, `${label}: skipping duplicate logical row ${row.rowIndex}`);
+                            return SKIP;
+                        }
                         // Wait for the row to finish loading BEFORE evaluating its dedupe key (Bug #355).
                         // map/forEach/filter process a still-loading row when no timeout is set (unlike
                         // findRows, which skips) — see resolveRowLoading's `noTimeoutAction`.
@@ -141,6 +159,9 @@ async function runMap(env, callback, options = {}, label = 'map') {
                         if (dedupeKeys && dedupeKey !== undefined && result !== SKIP) {
                             dedupeKeys.add(dedupeKey);
                         }
+                        if (row.rowIndex !== undefined && result !== SKIP) {
+                            seenLogicalIndices.add(row.rowIndex);
+                        }
                         return result;
                     }
                     finally {
@@ -155,8 +176,8 @@ async function runMap(env, callback, options = {}, label = 'map') {
                     }
                 }
                 else {
-                    const results = await Promise.all(smartRows.map((row, i) => processRow(row, positionBase + i)));
-                    pageResults.push(...results);
+                    const batchResults = await Promise.all(smartRows.map((row, i) => processRow(row, positionBase + i)));
+                    pageResults.push(...batchResults);
                 }
                 for (let i = 0; i < pageResults.length; i++) {
                     if (positionBase + i > stoppedIndex)
@@ -167,16 +188,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 }
                 rowIndex += batchSize;
             }
-            if (stopped || pagesScanned >= effectiveMaxPages || reachedEnd)
-                break;
-            log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
-            if (!await env.advancePage(useBulk)) {
-                log(env.config, `${label}: pagination returned false — final scan`);
-                reachedEnd = true;
-                continue;
-            }
-            pagesScanned++;
-        }
+            return stopped ? 'stop' : 'continue';
+        }, {
+            maxPages: effectiveMaxPages,
+            useBulk,
+            label,
+            finalScanOnEof: true,
+        });
         log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
     }
     finally {

package/dist/filterEngine.d.ts

@@ -10,6 +10,10 @@ export declare class FilterEngine {
      * Note: `rootLocator` is optional for backward compatibility in call sites that already
      * pass only the page. When strategies.filter is present we construct a TableContext
      * using the provided `rootLocator`.
+     *
+     * When `strategies.getCellLocator` is set, cells are resolved through that strategy
+     * (via a `:scope` row stub) so column-virtualized grids that use `aria-colindex` / etc.
+     * are not filtered with fragile `.nth(colIndex)` DOM order.
      */
     applyFilters(baseRows: Locator, filters: Record<string, FilterValue>, map: Map<string, number>, exact: boolean, page: Page, rootLocator?: Locator): Locator;
 }

package/dist/filterEngine.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterEngine = void 0;
 const stringUtils_1 = require("./utils/stringUtils");
+const resolveCellLocator_1 = require("./utils/resolveCellLocator");
 class FilterEngine {
     constructor(config, resolve) {
         this.config = config;
@@ -13,6 +14,10 @@ class FilterEngine {
      * Note: `rootLocator` is optional for backward compatibility in call sites that already
      * pass only the page. When strategies.filter is present we construct a TableContext
      * using the provided `rootLocator`.
+     *
+     * When `strategies.getCellLocator` is set, cells are resolved through that strategy
+     * (via a `:scope` row stub) so column-virtualized grids that use `aria-colindex` / etc.
+     * are not filtered with fragile `.nth(colIndex)` DOM order.
      */
     applyFilters(baseRows, filters, map, exact, page, rootLocator) {
         var _a;
@@ -41,10 +46,16 @@ class FilterEngine {
                 });
                 continue;
             }
-            // Default Filter Logic
-            const cellTemplate = this.resolve(this.config.cellSelector, page);
-            // Playwright scoping: `cellTemplate.nth(colIndex)` will be re-based when used in filtered.filter({ has: ... })
-            const targetCell = cellTemplate.nth(colIndex);
+            // Prefer getCellLocator (column-virtualized presets); else cellSelector.nth.
+            // Playwright re-bases the `has` locator into each candidate row.
+            const targetCell = (0, resolveCellLocator_1.resolveCellLocatorForFilter)({
+                config: this.config,
+                resolve: this.resolve,
+                page,
+                root: rootLocator,
+                columnName: colName,
+                columnIndex: colIndex,
+            });
             if (typeof filterVal === 'function') {
                 // Locator-based filter: (cell) => cell.locator(...)
                 filtered = filtered.filter({

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 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, } from './types';
+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 { Strategies } from './strategies';
 export * as presets from './presets';
-/** @deprecated Use `presets` instead. Plugins will be removed in v7.0.0. */
+/**
+ * @deprecated Use `presets` instead (`presets.muiDataGrid`, `presets.rdg`, `presets.glide`, …).
+ * `Plugins` will be removed in v7.0.0.
+ * Note: `Plugins.MUI` is the **DataGrid** preset only — for MUI Table use `presets.muiTable`.
+ */
 export { Plugins } from './plugins';
 export { mergeTableConfig } from './utils/mergeTableConfig';

package/dist/index.js

@@ -42,7 +42,11 @@ Object.defineProperty(exports, "useTable", { enumerable: true, get: function ()
 var strategies_1 = require("./strategies");
 Object.defineProperty(exports, "Strategies", { enumerable: true, get: function () { return strategies_1.Strategies; } });
 exports.presets = __importStar(require("./presets"));
-/** @deprecated Use `presets` instead. Plugins will be removed in v7.0.0. */
+/**
+ * @deprecated Use `presets` instead (`presets.muiDataGrid`, `presets.rdg`, `presets.glide`, …).
+ * `Plugins` will be removed in v7.0.0.
+ * Note: `Plugins.MUI` is the **DataGrid** preset only — for MUI Table use `presets.muiTable`.
+ */
 var plugins_1 = require("./plugins");
 Object.defineProperty(exports, "Plugins", { enumerable: true, get: function () { return plugins_1.Plugins; } });
 var mergeTableConfig_1 = require("./utils/mergeTableConfig");

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.20.1";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.21.0-next.3ab7a18";

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.20.1";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.21.0-next.3ab7a18";