@rickcedwhat/playwright-smart-table 6.20.0 → 6.20.1-next.1d11eb1

package/dist/useTable.js

@@ -28,10 +28,10 @@ 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");
 // Helper to safely serialize objects containing functions for logging
 const safeStringify = (obj) => {
     try {
@@ -301,7 +301,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 +359,15 @@ 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();
+                while (await isTableLoading(ctx)) {
+                    log('countRows: table is loading... waiting');
+                    await rootLocator.page().waitForTimeout(200);
+                }
+            }
             if (!hasPagination) {
                 log(`countRows: counting rows in current viewport (no pagination)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
                 if (!hasPostFilters)
@@ -372,19 +381,34 @@ 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();
+                        while (await isTableLoading(ctx)) {
+                            log('countRows: table is loading... waiting');
+                            await rootLocator.page().waitForTimeout(200);
+                        }
+                    },
+                }, 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 +452,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 +491,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.');
@@ -597,43 +630,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; }));
+                        }
+                        while (queue.length > 0) {
+                            yield yield __await(queue.shift());
+                            release === null || release === void 0 ? void 0 : release();
+                            release = undefined;
                         }
-                        if (pagesScanned >= effectiveMaxPages)
-                            break;
-                        if (!(yield __await(_advancePage(useBulk))))
-                            break;
-                        pagesScanned++;
+                        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(() => { }));
                 }
             });
         },

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/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.0",
+  "version": "6.20.1-next.1d11eb1",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -110,6 +110,11 @@
   "peerDependencies": {
     "@playwright/test": "^1.40.0"
   },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@commitlint/cli": "^21.0.0",
     "@commitlint/config-conventional": "^21.0.0",