@rickcedwhat/playwright-smart-table 6.25.0-next.0d74239 → 6.25.0-next.1e71a54

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;
@@ -35,6 +36,15 @@ async function computeSyntheticColumns(env, result, columns) {
     }
 }
 const isBatchRow = (row) => row._inBatch === true || !!row._barrier;
+/** Capture a mounted position's identity once, before readiness or navigation can recycle it. */
+async function resolveSnapshotIdentity(env) {
+    if (!env.renderWindowPosition || !env.config.strategies.resolveRowIndex)
+        return env;
+    const identity = await (0, rowResolution_1.resolveLogicalRowIndex)(env.rowLocator, env.config, () => undefined);
+    // Keep the public SmartRow's mounted position unchanged; all snapshot recovery and
+    // navigation use this read's logical identity. An unknown identity is not position 0.
+    return Object.assign(Object.assign({}, env), { rowIndex: identity === null || identity === void 0 ? void 0 : identity.index, renderWindowPosition: false });
+}
 // ─── Atomic snapshot ─────────────────────────────────────────────────────────
 /** Mounted row whose logical index (per resolveRowIndex) is `rowIndex`; tolerates rows detaching mid-scan. */
 async function rescanForRow(env, rowIndex) {
@@ -107,9 +117,7 @@ async function resolveCloneTarget(env) {
         await config.strategies.contentReady(cloneTarget, env.rootLocator.page());
         // Revalidate: the element may have recycled during the await.
         if (canRepin && await logicalIndexOf(env, cloneTarget) !== rowIndex) {
-            const reFound = await rescanForRow(env, rowIndex);
-            if (reFound)
-                cloneTarget = reFound;
+            cloneTarget = await recoverDriftedRow(env, rowIndex);
         }
     }
     return cloneTarget;
@@ -148,6 +156,7 @@ async function readRowAtomic(env, columns) {
     if (typeof cellSel !== 'string') {
         throw new Error('[SmartTable] toJSON({ atomic: true }) requires cellSelector to be a CSS string, not a function.');
     }
+    env = await resolveSnapshotIdentity(env);
     const page = rootLocator.page();
     const snapshot = await cloneRow(await resolveCloneTarget(env), cellSel);
     // Determine which columns have overrides (need lazy materialization)
@@ -275,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;
@@ -285,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) {
@@ -320,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);
 }
 /**
@@ -340,6 +354,7 @@ async function waitForCellLoaded(env, targetCell, col) {
  */
 async function readRowLive(env, columns) {
     var _a, _b, _c;
+    env = await resolveSnapshotIdentity(env);
     const { config, map, rootLocator, rowIndex } = env;
     const result = {};
     const page = rootLocator.page();

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.0d74239";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.1e71a54";

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.0d74239";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.1e71a54";

package/dist/types.d.ts

@@ -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/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/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.0d74239",
+  "version": "6.25.0-next.1e71a54",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",