@rickcedwhat/playwright-smart-table 6.25.0-next.fa652fc → 6.25.0-next.ffb9625

package/dist/engine/cellNavigation.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.navigateToCell = void 0;
 const rowResolution_1 = require("./rowResolution");
 const debugUtils_1 = require("../utils/debugUtils");
+const memoizeViewport_1 = require("../utils/memoizeViewport");
 const log = (config, msg) => (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 /**
  * Navigates to a cell with active cell optimization.
@@ -49,9 +50,9 @@ const navigateToCell = async (params) => {
     };
     // Viewport-oracle phase: direct positioning for 2D virtualized tables.
     // Runs before navigation primitives; falls through to them if cell still not accessible.
-    const viewport = config.strategies.viewport;
-    if (viewport && typeof rowIndex === 'number') {
-        const viaViewport = await navigateViaViewport(nav, viewport, rowIndex);
+    const cache = config.strategies.viewport && (0, memoizeViewport_1.memoizeViewport)(config.strategies.viewport);
+    if (cache && typeof rowIndex === 'number') {
+        const viaViewport = await navigateViaViewport(nav, cache.viewport, rowIndex, cache.clear);
         if (viaViewport)
             return viaViewport;
     }
@@ -119,7 +120,7 @@ async function readIfInView(nav, viewport, rowIndex) {
  * Viewport phase. Returns the cell locator, or null to fall through to navigation primitives
  * (only when `strategies.navigation` is configured; otherwise throws on a miss).
  */
-async function navigateViaViewport(nav, viewport, rowIndex) {
+async function navigateViaViewport(nav, viewport, rowIndex, clearCache) {
     const { config, context, index } = nav;
     const inView = await readIfInView(nav, viewport, rowIndex);
     if (inView)
@@ -135,6 +136,8 @@ async function navigateViaViewport(nav, viewport, rowIndex) {
             await viewport.scrollToColumn(context, index);
         }
     });
+    // A peer may have performed the coordinated scroll. Drop this row's pre-scroll geometry too.
+    clearCache();
     await recoverEvictedRow(nav, viewport, rowIndex);
     if (await nav.targetReached()) {
         return nav.getCellLocator();

package/dist/engine/rowFinder.d.ts

@@ -3,7 +3,7 @@ import { FinalTableConfig, Selector, SmartRow, FilterValue } from '../types';
 import { FilterEngine } from '../filterEngine';
 import { TableMapper } from './tableMapper';
 import { SmartRowArray } from '../utils/smartRowArray';
-import { NavigationBarrier } from '../utils/navigationBarrier';
+import type { NavigationBarrier } from '../utils/navigationBarrier';
 export declare class RowFinder<T = any> {
     private rootLocator;
     private config;

package/dist/engine/rowFinder.js

@@ -5,7 +5,6 @@ const debugUtils_1 = require("../utils/debugUtils");
 const smartRowArray_1 = require("../utils/smartRowArray");
 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");
@@ -172,26 +171,23 @@ class RowFinder {
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
                 const currentRows = await rowLocators.all();
                 let added = 0;
-                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 rowLocator = this.nameFilteredRow(currentRows[idx], resolved, filtersRecord);
-                    const smartRow = this.makeSmartRow(rowLocator, map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
+                    // These rows outlive the scan and may be consumed individually. Only
+                    // iteration engines that own every callback can attach a batch barrier.
+                    const smartRow = this.makeSmartRow(rowLocator, map, resolved === null || resolved === void 0 ? void 0 : resolved.index, this.tableState.currentPageIndex, undefined, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                     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 ${(_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.rowLoadingTimeout}ms`);
                         }
                         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();
                         continue;
                     }
                     if (hasSyntheticFilters && !await this.matchesSyntheticFilters(currentRows[idx], syntheticFilters, map, (_d = options === null || options === void 0 ? void 0 : options.exact) !== null && _d !== void 0 ? _d : false)) {
-                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                         continue;
                     }
                     allRows.push(smartRow);

package/dist/engine/rowResolution.d.ts

@@ -29,7 +29,7 @@ export type RowLoadingOutcome = 'process' | 'skip' | 'throw';
  * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
  * case, never even probes `isRowLoading`. Both are preserved exactly.
  *
- * The helper never throws and never touches the navigation barrier; it returns a decision so
- * each caller keeps its own barrier bookkeeping and error message.
+ * Timeout returns a decision so each caller keeps its own barrier bookkeeping and error
+ * message. Predicate errors propagate unchanged.
  */
 export declare function resolveRowLoading(row: SmartRow, loading: LoadingStrategy | undefined, noTimeoutAction: 'skip' | 'process', log?: (msg: string) => void): Promise<RowLoadingOutcome>;

package/dist/engine/rowResolution.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRowIndexResult = normalizeRowIndexResult;
 exports.resolveLogicalRowIndex = resolveLogicalRowIndex;
 exports.resolveRowLoading = resolveRowLoading;
+const deadline_1 = require("../utils/deadline");
 /** Extract the numeric index from a {@link RowIndexResult}. */
 function normalizeRowIndexResult(result) {
     return typeof result === 'number' ? { index: result } : result;
@@ -36,8 +37,8 @@ async function resolveLogicalRowIndex(row, config, fallback) {
  * 'skip'`), while `map`/`forEach`/`filter` process it as-is (`'process'`) — and map, in that
  * case, never even probes `isRowLoading`. Both are preserved exactly.
  *
- * The helper never throws and never touches the navigation barrier; it returns a decision so
- * each caller keeps its own barrier bookkeeping and error message.
+ * Timeout returns a decision so each caller keeps its own barrier bookkeeping and error
+ * message. Predicate errors propagate unchanged.
  */
 async function resolveRowLoading(row, loading, noTimeoutAction, log) {
     var _a;
@@ -53,18 +54,21 @@ async function resolveRowLoading(row, loading, noTimeoutAction, log) {
     // map's fast path: with no timeout and a process-default, it never probes isRowLoading.
     if (timeout === undefined && noTimeoutAction === 'process')
         return 'process';
-    if (!(await isRowLoading(row)))
+    const deadline = Date.now() + (timeout !== null && timeout !== void 0 ? timeout : Infinity);
+    const check = () => (0, deadline_1.withinDeadline)(() => isRowLoading(row), deadline, true);
+    if (!(await check()))
         return 'process';
     // Row is loading with no timeout configured → legacy skip (findRows).
     if (timeout === undefined)
         return 'skip';
     log === null || log === void 0 ? void 0 : log(`row ${row.rowIndex} — waiting up to ${timeout}ms for row to load`);
-    const deadline = Date.now() + timeout;
-    let resolved = !(await isRowLoading(row)); // immediate check (handles timeout=0)
+    let resolved = (timeout === 0 || Date.now() < deadline) && !(await check());
     while (!resolved && Date.now() < deadline) {
         // Page accessed lazily (only while actually polling), matching the pre-refactor code.
-        await row.page().waitForTimeout(100);
-        resolved = !(await isRowLoading(row));
+        await row.page().waitForTimeout(Math.min(100, deadline - Date.now()));
+        if (Date.now() >= deadline)
+            break;
+        resolved = !(await check());
     }
     if (resolved)
         return 'process';

package/dist/engine/rowSnapshot.js

@@ -6,6 +6,7 @@ exports.readRowLive = readRowLive;
 const rowResolution_1 = require("./rowResolution");
 const cellNavigation_1 = require("./cellNavigation");
 const debugUtils_1 = require("../utils/debugUtils");
+const deadline_1 = require("../utils/deadline");
 /** `getHeaderCell` for strategy hooks: the table's when available, else an index lookup. */
 function headerCellGetter(env) {
     const { table } = env;
@@ -283,7 +284,9 @@ function cellLoadingTimeoutOf(config) {
 async function pollUntil(page, deadline, intervalMs, check, initial) {
     let done = initial;
     while (!done && Date.now() < deadline) {
-        await page.waitForTimeout(intervalMs);
+        await page.waitForTimeout(Math.min(intervalMs, deadline - Date.now()));
+        if (Date.now() >= deadline)
+            break;
         done = await check();
     }
     return done;
@@ -293,11 +296,13 @@ async function pollUntil(page, deadline, intervalMs, check, initial) {
  * indicator mounts. A single false-negative then reads "" and skips
  * onCellLoadingTimeout. Only grace when the cell still looks empty.
  */
-async function graceForLoadingIndicator(page, targetCell, isLoading, timeout) {
-    const peek = await targetCell.evaluate((el) => (el.textContent || '').trim()).catch(() => '');
+async function graceForLoadingIndicator(page, targetCell, isLoading, deadline) {
+    const peek = await (0, deadline_1.withinDeadline)(() => targetCell.evaluate((el) => (el.textContent || '').trim()).catch(() => ''), deadline, null);
+    if (peek === null)
+        return true; // Deadline expired: apply the cell loading timeout policy.
     if (peek !== '')
         return false;
-    return pollUntil(page, Date.now() + Math.min(250, timeout), 25, isLoading, false);
+    return pollUntil(page, Math.min(Date.now() + 250, deadline), 25, isLoading, false);
 }
 /** What to do when a cell is still loading after `cellLoadingTimeout`. */
 async function onStillLoading(env, targetCell, col, timeout) {
@@ -328,18 +333,19 @@ async function waitForCellLoaded(env, targetCell, col) {
     if (!isCellLoading)
         return { read: true };
     const page = env.rootLocator.page();
-    const isLoading = () => isCellLoading(targetCell, col, smart);
     const timeout = cellLoadingTimeoutOf(config);
+    const deadline = Date.now() + (timeout !== null && timeout !== void 0 ? timeout : Infinity);
+    const isLoading = () => (0, deadline_1.withinDeadline)(() => isCellLoading(targetCell, col, smart), deadline, true);
     let loading = await isLoading();
     if (!loading && timeout !== undefined && timeout > 0) {
-        loading = await graceForLoadingIndicator(page, targetCell, isLoading, timeout);
+        loading = await graceForLoadingIndicator(page, targetCell, isLoading, deadline);
     }
     if (!loading || timeout === undefined)
         return { read: true };
     (0, debugUtils_1.logDebug)(config, 'verbose', `toJSON: cell "${col}" — waiting up to ${timeout}ms`);
-    const deadline = Date.now() + timeout;
     const isLoaded = async () => !(await isLoading());
-    const cellResolved = await pollUntil(page, deadline, 100, isLoaded, await isLoaded()); // immediate check (handles timeout=0)
+    const initial = (timeout === 0 || Date.now() < deadline) && await isLoaded();
+    const cellResolved = await pollUntil(page, deadline, 100, isLoaded, initial);
     return cellResolved ? { read: true } : onStillLoading(env, targetCell, col, timeout);
 }
 /**

package/dist/engine/tableMapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableMapper = void 0;
 const headers_1 = require("../strategies/headers");
 const debugUtils_1 = require("../utils/debugUtils");
+const deadline_1 = require("../utils/deadline");
 class TableMapper {
     constructor(rootLocator, config, resolve) {
         this._headerMap = null;
@@ -21,9 +22,11 @@ class TableMapper {
         this.log('Mapping headers...');
         const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
         const startTime = Date.now();
+        const deadline = startTime + headerTimeout;
+        const remaining = () => Math.max(0, deadline - Date.now());
         if (this.config.autoScroll) {
             try {
-                await this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
+                await (0, deadline_1.withinDeadline)(() => this.rootLocator.scrollIntoViewIfNeeded({ timeout: Math.max(1, Math.min(1000, remaining())) }), deadline, undefined);
             }
             catch (e) { }
         }
@@ -39,22 +42,29 @@ class TableMapper {
         while (Date.now() - startTime < headerTimeout) {
             // 1. Wait for visibility
             try {
-                await headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
+                await (0, deadline_1.withinDeadline)(() => headerLoc.first().waitFor({ state: 'visible', timeout: Math.max(1, Math.min(200, remaining())) }), deadline, undefined);
             }
             catch (e) {
                 // Continue to check existing/loading state even if not strictly "visible" yet
             }
+            if (remaining() <= 0)
+                break;
             // 2. Check Smart Loading State
             if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
-                const isStable = !(await this.config.strategies.loading.isHeaderLoading(context));
+                const isStable = !(await (0, deadline_1.withinDeadline)(() => this.config.strategies.loading.isHeaderLoading(context), deadline, true));
                 if (!isStable) {
                     this.log('Headers are loading/unstable... waiting');
-                    await new Promise(r => setTimeout(r, 100));
+                    if (remaining() > 0)
+                        await new Promise(r => setTimeout(r, Math.min(100, remaining())));
                     continue;
                 }
             }
             // 3. Attempt Scan
+            if (remaining() <= 0)
+                break;
             try {
+                // Preserve long-running discovery strategies (e.g. horizontal header scans).
+                // The deadline bounds readiness and retries, not a strategy's own operation.
                 const rawHeaders = await strategy(context);
                 const entries = await this.processHeaders(rawHeaders);
                 // Success — validate before caching so a collision doesn't leave stale state
@@ -72,7 +82,8 @@ class TableMapper {
             catch (e) {
                 lastError = e;
                 this.log(`Header mapping failed. Attempt ${Math.floor((Date.now() - startTime) / 100)}: ${e.message}`);
-                await new Promise(r => setTimeout(r, 100));
+                if (remaining() > 0)
+                    await new Promise(r => setTimeout(r, Math.min(100, remaining())));
             }
         }
         throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);

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.25.0-next.fa652fc";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.ffb9625";

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.25.0-next.fa652fc";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.ffb9625";

package/dist/types.d.ts

@@ -210,9 +210,9 @@ export interface ViewportStrategy {
     scrollToColumn?: (context: TableContext, colIndex: number) => Promise<void>;
     /**
      * When true, disables the automatic memoization of getVisibleColumnRange and
-     * getVisibleRowRange results. By default the library caches each range value and
-     * invalidates it after the corresponding scroll call, eliminating redundant DOM
-     * evaluate() round-trips between scrolls.
+     * getVisibleRowRange results within a single cell-navigation operation. Geometry
+     * is refreshed for each new read and around scroll calls. Row membership is not
+     * memoized by the library. Caches never persist across scans, resets, or revalidation.
      */
     disableCache?: boolean;
 }
@@ -526,6 +526,7 @@ export interface LoadingStrategy {
      * How long (ms) to wait for a loading row to resolve before applying onRowLoadingTimeout.
      * Honored by findRows AND by map/forEach/filter, where the wait runs before the dedupe
      * strategy so content-based dedupe keys see the row's final loaded state.
+     * Includes time spent awaiting the loading predicate, even if it never settles.
      * When not set (backward-compatible behavior): findRows skips loading rows immediately;
      * map/forEach/filter process them as-is.
      */
@@ -546,6 +547,7 @@ export interface LoadingStrategy {
     isCellLoading?: (cell: import('@playwright/test').Locator, columnName: string, row: SmartRow) => Promise<boolean>;
     /**
      * How long (ms) to wait for a loading cell to resolve before applying onCellLoadingTimeout.
+     * Includes predicate evaluation and any initial rendering grace period.
      * When not set and isCellLoading returns true, the cell is read as-is immediately.
      */
     cellLoadingTimeout?: number;
@@ -910,6 +912,8 @@ export interface TableResult<T = any> extends AsyncIterable<{
     /**
      * ASYNC: Searches for all matching rows across pages using pagination.
      * Auto-initializes the table if not already initialized.
+     * Returned rows can be read independently, including with `concurrency: 'synchronized'`.
+     * Use synchronized `map()` for coordinated column scrolling across virtualized rows.
      * @param filters - The filter criteria to match (omit or pass {} for all rows)
      * @param options - Search options (exact, maxPages). `useBulkPagination` defaults to `false`: pages advance one at a time via `goNext` so no intermediate page is skipped. Set it to `true` to opt into `goNextBulk` (faster, but skips the rows on jumped-over pages). `signal` cancels the page scan; the call rejects with `signal.reason`.
      */

package/dist/useTable.js

@@ -53,52 +53,6 @@ const useTable = (rootLocator, configOptions = {}) => {
         }
     };
     const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: async () => { } }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
-    // Automatically memoize viewport range oracles so user-provided functions are
-    // pure DOM queries with no cache bookkeeping. Invalidated after each scroll call.
-    let _clearViewportCache = null;
-    if (config.strategies.viewport && !config.strategies.viewport.disableCache) {
-        const vp = config.strategies.viewport;
-        let colRangeCache = null;
-        let rowRangeCache = null;
-        let rowIndicesCache = null;
-        _clearViewportCache = () => {
-            colRangeCache = null;
-            rowRangeCache = null;
-            rowIndicesCache = null;
-        };
-        config.strategies.viewport = Object.assign(Object.assign({}, vp), { getVisibleColumnRange: vp.getVisibleColumnRange
-                ? async (ctx) => {
-                    if (!colRangeCache)
-                        colRangeCache = await vp.getVisibleColumnRange(ctx);
-                    return colRangeCache;
-                }
-                : undefined, getVisibleRowRange: vp.getVisibleRowRange
-                ? async (ctx) => {
-                    if (!rowRangeCache)
-                        rowRangeCache = await vp.getVisibleRowRange(ctx);
-                    return rowRangeCache;
-                }
-                : undefined, getVisibleRowIndices: vp.getVisibleRowIndices
-                ? async (ctx) => {
-                    if (!rowIndicesCache)
-                        rowIndicesCache = await vp.getVisibleRowIndices(ctx);
-                    return rowIndicesCache;
-                }
-                : undefined, scrollToColumn: vp.scrollToColumn
-                ? async (ctx, colIndex) => {
-                    colRangeCache = null;
-                    rowRangeCache = null;
-                    rowIndicesCache = null;
-                    await vp.scrollToColumn(ctx, colIndex);
-                }
-                : undefined, scrollToRow: vp.scrollToRow
-                ? async (ctx, rowIndex) => {
-                    rowRangeCache = null;
-                    rowIndicesCache = null;
-                    await vp.scrollToRow(ctx, rowIndex);
-                }
-                : undefined });
-    }
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -213,10 +167,6 @@ const useTable = (rootLocator, configOptions = {}) => {
         if (pagesJumped > 0) {
             tableState.currentPageIndex += pagesJumped;
             log(`_advancePage: ${primitive} advanced ${pagesJumped} page(s) — now at page ${tableState.currentPageIndex}`);
-            // Invalidate viewport caches: after a page advance the row set changes and the
-            // column renderer may recalculate (e.g. scrollbar appearance changes available width).
-            if (_clearViewportCache)
-                _clearViewportCache();
             await (0, debugUtils_1.debugDelay)(config, 'pagination');
         }
         else {

package/dist/utils/deadline.d.ts

@@ -0,0 +1,2 @@
+/** Bound one asynchronous check by an existing deadline, without cancelling its underlying work. */
+export declare function withinDeadline<T>(check: () => Promise<T>, deadline: number, expiredValue: T): Promise<T>;

package/dist/utils/deadline.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withinDeadline = withinDeadline;
+/** Bound one asynchronous check by an existing deadline, without cancelling its underlying work. */
+async function withinDeadline(check, deadline, expiredValue) {
+    if (!Number.isFinite(deadline))
+        return check();
+    let timer;
+    try {
+        const expired = new Promise(resolve => {
+            timer = setTimeout(() => resolve(expiredValue), Math.max(0, deadline - Date.now()));
+        });
+        // A late rejection is handled by the race even after the deadline wins.
+        return await Promise.race([check(), expired]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/utils/memoizeViewport.d.ts

@@ -0,0 +1,6 @@
+import type { ViewportStrategy } from '../types';
+/** Cache geometry only for one navigation; scans and later reads use the original oracles. */
+export declare function memoizeViewport(viewport: ViewportStrategy): {
+    viewport: ViewportStrategy;
+    clear: () => void;
+};

package/dist/utils/memoizeViewport.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeViewport = memoizeViewport;
+/** Cache geometry only for one navigation; scans and later reads use the original oracles. */
+function memoizeViewport(viewport) {
+    if (viewport.disableCache)
+        return { viewport, clear: () => { } };
+    let columns;
+    let rows;
+    const clear = () => { columns = undefined; rows = undefined; };
+    const wrapScroll = (scroll) => scroll && (async (context, index) => {
+        clear();
+        try {
+            await scroll.call(viewport, context, index);
+        }
+        finally {
+            clear();
+        }
+    });
+    return {
+        clear,
+        viewport: Object.assign(Object.assign({}, viewport), { getVisibleColumnRange: viewport.getVisibleColumnRange
+                ? context => columns !== null && columns !== void 0 ? columns : (columns = viewport.getVisibleColumnRange(context))
+                : undefined, getVisibleRowRange: viewport.getVisibleRowRange
+                ? context => rows !== null && rows !== void 0 ? rows : (rows = viewport.getVisibleRowRange(context))
+                : undefined, scrollToColumn: wrapScroll(viewport.scrollToColumn), scrollToRow: wrapScroll(viewport.scrollToRow) }),
+    };
+}

package/dist/utils/smartRowArray.d.ts

@@ -4,7 +4,7 @@ import { SmartRow } from '../types';
  */
 export interface SmartRowArray<T = any> extends Array<SmartRow<T>> {
     /**
-     * Converts all rows to JSON objects
+     * Converts all rows to JSON objects, reading sequentially to avoid competing viewport moves.
      */
     toJSON(): Promise<T[]>;
 }

package/dist/utils/smartRowArray.js

@@ -7,7 +7,10 @@ exports.createSmartRowArray = createSmartRowArray;
 function createSmartRowArray(rows) {
     const arr = rows;
     arr.toJSON = async () => {
-        return Promise.all(rows.map(r => r.toJSON()));
+        const results = [];
+        for (const row of rows)
+            results.push(await row.toJSON());
+        return results;
     };
     return arr;
 }

package/package.json

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