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

package/dist/useTable.js

@@ -28,10 +28,12 @@ const tableMapper_1 = require("./engine/tableMapper");
 const rowFinder_1 = require("./engine/rowFinder");
 const tableIteration_1 = require("./engine/tableIteration");
 const rowResolution_1 = require("./engine/rowResolution");
+const scanPages_1 = require("./engine/scanPages");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
 const elementTracker_1 = require("./utils/elementTracker");
-const navigationBarrier_1 = require("./utils/navigationBarrier");
+const loadingWait_1 = require("./utils/loadingWait");
+const pageIndex_1 = require("./utils/pageIndex");
 // Helper to safely serialize objects containing functions for logging
 const safeStringify = (obj) => {
     try {
@@ -145,11 +147,11 @@ const useTable = (rootLocator, configOptions = {}) => {
     // Placeholder for the final table object
     let finalTable = null;
     // Helper factory
-    const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex, barrier, rowSelector) => {
+    const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex, barrier, rowSelector, renderWindowPosition = false) => {
         const effectiveLocator = rowSelector
             ? rootLocator.locator(rowSelector)
             : rowLocator;
-        const sr = (0, smartRow_1.default)(effectiveLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier);
+        const sr = (0, smartRow_1.default)(effectiveLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier, renderWindowPosition);
         if (rowSelector)
             sr._selfHealing = true;
         return sr;
@@ -183,7 +185,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     const _handlePrompt = async (promptName, content) => {
         let finalPrompt = content;
         finalPrompt += `\n\n👇 Useful TypeScript Definitions 👇\n\`\`\`typescript\n${minimalConfigContext_1.MINIMAL_CONFIG_CONTEXT}\n\`\`\`\n`;
-        console.log(`⚠️ Throwing error to display [${promptName}] cleanly...`);
+        (0, debugUtils_1.logDebug)(config, 'info', `Throwing error to display [${promptName}] cleanly...`);
         throw new Error(finalPrompt);
     };
     const _autoInit = async () => {
@@ -229,9 +231,12 @@ const useTable = (rootLocator, configOptions = {}) => {
     };
     const result = {
         get currentPageIndex() { return tableState.currentPageIndex; },
-        set currentPageIndex(v) { tableState.currentPageIndex = v; },
+        set currentPageIndex(v) {
+            console.warn('[SmartTable] Manually assigning table.currentPageIndex can desync pagination path planning. Prefer reset() / library navigation; writable access may become read-only in v7.');
+            tableState.currentPageIndex = v;
+        },
         init: async (options) => {
-            var _a;
+            var _a, _b, _c;
             if (tableMapper.isInitialized() || tableState.empty)
                 return result;
             if (config.strategies.sorting)
@@ -240,6 +245,10 @@ const useTable = (rootLocator, configOptions = {}) => {
                 (0, validation_1.validateFillStrategy)(config.strategies.fill);
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
+            if (config.maxPages === 1 &&
+                (((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goNext) || ((_b = config.strategies.pagination) === null || _b === void 0 ? void 0 : _b.goNextBulk))) {
+                console.warn('[SmartTable] maxPages is 1 but a pagination strategy is configured — iteration/find will never leave page 1. Pass maxPages: N (or Infinity) to scan further pages.');
+            }
             let map;
             try {
                 map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
@@ -256,7 +265,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw headerError;
             }
             (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${map.size} columns`, Array.from(map.keys()));
-            if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.detectCurrentPage) {
+            if ((_c = config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.detectCurrentPage) {
                 try {
                     const detected = await config.strategies.pagination.detectCurrentPage(rootLocator);
                     if (Number.isInteger(detected) && detected >= 0) {
@@ -277,12 +286,19 @@ const useTable = (rootLocator, configOptions = {}) => {
             return result;
         },
         scrollToColumn: async (columnName) => {
+            var _a;
             log(`scrollToColumn: column="${columnName}"`);
             const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map);
-            // Use header cell for scrolling
+            // Prefer viewport strategy when configured (#430). Raw scrollIntoViewIfNeeded on a
+            // header can shift Y and evict virtualized rows; viewport.scrollToColumn is X-aware.
+            const viewportScroll = (_a = config.strategies.viewport) === null || _a === void 0 ? void 0 : _a.scrollToColumn;
+            if (viewportScroll) {
+                await viewportScroll(createStrategyContext(), idx);
+                return;
+            }
             const headerCell = resolve(config.headerSelector, rootLocator).nth(idx);
             await headerCell.scrollIntoViewIfNeeded();
         },
@@ -301,7 +317,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             return resolve(config.headerSelector, rootLocator).nth(idx);
         },
         countRows: async (filters, options) => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             if (tableState.empty)
                 return 0;
             await _autoInit();
@@ -359,6 +375,12 @@ const useTable = (rootLocator, configOptions = {}) => {
                 }
                 return count;
             };
+            // Wait for table to finish loading before counting
+            const isTableLoading = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.isTableLoading;
+            if (isTableLoading) {
+                const ctx = createStrategyContext();
+                await (0, loadingWait_1.waitWhileTableLoading)(config, ctx, rootLocator.page(), 'countRows');
+            }
             if (!hasPagination) {
                 log(`countRows: counting rows in current viewport (no pagination)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
                 if (!hasPostFilters)
@@ -372,19 +394,31 @@ const useTable = (rootLocator, configOptions = {}) => {
             let pagesScanned = 1;
             let paginationError;
             try {
-                while (true) {
+                const scanned = await (0, scanPages_1.scanPages)({
+                    advancePage: _advancePage,
+                    getCurrentPageIndex: () => tableState.currentPageIndex,
+                    config,
+                    waitForReady: async () => {
+                        if (!isTableLoading)
+                            return;
+                        const ctx = createStrategyContext();
+                        await (0, loadingWait_1.waitWhileTableLoading)(config, ctx, rootLocator.page(), 'countRows');
+                    },
+                }, async ({ pagesScanned: pageNum }) => {
                     const rowLocators = resolveRows();
                     const newIndices = await tracker.getUnseenIndices(rowLocators);
                     const candidates = await rowLocators.all();
                     const matched = await countPostFilterMatches(candidates, newIndices);
                     total += matched;
-                    log(`countRows: page ${pagesScanned} — ${matched} row(s) (running total: ${total})`);
-                    if (pagesScanned >= effectiveMaxPages)
-                        break;
-                    if (!await _advancePage(false))
-                        break;
-                    pagesScanned++;
-                }
+                    log(`countRows: page ${pageNum} — ${matched} row(s) (running total: ${total})`);
+                    return 'continue';
+                }, {
+                    maxPages: effectiveMaxPages,
+                    useBulk: false,
+                    label: 'countRows',
+                    finalScanOnEof: true,
+                });
+                pagesScanned = scanned.pagesScanned;
             }
             catch (e) {
                 paginationError = e;
@@ -428,6 +462,10 @@ const useTable = (rootLocator, configOptions = {}) => {
                 return (text || '').trim();
             }, options);
         },
+        /**
+         * @deprecated Use `mapColumn` (or `map`) instead. Will be removed in v7.0.0.
+         * Iterates over rows and extracts the value of a single column as strings.
+         */
         getColumnValues: async (columnName, options = {}) => {
             log(`getColumnValues: column="${columnName}" options=${safeStringify(options)}`);
             const values = await result.mapColumn(columnName, options);
@@ -463,6 +501,11 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw new Error(`getRow() cannot filter by synthetic column(s): ${syntheticKeys.join(', ')}. ` +
                     `Use findRow() instead — synthetic columns require async evaluation.`);
             }
+            const overrideKeys = Object.keys(filters).filter(k => { var _a, _b; return (_b = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[k]) === null || _b === void 0 ? void 0 : _b.read; });
+            if (overrideKeys.length > 0) {
+                throw new Error(`getRow() cannot filter by columnOverrides.read column(s): ${overrideKeys.join(', ')}. ` +
+                    `Use findRow() instead — override columns require async evaluation.`);
+            }
             const map = tableMapper.getMapSync();
             if (!map)
                 throw new Error('Initialization Error: You attempted to access a row before the table structure was mapped. Please call "await table.init()" once before using synchronous row access.');
@@ -476,7 +519,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             if (!map)
                 throw new Error('Initialization Error: You attempted to access a row before the table structure was mapped. Please call "await table.init()" once before using synchronous row access.');
             const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
-            return _makeSmart(rowLocator, map, index);
+            return _makeSmart(rowLocator, map, index, undefined, undefined, undefined, true);
         },
         findRowByIndex: async (index, options) => {
             var _a, _b;
@@ -552,7 +595,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         sorting: {
             apply: async (columnName, direction) => {
-                var _a, _b, _c, _d, _e;
+                var _a, _b, _c, _d, _e, _f;
                 await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
@@ -567,15 +610,15 @@ const useTable = (rootLocator, configOptions = {}) => {
                     }
                     await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        const timeout = (_b = config.strategies.loading.sortStabilizationTimeout) !== null && _b !== void 0 ? _b : 10000;
-                        const poll = (_c = config.strategies.loading.sortStabilizationPollInterval) !== null && _c !== void 0 ? _c : 100;
-                        const deadline = Date.now() + timeout;
-                        while (Date.now() < deadline && await config.strategies.loading.isTableLoading(context)) {
-                            await rootLocator.page().waitForTimeout(poll);
-                        }
+                        const timeout = (_c = (_b = config.strategies.loading.sortStabilizationTimeout) !== null && _b !== void 0 ? _b : config.strategies.loading.loadingTimeout) !== null && _c !== void 0 ? _c : 10000;
+                        const poll = (_d = config.strategies.loading.sortStabilizationPollInterval) !== null && _d !== void 0 ? _d : 100;
+                        await (0, loadingWait_1.waitWhileTableLoading)(config, context, rootLocator.page(), 'sorting.apply', {
+                            timeout,
+                            pollInterval: poll,
+                        });
                     }
                     else {
-                        const fallback = (_e = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.sortStabilizationFallbackDelay) !== null && _e !== void 0 ? _e : 200;
+                        const fallback = (_f = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.sortStabilizationFallbackDelay) !== null && _f !== void 0 ? _f : 200;
                         await rootLocator.page().waitForTimeout(fallback);
                     }
                     await (0, debugUtils_1.debugDelay)(config, 'default');
@@ -597,43 +640,65 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
         },
         // ─── Shared async row iterator ───────────────────────────────────────────
+        /**
+         * Streams rows using the same page-walk + collection path as `map` / `forEach`
+         * (`scanPages` + runMap): overscan filtering, loading-before-dedupe, EOF final
+         * scan, and config dedupe. Concurrency is sequential so yields stay ordered. (#427)
+         */
         [Symbol.asyncIterator]() {
             return __asyncGenerator(this, arguments, function* _a() {
-                var _b;
                 yield __await(_autoInit());
-                const map = tableMapper.getMapSync();
-                const effectiveMaxPages = config.maxPages;
-                const tracker = new elementTracker_1.ElementTracker('iterator');
-                const useBulk = false; // iterator has no options; default goNext
-                log(`iterator: starting (maxPages=${effectiveMaxPages})`);
+                log(`iterator: starting via runMap (maxPages=${config.maxPages})`);
+                const queue = [];
+                let notify;
+                let release;
+                let finished = false;
+                let cancelled = false;
+                let runError;
+                const wake = () => {
+                    notify === null || notify === void 0 ? void 0 : notify();
+                    notify = undefined;
+                };
+                const runPromise = (0, tableIteration_1.runMap)({
+                    getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                    getMap: () => tableMapper.getMapSync(),
+                    advancePage: _advancePage,
+                    makeSmartRow: (loc, map, idx, pageIdx, barrier, sel) => _makeSmart(loc, map, idx, pageIdx, barrier, sel),
+                    createSmartRowArray: smartRowArray_1.createSmartRowArray,
+                    config,
+                    getPage: () => rootLocator.page(),
+                    getCurrentPageIndex: () => tableState.currentPageIndex,
+                    getContext: () => createStrategyContext(),
+                }, async (ctx) => {
+                    queue.push({
+                        row: ctx.row,
+                        index: ctx.index,
+                        rowIndex: ctx.rowIndex,
+                        pageIndex: ctx.pageIndex,
+                    });
+                    wake();
+                    await new Promise((resolve) => { release = resolve; });
+                    if (cancelled)
+                        ctx.stop();
+                }, { concurrency: 'sequential' }, 'iterator').then(() => { finished = true; wake(); }, (err) => { runError = err; finished = true; wake(); });
                 try {
-                    let rowIndex = 0;
-                    let pagesScanned = 1;
-                    while (true) {
-                        const rowLocators = resolve(config.rowSelector, rootLocator);
-                        const newIndices = yield __await(tracker.getUnseenIndices(rowLocators));
-                        const pageRows = yield __await(rowLocators.all());
-                        const barrier = new navigationBarrier_1.NavigationBarrier(newIndices.length);
-                        for (const idx of newIndices) {
-                            // index = visit-order counter; rowIndex = logical/data index (B-hybrid, #362).
-                            const resolved = yield __await((0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], config, () => rowIndex));
-                            const logical = (_b = resolved === null || resolved === void 0 ? void 0 : resolved.index) !== null && _b !== void 0 ? _b : rowIndex;
-                            const sr = _makeSmart(pageRows[idx], map, logical, tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
-                            // Iterator rows share one per-page DOM snapshot (positional locators); disable
-                            // toJSON's scroll-back recovery so reading one row can't invalidate the others (#366).
-                            sr._inBatch = true;
-                            yield yield __await({ row: sr, index: rowIndex, rowIndex: logical, pageIndex: tableState.currentPageIndex });
-                            rowIndex++;
+                    while (!finished || queue.length > 0) {
+                        if (queue.length === 0) {
+                            yield __await(new Promise((resolve) => { notify = resolve; }));
                         }
-                        if (pagesScanned >= effectiveMaxPages)
-                            break;
-                        if (!(yield __await(_advancePage(useBulk))))
-                            break;
-                        pagesScanned++;
+                        while (queue.length > 0) {
+                            yield yield __await(queue.shift());
+                            release === null || release === void 0 ? void 0 : release();
+                            release = undefined;
+                        }
+                        if (runError)
+                            throw runError;
                     }
                 }
                 finally {
-                    yield __await(tracker.cleanup(rootLocator.page()));
+                    cancelled = true;
+                    release === null || release === void 0 ? void 0 : release();
+                    yield __await(runPromise.catch(() => { }));
                 }
             });
         },
@@ -705,10 +770,14 @@ const useTable = (rootLocator, configOptions = {}) => {
             await _handlePrompt('Smart Table Config', content);
         },
         generateConfigPrompt: async () => {
-            console.warn('⚠️ [playwright-smart-table] generateConfigPrompt() is deprecated and will be removed in v7.0.0. Please use generateConfig() instead.');
+            (0, debugUtils_1.logDebug)(config, 'error', 'generateConfigPrompt() is deprecated and will be removed in v7.0.0. Please use generateConfig() instead.');
             return result.generateConfig();
         },
     };
+    Object.defineProperty(result, pageIndex_1.SET_CURRENT_PAGE_INDEX, {
+        value: (v) => { tableState.currentPageIndex = v; },
+        enumerable: false,
+    });
     createStrategyContext = () => ({
         root: rootLocator,
         config,

package/dist/utils/elementTracker.js

@@ -18,7 +18,8 @@ class ElementTracker {
             const seenMap = win[trackerId];
             const newIndices = [];
             elements.forEach((el, index) => {
-                const signature = el.textContent || '';
+                const htmlEl = el;
+                const signature = htmlEl.offsetTop + '|' + (el.textContent || '');
                 if (seenMap.get(el) !== signature) {
                     newIndices.push(index);
                 }
@@ -39,8 +40,10 @@ class ElementTracker {
             const seenMap = win[trackerId];
             for (const index of indicesToCommit) {
                 const el = elements[index];
-                if (el)
-                    seenMap.set(el, el.textContent || '');
+                if (el) {
+                    const htmlEl = el;
+                    seenMap.set(el, htmlEl.offsetTop + '|' + (el.textContent || ''));
+                }
             }
         }, [this.id, indices]);
     }

package/dist/utils/loadingWait.d.ts

@@ -0,0 +1,15 @@
+import type { Page } from '@playwright/test';
+import type { FinalTableConfig, TableContext } from '../types';
+/**
+ * Poll `loading.isTableLoading` until false or timeout.
+ * Shared by countRows, findRow(s), and sort stabilization (#434).
+ *
+ * Timeout resolution (first defined wins):
+ * 1. Explicit `options.timeout` — e.g. the sort caller's stabilization timeout
+ * 2. `loadingTimeout` — general gate for any isTableLoading poll
+ * 3. 10_000 ms default
+ */
+export declare function waitWhileTableLoading(config: FinalTableConfig, context: TableContext, page: Page, label: string, options?: {
+    timeout?: number;
+    pollInterval?: number;
+}): Promise<void>;

package/dist/utils/loadingWait.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitWhileTableLoading = waitWhileTableLoading;
+const debugUtils_1 = require("./debugUtils");
+/**
+ * Poll `loading.isTableLoading` until false or timeout.
+ * Shared by countRows, findRow(s), and sort stabilization (#434).
+ *
+ * Timeout resolution (first defined wins):
+ * 1. Explicit `options.timeout` — e.g. the sort caller's stabilization timeout
+ * 2. `loadingTimeout` — general gate for any isTableLoading poll
+ * 3. 10_000 ms default
+ */
+async function waitWhileTableLoading(config, context, page, label, options) {
+    var _a, _b, _c, _d, _e;
+    const isTableLoading = (_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading;
+    if (!isTableLoading)
+        return;
+    const loading = config.strategies.loading;
+    const timeout = (_c = (_b = options === null || options === void 0 ? void 0 : options.timeout) !== null && _b !== void 0 ? _b : loading.loadingTimeout) !== null && _c !== void 0 ? _c : 10000;
+    const poll = (_e = (_d = options === null || options === void 0 ? void 0 : options.pollInterval) !== null && _d !== void 0 ? _d : loading.sortStabilizationPollInterval) !== null && _e !== void 0 ? _e : 200;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        let timer;
+        try {
+            // A custom predicate may never settle. Stop waiting when the budget expires;
+            // Promise.race also handles any later rejection from that predicate.
+            const expired = new Promise(resolve => {
+                timer = setTimeout(() => resolve(false), Math.max(0, deadline - Date.now()));
+            });
+            if (!(await Promise.race([isTableLoading(context), expired])))
+                return;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return;
+        (0, debugUtils_1.logDebug)(config, 'verbose', `${label}: table is loading... waiting`);
+        await page.waitForTimeout(Math.min(poll, remaining));
+    }
+}

package/dist/utils/pageIndex.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal setter for `table.currentPageIndex` used by library navigation
+ * (bringIntoView path planner, etc.) so the public setter can warn on
+ * external writes without spamming on every library update (#434).
+ */
+export declare const SET_CURRENT_PAGE_INDEX: unique symbol;
+export type PageIndexWritable = {
+    currentPageIndex: number;
+    [SET_CURRENT_PAGE_INDEX]?: (n: number) => void;
+};
+/** Prefer the internal setter when present; fall back to the public property. */
+export declare function setCurrentPageIndex(table: PageIndexWritable, n: number): void;

package/dist/utils/pageIndex.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_CURRENT_PAGE_INDEX = void 0;
+exports.setCurrentPageIndex = setCurrentPageIndex;
+/**
+ * Internal setter for `table.currentPageIndex` used by library navigation
+ * (bringIntoView path planner, etc.) so the public setter can warn on
+ * external writes without spamming on every library update (#434).
+ */
+exports.SET_CURRENT_PAGE_INDEX = Symbol.for('playwright-smart-table.setCurrentPageIndex');
+/** Prefer the internal setter when present; fall back to the public property. */
+function setCurrentPageIndex(table, n) {
+    const internal = table[exports.SET_CURRENT_PAGE_INDEX];
+    if (typeof internal === 'function') {
+        internal(n);
+        return;
+    }
+    table.currentPageIndex = n;
+}

package/dist/utils/resolveCellLocator.d.ts

@@ -0,0 +1,35 @@
+import type { Locator, Page } from '@playwright/test';
+import type { FinalTableConfig, Selector } from '../types';
+/**
+ * Resolve a cell locator for a concrete row — prefers `strategies.getCellLocator`,
+ * otherwise `cellSelector` + `.nth(columnIndex)`.
+ */
+export declare function resolveCellLocator(args: {
+    config: FinalTableConfig;
+    resolve: (selector: Selector, parent: Locator | Page) => Locator;
+    row: Locator;
+    root: Locator;
+    columnName: string;
+    columnIndex: number;
+    rowIndex?: number;
+    page?: Page;
+}): Locator;
+/**
+ * Cell locator for Playwright `rows.filter({ has })`.
+ *
+ * When `getCellLocator` is set, pass `page.locator(':scope')` as the row so the
+ * strategy's `row.locator(...)` chain stays relative to each candidate row under
+ * `filter({ has })`. Using the rows collection or a document-rooted parent nests
+ * the row selector and matches nothing.
+ *
+ * Without `getCellLocator`, keeps the historical page-scoped `cellSelector.nth(i)`
+ * template that Playwright re-bases into each row.
+ */
+export declare function resolveCellLocatorForFilter(args: {
+    config: FinalTableConfig;
+    resolve: (selector: Selector, parent: Locator | Page) => Locator;
+    page: Page;
+    root?: Locator;
+    columnName: string;
+    columnIndex: number;
+}): Locator;

package/dist/utils/resolveCellLocator.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCellLocator = resolveCellLocator;
+exports.resolveCellLocatorForFilter = resolveCellLocatorForFilter;
+/**
+ * Resolve a cell locator for a concrete row — prefers `strategies.getCellLocator`,
+ * otherwise `cellSelector` + `.nth(columnIndex)`.
+ */
+function resolveCellLocator(args) {
+    var _a, _b;
+    const { config, resolve, row, root, columnName, columnIndex, rowIndex } = args;
+    const page = (_a = args.page) !== null && _a !== void 0 ? _a : root.page();
+    if ((_b = config.strategies) === null || _b === void 0 ? void 0 : _b.getCellLocator) {
+        return config.strategies.getCellLocator({
+            row,
+            root,
+            columnName,
+            columnIndex,
+            rowIndex,
+            page,
+            config,
+        });
+    }
+    return resolve(config.cellSelector, row).nth(columnIndex);
+}
+/**
+ * Cell locator for Playwright `rows.filter({ has })`.
+ *
+ * When `getCellLocator` is set, pass `page.locator(':scope')` as the row so the
+ * strategy's `row.locator(...)` chain stays relative to each candidate row under
+ * `filter({ has })`. Using the rows collection or a document-rooted parent nests
+ * the row selector and matches nothing.
+ *
+ * Without `getCellLocator`, keeps the historical page-scoped `cellSelector.nth(i)`
+ * template that Playwright re-bases into each row.
+ */
+function resolveCellLocatorForFilter(args) {
+    var _a;
+    const { config, resolve, page, root, columnName, columnIndex } = args;
+    if ((_a = config.strategies) === null || _a === void 0 ? void 0 : _a.getCellLocator) {
+        const scopeRow = page.locator(':scope');
+        return config.strategies.getCellLocator({
+            row: scopeRow,
+            root: root !== null && root !== void 0 ? root : scopeRow,
+            columnName,
+            columnIndex,
+            page,
+            config,
+        });
+    }
+    return resolve(config.cellSelector, page).nth(columnIndex);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.20.1",
+  "version": "6.21.0-next.3ab7a18",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",