@rickcedwhat/playwright-smart-table 6.18.0 → 6.20.0

package/dist/engine/tableIteration.js

@@ -7,6 +7,7 @@ const elementTracker_1 = require("../utils/elementTracker");
 const debugUtils_1 = require("../utils/debugUtils");
 const navigationBarrier_1 = require("../utils/navigationBarrier");
 const mutex_1 = require("../utils/mutex");
+const rowResolution_1 = require("./rowResolution");
 function log(config, msg) {
     (0, debugUtils_1.logDebug)(config, 'verbose', msg);
 }
@@ -20,7 +21,7 @@ async function runForEach(env, callback, options = {}) {
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
  */
 async function runMap(env, callback, options = {}, label = 'map') {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f;
     const map = env.getMap();
     const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
     const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
@@ -34,21 +35,6 @@ async function runMap(env, callback, options = {}, label = 'map') {
     const useMutex = concurrency === 'sequential';
     const useBulk = (_e = options.useBulkPagination) !== null && _e !== void 0 ? _e : false;
     const tracker = new elementTracker_1.ElementTracker(label);
-    // Row-level loading gate (Bug #355). Must run BEFORE the dedupe strategy so
-    // content-based dedupe keys are computed on the row's final loaded state — a key
-    // computed on a skeleton changes once the row loads, and the ElementTracker
-    // re-flags the row (text signature changed), producing duplicates.
-    // Semantics mirror findRows (rowFinder.ts), with one deliberate difference:
-    // findRows drops loading rows when no timeout is set (legacy skip), but map/forEach
-    // historically visited every row — so without a timeout we process the row as-is.
-    const isRowLoading = (_f = env.config.strategies.loading) === null || _f === void 0 ? void 0 : _f.isRowLoading;
-    const rawRowTimeout = (_g = env.config.strategies.loading) === null || _g === void 0 ? void 0 : _g.rowLoadingTimeout;
-    // undefined = unset (process as-is); 0 = no wait (immediate re-check); >0 = wait up to N ms
-    // Non-finite values are treated as unset (defensive guard against Infinity/NaN)
-    const rowLoadingTimeout = rawRowTimeout !== undefined && Number.isFinite(rawRowTimeout) && rawRowTimeout >= 0
-        ? rawRowTimeout
-        : undefined;
-    const onRowLoadingTimeout = (_j = (_h = env.config.strategies.loading) === null || _h === void 0 ? void 0 : _h.onRowLoadingTimeout) !== null && _j !== void 0 ? _j : 'read-as-is';
     log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
     const results = [];
     try {
@@ -56,6 +42,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
         let stopped = false;
         let stoppedIndex = Infinity;
         let pagesScanned = 1;
+        let reachedEnd = false;
         const stop = (idx) => {
             if (!stopped) {
                 log(env.config, `${label}: stop() called at row ${idx} — halting`);
@@ -67,12 +54,31 @@ async function runMap(env, callback, options = {}, label = 'map') {
             const rowLocators = env.getRowLocators();
             const allIndices = await tracker.peekUnseenIndices(rowLocators);
             const pageRows = await rowLocators.all();
+            // A2 (#353 part 2 / #357): when the viewport can report which rows are within the visible
+            // bounds, drop overscan rows from collection. They are left uncommitted (still unseen), so
+            // they're picked up on a later page once scrolled into view — preventing overscan from
+            // being ingested (#353) or double-collected via node recycling (#357). No-op when no
+            // viewport reports visible rows.
+            //
+            // #384: overscan rows ABOVE the visible range have already scrolled past and will never
+            // re-enter the viewport — collect them now. Only defer rows BELOW the visible range
+            // (they'll scroll into view on a later page).
+            let candidateIndices = allIndices;
+            const getVisibleRowIndices = (_f = env.config.strategies.viewport) === null || _f === void 0 ? void 0 : _f.getVisibleRowIndices;
+            if (getVisibleRowIndices) {
+                const visible = new Set(await getVisibleRowIndices(env.getContext()));
+                const minVisible = visible.size > 0 ? Math.min(...visible) : Infinity;
+                candidateIndices = allIndices.filter(idx => visible.has(idx) || idx < minVisible);
+                if (candidateIndices.length !== allIndices.length) {
+                    log(env.config, `${label}: viewport visible filter — ${candidateIndices.length}/${allIndices.length} row(s) in view`);
+                }
+            }
             // In synchronized mode, overscan rows rendered beyond the visible viewport by virtual
             // scrollers can be evicted when the horizontal barrier fires snapFirstColumnIntoView.
             // Filter them out before committing so they stay unseen and are picked up on the next page.
             const newIndices = concurrency === 'synchronized'
-                ? (await Promise.all(allIndices.map(async (idx) => ({ idx, present: pageRows[idx] != null && (await pageRows[idx].count()) > 0 })))).filter(r => r.present).map(r => r.idx)
-                : allIndices;
+                ? (await Promise.all(candidateIndices.map(async (idx) => ({ idx, present: pageRows[idx] != null && (await pageRows[idx].count()) > 0 })))).filter(r => r.present).map(r => r.idx)
+                : candidateIndices;
             await tracker.commitIndices(rowLocators, newIndices);
             const batchSize = newIndices.length;
             if (batchSize === 0) {
@@ -82,52 +88,60 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
                 const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
                 const actionMutex = useMutex ? new mutex_1.Mutex() : null;
-                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, env.getCurrentPageIndex(), barrier));
-                const processRow = async (row) => {
+                // `index` (ctx.index) is the enumeration counter — the order rows are visited,
+                // contiguous and monotonic. It drives the internal stop()/ordering logic.
+                const positionBase = rowIndex;
+                // B-hybrid (#362): the row's rowIndex is its logical/data-model index when a
+                // resolveRowIndex strategy is configured (so bringIntoView and position math are
+                // correct on virtualized tables); otherwise it equals the enumeration counter.
+                const smartRows = await Promise.all(newIndices.map(async (idx, i) => {
+                    var _a;
+                    const resolved = await (0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], env.config, () => positionBase + i);
+                    const logicalIndex = (_a = resolved === null || resolved === void 0 ? void 0 : resolved.index) !== null && _a !== void 0 ? _a : (positionBase + i);
+                    const sr = env.makeSmartRow(pageRows[idx], map, logicalIndex, env.getCurrentPageIndex(), barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
+                    // Mark as part of an iteration batch so toJSON's #366 re-pin uses rescan-only recovery
+                    // (no scroll-back) — scrolling here would disrupt sibling rows' positional locators.
+                    sr._inBatch = true;
+                    return sr;
+                }));
+                // enumIndex = visit-order counter (ctx.index); row.rowIndex = logical (ctx.rowIndex).
+                const processRow = async (row, enumIndex) => {
+                    var _a;
                     try {
-                        if (stopped && row.rowIndex > stoppedIndex) {
+                        if (stopped && enumIndex > stoppedIndex) {
                             return SKIP;
                         }
                         // Wait for the row to finish loading BEFORE evaluating its dedupe key (Bug #355).
-                        if (isRowLoading && rowLoadingTimeout !== undefined && await isRowLoading(row)) {
-                            log(env.config, `${label}: row ${row.rowIndex} — waiting up to ${rowLoadingTimeout}ms for row to load`);
-                            const deadline = Date.now() + rowLoadingTimeout;
-                            let resolved = !(await isRowLoading(row)); // immediate check (handles timeout=0)
-                            while (!resolved && Date.now() < deadline) {
-                                await env.getPage().waitForTimeout(100);
-                                resolved = !(await isRowLoading(row));
-                            }
-                            if (!resolved) {
-                                log(env.config, `${label}: row ${row.rowIndex} — still loading after ${rowLoadingTimeout}ms, action: ${onRowLoadingTimeout}`);
-                                if (onRowLoadingTimeout === 'skip')
-                                    return SKIP;
-                                if (onRowLoadingTimeout === 'throw') {
-                                    throw new Error(`[SmartTable] Row ${row.rowIndex} did not finish loading within ${rowLoadingTimeout}ms`);
-                                }
-                                // 'read-as-is': fall through and process the row
-                            }
+                        // map/forEach/filter process a still-loading row when no timeout is set (unlike
+                        // findRows, which skips) — see resolveRowLoading's `noTimeoutAction`.
+                        const loadingOutcome = await (0, rowResolution_1.resolveRowLoading)(row, env.config.strategies.loading, 'process', (msg) => log(env.config, `${label}: ${msg}`));
+                        if (loadingOutcome === 'skip')
+                            return SKIP;
+                        if (loadingOutcome === 'throw') {
+                            throw new Error(`[SmartTable] Row ${row.rowIndex} did not finish loading within ${(_a = env.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.rowLoadingTimeout}ms`);
                         }
+                        let dedupeKey;
                         if (dedupeKeys && dedupeStrategy) {
-                            const key = await dedupeStrategy(row);
-                            if (dedupeKeys.has(key)) {
-                                log(env.config, `${label}: dedupe skip key="${key}"`);
+                            dedupeKey = await dedupeStrategy(row);
+                            if (dedupeKeys.has(dedupeKey)) {
+                                log(env.config, `${label}: dedupe skip key="${dedupeKey}"`);
                                 return SKIP;
                             }
-                            dedupeKeys.add(key);
                         }
                         // Execute callback (optionally serialized via mutex)
                         const runCallback = async () => {
-                            if (stopped && row.rowIndex > stoppedIndex)
+                            if (stopped && enumIndex > stoppedIndex)
                                 return SKIP;
-                            log(env.config, `${label}: processing row ${row.rowIndex}`);
-                            return await callback({ row, index: row.rowIndex, rowIndex: row.rowIndex, pageIndex: env.getCurrentPageIndex(), stop: () => stop(row.rowIndex) });
+                            log(env.config, `${label}: processing row (index ${enumIndex}, rowIndex ${row.rowIndex})`);
+                            return await callback({ row, index: enumIndex, rowIndex: row.rowIndex, pageIndex: env.getCurrentPageIndex(), stop: () => stop(enumIndex) });
                         };
-                        if (actionMutex) {
-                            return await actionMutex.run(runCallback);
-                        }
-                        else {
-                            return await runCallback();
+                        const result = actionMutex
+                            ? await actionMutex.run(runCallback)
+                            : await runCallback();
+                        if (dedupeKeys && dedupeKey !== undefined && result !== SKIP) {
+                            dedupeKeys.add(dedupeKey);
                         }
+                        return result;
                     }
                     finally {
                         // Ensure the barrier is notified once per row, even on error or skip.
@@ -136,16 +150,16 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 };
                 const pageResults = [];
                 if (concurrency === 'sequential') {
-                    for (const row of smartRows) {
-                        pageResults.push(await processRow(row));
+                    for (let i = 0; i < smartRows.length; i++) {
+                        pageResults.push(await processRow(smartRows[i], positionBase + i));
                     }
                 }
                 else {
-                    const results = await Promise.all(smartRows.map(processRow));
+                    const results = await Promise.all(smartRows.map((row, i) => processRow(row, positionBase + i)));
                     pageResults.push(...results);
                 }
                 for (let i = 0; i < pageResults.length; i++) {
-                    if (smartRows[i].rowIndex > stoppedIndex)
+                    if (positionBase + i > stoppedIndex)
                         break;
                     const r = pageResults[i];
                     if (r !== SKIP)
@@ -153,12 +167,13 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 }
                 rowIndex += batchSize;
             }
-            if (stopped || pagesScanned >= effectiveMaxPages)
+            if (stopped || pagesScanned >= effectiveMaxPages || reachedEnd)
                 break;
             log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
             if (!await env.advancePage(useBulk)) {
-                log(env.config, `${label}: no more pages — done`);
-                break;
+                log(env.config, `${label}: pagination returned false — final scan`);
+                reachedEnd = true;
+                continue;
             }
             pagesScanned++;
         }

package/dist/engine/tableMapper.js

@@ -14,7 +14,7 @@ class TableMapper {
         (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
     }
     async getMap(timeout) {
-        var _a;
+        var _a, _b;
         if (this._headerMap)
             return this._headerMap;
         this.log('Mapping headers...');
@@ -56,8 +56,15 @@ class TableMapper {
             try {
                 const rawHeaders = await strategy(context);
                 const entries = await this.processHeaders(rawHeaders);
-                // Success
-                this._headerMap = new Map(entries);
+                // Success — validate before caching so a collision doesn't leave stale state
+                const headerMap = new Map(entries);
+                const syntheticNames = Object.keys((_b = this.config.syntheticColumns) !== null && _b !== void 0 ? _b : {});
+                const collisions = syntheticNames.filter(name => headerMap.has(name));
+                if (collisions.length > 0) {
+                    throw new Error(`Synthetic column name(s) collide with real header(s): ${collisions.join(', ')}. ` +
+                        `Rename the synthetic column or use columnOverrides for columns that exist in the DOM.`);
+                }
+                this._headerMap = headerMap;
                 this.log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
                 return this._headerMap;
             }

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, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /** @deprecated Use `presets` instead. Plugins will be removed in v7.0.0. */

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.18.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.20.0";

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.18.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.20.0";

package/dist/plugins/index.d.ts

@@ -23,7 +23,9 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.glide` */
     Glide: {
@@ -43,7 +45,9 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
     /** @deprecated Use `presets.muiDataGrid` */
     MUI: {
@@ -63,6 +67,8 @@ export declare const Plugins: {
         debug?: import("..").DebugConfig | undefined;
         onReset?: ((context: import("..").TableContext) => Promise<void>) | undefined;
         strategies?: import("../types").TableStrategies | undefined;
-        columnOverrides?: Partial<Record<string | number | symbol, import("../types").ColumnOverride<any>>> | undefined;
+        columnOverrides?: Partial<Record<string | number | symbol, import("..").ColumnOverride<any>>> | undefined;
+        syntheticColumns?: Record<string, import("..").SyntheticColumnDef<any>> | undefined;
+        emptyState?: import("@playwright/test").Locator | undefined;
     };
 };

package/dist/presets/glide/headers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scrollRightHeader = void 0;
+const debugUtils_1 = require("../../utils/debugUtils");
 /**
  * Scans for headers by finding a scrollable container and setting scrollLeft.
  */
@@ -47,10 +48,12 @@ const scrollRightHeader = async (context, options) => {
         }
     }
     else {
-        console.warn("HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+        (0, debugUtils_1.logDebug)(config, 'info', "HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+    }
+    if (isScrollerFound) {
+        await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+        await page.waitForTimeout(200);
     }
-    await scrollerHandle.evaluate(el => el.scrollLeft = 0);
-    await page.waitForTimeout(200);
     return Array.from(collectedHeaders);
 };
 exports.scrollRightHeader = scrollRightHeader;

package/dist/presets/mui.js

@@ -200,7 +200,9 @@ function createMuiDataGrid(opts) {
         strategies: {
             resolveRowIndex: async (row) => {
                 const v = await row.getAttribute('data-rowindex').catch(() => null);
-                return v !== null && !isNaN(Number(v)) ? Number(v) : undefined;
+                if (v === null || isNaN(Number(v)))
+                    return undefined;
+                return { index: Number(v), selector: `[data-rowindex="${v}"]` };
             },
             pagination: {
                 goNext: async (context) => {
@@ -353,6 +355,31 @@ function createMuiDataGrid(opts) {
                         return { first: Math.min(...indices), last: Math.max(...indices) };
                     }, rowSel);
                 },
+                // Geometry-based visible-row set for the iteration engine (A2, #353/#357). Returns
+                // the DOM positions of rows overlapping the virtualScroller's bounds so map/forEach
+                // skip the overscan rows MUI keeps mounted above/below the fold. The scroller is a
+                // descendant of root, so querySelector (not closest).
+                getVisibleRowIndices: async ({ root, config }) => {
+                    const rowSel = config.rowSelector;
+                    return root.evaluate((el, rowSel) => {
+                        const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
+                        const rows = Array.from(el.querySelectorAll(rowSel));
+                        const scrollerRect = scroller ? scroller.getBoundingClientRect() : null;
+                        const visible = [];
+                        rows.forEach((r, i) => {
+                            if (!scrollerRect) {
+                                visible.push(i);
+                                return;
+                            } // can't measure → keep all
+                            const rect = r.getBoundingClientRect();
+                            if (rect.height === 0)
+                                return;
+                            if (rect.bottom > scrollerRect.top && rect.top < scrollerRect.bottom)
+                                visible.push(i);
+                        });
+                        return visible;
+                    }, rowSel);
+                },
                 getVisibleColumnRange: async ({ root, config }) => {
                     const rowSel = config.rowSelector;
                     const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : '[aria-colindex]';