@rickcedwhat/playwright-smart-table 6.25.0-next.c81cb3d → 6.25.0-next.f72ee4c

package/dist/engine/countRows.d.ts

@@ -24,4 +24,5 @@ export interface CountRowsEnv<T = any> {
 export declare function countRows<T>(env: CountRowsEnv<T>, filters?: Record<string, FilterValue>, options?: {
     exact?: boolean;
     maxPages?: number;
+    signal?: AbortSignal;
 }): Promise<number>;

package/dist/engine/countRows.js

@@ -40,15 +40,15 @@ function requireMap(tableMapper) {
  * Callers must have initialized the table.
  */
 async function countRows(env, filters, options) {
-    var _a;
-    var _b, _c;
+    var _a, _b, _c, _d, _e;
+    var _f, _g;
     const { config, rootLocator, tableMapper, rowFinder } = env;
     const filtersRecord = filters !== null && filters !== void 0 ? filters : {};
     const hasFilters = Object.keys(filtersRecord).length > 0;
-    const effectiveMaxPages = (_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages;
+    const effectiveMaxPages = (_f = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _f !== void 0 ? _f : config.maxPages;
     const pag = config.strategies.pagination;
     const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
-    const exact = (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false;
+    const exact = (_g = options === null || options === void 0 ? void 0 : options.exact) !== null && _g !== void 0 ? _g : false;
     const { domFilters, overrideFilters, syntheticFilters } = partitionFilters(config, filtersRecord);
     const hasOverrides = Object.keys(overrideFilters).length > 0;
     const hasSynthetics = Object.keys(syntheticFilters).length > 0;
@@ -80,14 +80,23 @@ async function countRows(env, filters, options) {
             return;
         await (0, loadingWait_1.waitWhileTableLoading)(config, env.getContext(), rootLocator.page(), 'countRows');
     };
+    (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
     await waitForReady();
+    (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.throwIfAborted();
     const filterSuffix = hasFilters ? ` filters=${(0, safeStringify_1.safeStringify)(filtersRecord)}` : '';
     if (!hasPagination) {
         log(config, `countRows: counting rows in current viewport (no pagination)${filterSuffix}`);
-        if (!hasPostFilters)
-            return resolveRows().count();
-        const all = await resolveRows().all();
-        return countPostFilterMatches(all, all.map((_, i) => i));
+        let count;
+        if (!hasPostFilters) {
+            count = await resolveRows().count();
+        }
+        else {
+            const all = await resolveRows().all();
+            (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
+            count = await countPostFilterMatches(all, all.map((_, i) => i));
+        }
+        (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.throwIfAborted();
+        return count;
     }
     log(config, `countRows: paginating up to ${effectiveMaxPages} page(s)${filterSuffix}`);
     const tracker = new elementTracker_1.ElementTracker('countRows');
@@ -113,6 +122,7 @@ async function countRows(env, filters, options) {
             useBulk: false,
             label: 'countRows',
             finalScanOnEof: true,
+            signal: options === null || options === void 0 ? void 0 : options.signal,
         });
         pagesScanned = scanned.pagesScanned;
     }

package/dist/engine/rowByIndex.d.ts

@@ -16,4 +16,5 @@ export interface RowByIndexEnv<T = any> {
  */
 export declare function findRowByIndex<T>(env: RowByIndexEnv<T>, index: number, options?: {
     maxPages?: number;
+    signal?: AbortSignal;
 }): Promise<SmartRow<T>>;

package/dist/engine/rowByIndex.js

@@ -11,7 +11,9 @@ const safeStringify_1 = require("../utils/safeStringify");
  * mounts (bounded by `maxPages`). Callers must have initialized the table.
  */
 async function findRowByIndex(env, index, options) {
-    var _a;
+    var _a, _b, _c, _d, _e;
+    var _f;
+    (_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
     const { config } = env;
     (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: index=${index} options=${(0, safeStringify_1.safeStringify)(options)}`);
     const resolveRI = config.strategies.resolveRowIndex;
@@ -25,9 +27,12 @@ async function findRowByIndex(env, index, options) {
     let foundSelector;
     // The currently-mounted row whose logical index === index, if any.
     const findMounted = async () => {
+        var _a, _b;
         const rows = await env.getRowLocators().all();
+        (_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
         for (const r of rows) {
             const result = await resolveRI(r);
+            (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
             if (result === undefined)
                 continue;
             const normalized = (0, rowResolution_1.normalizeRowIndexResult)(result);
@@ -40,22 +45,25 @@ async function findRowByIndex(env, index, options) {
     };
     // 1. Already mounted (no navigation needed)?
     let loc = await findMounted();
+    (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
     // 2. Fast path: jump straight to it via the viewport's random-access scroll.
     if (!loc && (viewport === null || viewport === void 0 ? void 0 : viewport.scrollToRow)) {
         (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: scrolling to row ${index}`);
         await viewport.scrollToRow(env.getContext(), index);
+        (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.throwIfAborted();
         loc = await findMounted();
+        (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
     }
     // 3. Fallback: advance pages (on infinite-scroll tables, a "page" is a scroll step) until
     //    the row is mounted. Page 1 was already searched above.
-    const maxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
+    const maxPages = (_f = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _f !== void 0 ? _f : config.maxPages;
     const scanForMounted = async () => {
         let hit = null;
         await (0, scanPages_1.scanPages)({ advancePage: env.advancePage, getCurrentPageIndex: env.getCurrentPageIndex, config }, async ({ pagesScanned }) => {
             if (pagesScanned > 1)
                 hit = await findMounted();
             return hit ? 'stop' : 'continue';
-        }, { maxPages, useBulk: false, label: 'findRowByIndex', finalScanOnEof: false });
+        }, { maxPages, useBulk: false, label: 'findRowByIndex', finalScanOnEof: false, signal: options === null || options === void 0 ? void 0 : options.signal });
         return hit;
     };
     if (!loc && config.strategies.pagination) {
@@ -66,5 +74,6 @@ async function findRowByIndex(env, index, options) {
             `Ensure a viewport.scrollToRow or pagination can bring it into view (searched up to maxPages=${maxPages}).`);
     }
     await (0, debugUtils_1.debugDelay)(config, 'findRow');
+    (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.throwIfAborted();
     return env.makeSmartRow(loc, env.getMap(), index, env.getCurrentPageIndex(), foundSelector);
 }

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;
@@ -23,6 +23,7 @@ export declare class RowFinder<T = any> {
     findRow(filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }): Promise<SmartRow<T>>;
     private waitForTableReady;
     /** Unfiltered rows keep the plain `SmartRow #n` name that `_makeSmart` applies. */
@@ -31,6 +32,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
         useBulkPagination?: boolean;
+        signal?: AbortSignal;
     }): Promise<SmartRowArray<T>>;
     private findRowLocator;
     private resolveRowIndex;

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);
@@ -204,6 +200,7 @@ class RowFinder {
                 useBulk,
                 label: 'findRows',
                 finalScanOnEof: hasPagination,
+                signal: options === null || options === void 0 ? void 0 : options.signal,
             });
             (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
         }
@@ -268,6 +265,7 @@ class RowFinder {
             useBulk,
             label: 'findRow',
             finalScanOnEof: true,
+            signal: options.signal,
         });
         return found;
     }

package/dist/engine/rowSnapshot.js

@@ -35,6 +35,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 +116,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 +155,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)
@@ -340,6 +348,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/scanPages.d.ts

@@ -52,6 +52,11 @@ export interface ScanPagesOptions {
      * Matches runMap / findRows EOF behavior. @default true
      */
     finalScanOnEof?: boolean;
+    /**
+     * Checked before each page and before each advance. When aborted, the scan throws
+     * `signal.reason` instead of returning partial results (#488).
+     */
+    signal?: AbortSignal;
 }
 export declare function scanPages(env: ScanPagesEnv, onPage: (ctx: ScanPageContext) => Promise<ScanDecision>, options: ScanPagesOptions): Promise<{
     pagesScanned: number;

package/dist/engine/scanPages.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanPages = scanPages;
 const debugUtils_1 = require("../utils/debugUtils");
+function throwIfAborted(env, label, signal) {
+    if (!(signal === null || signal === void 0 ? void 0 : signal.aborted))
+        return;
+    (0, debugUtils_1.logDebug)(env.config, 'info', `${label}: aborted via AbortSignal at page ${env.getCurrentPageIndex()}`);
+    throw signal.reason;
+}
 async function scanPages(env, onPage, options) {
     var _a, _b;
     const maxPages = options.maxPages;
@@ -12,14 +18,17 @@ async function scanPages(env, onPage, options) {
     let reachedEnd = false;
     (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: starting (maxPages=${maxPages}, useBulk=${useBulk}, finalScanOnEof=${finalScanOnEof})`);
     while (true) {
+        throwIfAborted(env, label, options.signal);
         if (env.waitForReady) {
             await env.waitForReady();
+            throwIfAborted(env, label, options.signal);
         }
         const decision = await onPage({
             pagesScanned,
             pageIndex: env.getCurrentPageIndex(),
             isFinalScan: reachedEnd,
         });
+        throwIfAborted(env, label, options.signal);
         if (decision === 'stop') {
             (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: onPage returned stop at page ${env.getCurrentPageIndex()}`);
             break;
@@ -27,8 +36,10 @@ async function scanPages(env, onPage, options) {
         if (pagesScanned >= maxPages || reachedEnd) {
             break;
         }
+        throwIfAborted(env, label, options.signal);
         const prevPage = env.getCurrentPageIndex();
         const didAdvance = await env.advancePage(useBulk);
+        throwIfAborted(env, label, options.signal);
         if (!didAdvance) {
             if (finalScanOnEof) {
                 (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: pagination returned false — final scan`);

package/dist/engine/tableIteration.js

@@ -196,6 +196,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
             useBulk,
             label,
             finalScanOnEof: true,
+            signal: options.signal,
         });
         log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
     }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { PLAYWRIGHT_SMART_TABLE_VERSION } from './packageVersion';
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, RowReadyPredicate, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /**

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.c81cb3d";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.f72ee4c";

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.c81cb3d";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.f72ee4c";

package/dist/strategies/contentReady.d.ts

@@ -1,5 +1,23 @@
-import type { ContentReadyStrategy } from '../types';
+import type { ContentReadyStrategy, RowReadyPredicate } from '../types';
 export declare const ContentReadyStrategies: {
+    /**
+     * Waits in the browser until `predicate(rowElement, arg)` returns a truthy value, e.g. until
+     * a skeleton placeholder is gone or every cell has rendered. Resolves when `timeout` expires
+     * even if the predicate never passed, like the other content-ready strategies.
+     *
+     * Uses `locator.waitForFunction` (Playwright 1.62+), which re-resolves the row on each retry
+     * and polls without a round-trip per check. Older versions poll via `locator.evaluate`.
+     * `timeout` and `interval` must be positive finite milliseconds. `interval` only controls
+     * the older-version fallback; native polling is controlled by Playwright.
+     *
+     * @example
+     * contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton'))
+     */
+    until: <Arg = undefined>(predicate: RowReadyPredicate<Arg>, options?: {
+        arg?: Arg;
+        timeout?: number;
+        interval?: number;
+    }) => ContentReadyStrategy;
     /**
      * Polls the row's text content until two consecutive reads match.
      */

package/dist/strategies/contentReady.js

@@ -1,7 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentReadyStrategies = void 0;
+function isTimeout(error) {
+    return (error === null || error === void 0 ? void 0 : error.name) === 'TimeoutError';
+}
+/** Playwright < 1.62 has no `locator.waitForFunction`: poll with one `evaluate` per check. */
+async function pollPredicate(row, page, predicate, arg, timeout, interval) {
+    const deadline = Date.now() + timeout;
+    let source = predicate.toString();
+    // Build a serializable callback; the user predicate executes only inside the browser.
+    const wrap = (expression) => new Function(`return async (row, arg) => Boolean(await (${expression})(row, arg))`)();
+    let evaluateBoolean;
+    try {
+        evaluateBoolean = wrap(source);
+    }
+    catch (_a) {
+        // Like Playwright's serializer, normalize method shorthand into a function expression.
+        source = source.startsWith('async ') ? source.replace(/^async\s+/, 'async function ') : `function ${source}`;
+        evaluateBoolean = wrap(source);
+    }
+    let expired = false;
+    let deadlineTimer;
+    const timeoutReached = new Promise(resolve => {
+        deadlineTimer = setTimeout(() => { expired = true; resolve(); }, timeout);
+    });
+    const poll = async () => {
+        while (!expired && Date.now() < deadline) {
+            // Convert truthiness before serialization, including async DOM-element results.
+            if (await row.evaluate(evaluateBoolean, arg, { timeout: Math.max(1, deadline - Date.now()) }))
+                return;
+            if (expired || Date.now() >= deadline)
+                return;
+            await page.waitForTimeout(Math.min(interval, Math.max(0, deadline - Date.now())));
+        }
+    };
+    try {
+        // evaluate's timeout only bounds locator resolution, not an async predicate's promise.
+        await Promise.race([poll(), timeoutReached]);
+    }
+    finally {
+        clearTimeout(deadlineTimer);
+    }
+}
 exports.ContentReadyStrategies = {
+    /**
+     * Waits in the browser until `predicate(rowElement, arg)` returns a truthy value, e.g. until
+     * a skeleton placeholder is gone or every cell has rendered. Resolves when `timeout` expires
+     * even if the predicate never passed, like the other content-ready strategies.
+     *
+     * Uses `locator.waitForFunction` (Playwright 1.62+), which re-resolves the row on each retry
+     * and polls without a round-trip per check. Older versions poll via `locator.evaluate`.
+     * `timeout` and `interval` must be positive finite milliseconds. `interval` only controls
+     * the older-version fallback; native polling is controlled by Playwright.
+     *
+     * @example
+     * contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton'))
+     */
+    until: (predicate, options = {}) => {
+        var _a, _b;
+        const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 500;
+        const interval = (_b = options.interval) !== null && _b !== void 0 ? _b : 50;
+        if (!Number.isFinite(timeout) || timeout <= 0) {
+            throw new Error('ContentReady.until: timeout must be a positive finite number');
+        }
+        if (!Number.isFinite(interval) || interval <= 0) {
+            throw new Error('ContentReady.until: interval must be a positive finite number');
+        }
+        const fn = predicate;
+        const arg = options.arg;
+        return async (row, page) => {
+            try {
+                if (typeof row.waitForFunction === 'function') {
+                    await row.waitForFunction(fn, arg, { timeout });
+                }
+                else {
+                    await pollPredicate(row, page, fn, arg, timeout, interval);
+                }
+            }
+            catch (error) {
+                if (!isTimeout(error))
+                    throw error;
+            }
+        };
+    },
     /**
      * Polls the row's text content until two consecutive reads match.
      */

package/dist/strategies/index.d.ts

@@ -98,6 +98,11 @@ export declare const Strategies: {
         dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("..").ViewportStrategy;
     };
     ContentReady: {
+        until: <Arg = undefined>(predicate: import("..").RowReadyPredicate<Arg>, options?: {
+            arg?: Arg;
+            timeout?: number;
+            interval?: number;
+        }) => import("..").ContentReadyStrategy;
         textStable: (options?: {
             timeout?: number;
             interval?: number;

package/dist/types.d.ts

@@ -428,6 +428,8 @@ export interface PaginationPrimitives {
 export type PaginationStrategy = PaginationPrimitives;
 export type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;
 export type ContentReadyStrategy = (row: Locator, page: Page) => Promise<void>;
+/** Predicate for `Strategies.ContentReady.until`. Runs in the browser with the row element, so it must not close over test-side variables; pass values via `arg`. */
+export type RowReadyPredicate<Arg = undefined> = (row: HTMLElement | SVGElement, arg: Arg) => unknown;
 export type FillStrategy = (options: {
     row: SmartRow;
     columnName: string;
@@ -638,12 +640,18 @@ export interface TableStrategies {
      * Without this, the clone captures stale content from the previous occupant of the
      * DOM slot — the element is at the correct position but React hasn't re-rendered yet.
      *
-     * Use `Strategies.ContentReady.textStable()` for the built-in text-polling strategy.
+     * Built-ins: `Strategies.ContentReady.textStable()` (text stops changing),
+     * `mutationSettled()` (no DOM mutations for a quiet period), and `until(predicate)`
+     * (an in-browser condition holds, e.g. no skeleton placeholder).
      *
      * @example
      * strategies: {
      *   contentReady: Strategies.ContentReady.textStable({ timeout: 500 }),
      * }
+     * @example
+     * strategies: {
+     *   contentReady: Strategies.ContentReady.until(row => !row.querySelector('.skeleton')),
+     * }
      */
     contentReady?: ContentReadyStrategy;
     /**
@@ -794,6 +802,11 @@ export type RowIterationOptions = {
      * @default false — uses goNext for one-page-at-a-time advancement
      */
     useBulkPagination?: boolean;
+    /**
+     * Cancels the iteration between pages. When aborted, the call rejects with
+     * `signal.reason` (rows already processed are not returned).
+     */
+    signal?: AbortSignal;
 };
 /**
  * Result of {@link useTable}. Implements `AsyncIterable` — `for await (const { row } of table)`
@@ -876,31 +889,37 @@ export interface TableResult<T = any> extends AsyncIterable<{
      * is not configured. Also throws if the row cannot be reached (no silent wrong-row fallback).
      *
      * @param index 0-based logical/data-model row index
-     * @param options - `maxPages` bounds how far to scroll/paginate (defaults to config.maxPages)
+     * @param options - `maxPages` bounds how far to scroll/paginate (defaults to config.maxPages).
+     * `signal` cancels the page scan; the call rejects with `signal.reason`.
      */
     findRowByIndex: (index: number, options?: {
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<SmartRow<T>>;
     /**
      * ASYNC: Searches for a single row across pages using pagination.
      * Auto-initializes the table if not already initialized.
      * @param filters - The filter criteria to match
-     * @param options - Search options including exact match and max pages
+     * @param options - Search options including exact match and max pages. `signal` cancels the page scan; the call rejects with `signal.reason`.
      */
     findRow: (filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<SmartRow<T>>;
     /**
      * 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).
+     * @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`.
      */
     findRows: (filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
         useBulkPagination?: boolean;
+        signal?: AbortSignal;
     }) => Promise<SmartRowArray<T>>;
     /**
      * Resolves the named column and scrolls it into view.
@@ -911,11 +930,13 @@ export interface TableResult<T = any> extends AsyncIterable<{
     /**
      * Counts the number of rows, optionally filtered.
      * Without arguments, counts all rows. With filters, counts only matching rows.
-     * Paginates when pagination is configured.
+     * Paginates when pagination is configured. `signal` cancels the page scan; the call
+     * rejects with `signal.reason` (the table is still reset to page 1).
      */
     countRows: (filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        signal?: AbortSignal;
     }) => Promise<number>;
     /**
      * Iterates over rows and extracts the value of a single column.

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.c81cb3d",
+  "version": "6.25.0-next.f72ee4c",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",