@rickcedwhat/playwright-smart-table 6.20.1-next.b5aa4bd → 6.20.1-next.dbc9618

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 {
@@ -145,11 +145,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;
@@ -277,12 +277,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();
         },
@@ -381,19 +388,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;
@@ -494,7 +516,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;
@@ -615,43 +637,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/package.json

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