@rickcedwhat/playwright-smart-table 6.19.0 → 6.20.1-next.19d3cd3

package/dist/useTable.js

@@ -145,8 +145,14 @@ const useTable = (rootLocator, configOptions = {}) => {
     // Placeholder for the final table object
     let finalTable = null;
     // Helper factory
-    const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex, barrier) => {
-        return (0, smartRow_1.default)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier);
+    const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex, barrier, rowSelector) => {
+        const effectiveLocator = rowSelector
+            ? rootLocator.locator(rowSelector)
+            : rowLocator;
+        const sr = (0, smartRow_1.default)(effectiveLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier);
+        if (rowSelector)
+            sr._selfHealing = true;
+        return sr;
     };
     const tableState = { currentPageIndex: 0, empty: false };
     const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState, (useBulk) => _advancePage(useBulk));
@@ -281,9 +287,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             await headerCell.scrollIntoViewIfNeeded();
         },
         getHeaders: async () => {
+            var _a;
             log("getHeaders: fetching available columns");
             const map = await tableMapper.getMap();
-            return Array.from(map.keys());
+            return [...map.keys(), ...Object.keys((_a = config.syntheticColumns) !== null && _a !== void 0 ? _a : {})];
         },
         getHeaderCell: async (columnName) => {
             log(`getHeaderCell: column="${columnName}"`);
@@ -293,27 +300,95 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw _createColumnError(columnName, map, 'header cell');
             return resolve(config.headerSelector, rootLocator).nth(idx);
         },
-        countRows: async () => {
+        countRows: async (filters, options) => {
+            var _a, _b, _c, _d, _e;
             if (tableState.empty)
                 return 0;
             await _autoInit();
+            const filtersRecord = (filters !== null && filters !== void 0 ? filters : {});
+            const hasFilters = Object.keys(filtersRecord).length > 0;
+            const effectiveMaxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
             const pag = config.strategies.pagination;
-            const hasPagination = config.maxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
+            const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
+            const domFilters = {};
+            const overrideFilters = {};
+            const syntheticFilters = {};
+            if (hasFilters) {
+                for (const [key, value] of Object.entries(filtersRecord)) {
+                    if ((_b = config.syntheticColumns) === null || _b === void 0 ? void 0 : _b[key]) {
+                        syntheticFilters[key] = value;
+                    }
+                    else if ((_d = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[key]) === null || _d === void 0 ? void 0 : _d.read) {
+                        overrideFilters[key] = value;
+                    }
+                    else {
+                        domFilters[key] = value;
+                    }
+                }
+            }
+            const hasPostFilters = Object.keys(overrideFilters).length > 0 || Object.keys(syntheticFilters).length > 0;
+            const resolveRows = () => {
+                var _a;
+                let rows = resolve(config.rowSelector, rootLocator);
+                if (Object.keys(domFilters).length > 0) {
+                    const map = tableMapper.getMapSync();
+                    if (!map)
+                        throw new Error('Initialization Error: Table map not available. Call "await table.init()" first.');
+                    rows = filterEngine.applyFilters(rows, domFilters, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, rootLocator.page(), rootLocator);
+                }
+                return rows;
+            };
+            const countPostFilterMatches = async (candidates, indices) => {
+                var _a;
+                if (!hasPostFilters)
+                    return indices.length;
+                const map = tableMapper.getMapSync();
+                if (!map)
+                    throw new Error('Initialization Error: Table map not available. Call "await table.init()" first.');
+                const exact = (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false;
+                const hasOverrides = Object.keys(overrideFilters).length > 0;
+                const hasSynthetics = Object.keys(syntheticFilters).length > 0;
+                let count = 0;
+                for (const idx of indices) {
+                    const row = candidates[idx];
+                    if (hasOverrides && !await rowFinder.matchesOverrideFilters(row, overrideFilters, map, exact))
+                        continue;
+                    if (hasSynthetics && !await rowFinder.matchesSyntheticFilters(row, syntheticFilters, map, exact))
+                        continue;
+                    count++;
+                }
+                return count;
+            };
+            // Wait for table to finish loading before counting
+            const isTableLoading = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.isTableLoading;
+            if (isTableLoading) {
+                const ctx = createStrategyContext();
+                while (await isTableLoading(ctx)) {
+                    log('countRows: table is loading... waiting');
+                    await rootLocator.page().waitForTimeout(200);
+                }
+            }
             if (!hasPagination) {
-                log("countRows: counting rows in current viewport (no pagination)");
-                return resolve(config.rowSelector, rootLocator).count();
+                log(`countRows: counting rows in current viewport (no pagination)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
+                if (!hasPostFilters)
+                    return resolveRows().count();
+                const all = await resolveRows().all();
+                return countPostFilterMatches(all, all.map((_, i) => i));
             }
-            log(`countRows: paginating up to ${config.maxPages} page(s)`);
+            log(`countRows: paginating up to ${effectiveMaxPages} page(s)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
             const tracker = new elementTracker_1.ElementTracker('countRows');
             let total = 0;
             let pagesScanned = 1;
             let paginationError;
             try {
                 while (true) {
-                    const newIndices = await tracker.getUnseenIndices(resolve(config.rowSelector, rootLocator));
-                    total += newIndices.length;
-                    log(`countRows: page ${pagesScanned} — ${newIndices.length} row(s) (running total: ${total})`);
-                    if (pagesScanned >= config.maxPages)
+                    const rowLocators = resolveRows();
+                    const newIndices = await tracker.getUnseenIndices(rowLocators);
+                    const candidates = await rowLocators.all();
+                    const matched = await countPostFilterMatches(candidates, newIndices);
+                    total += matched;
+                    log(`countRows: page ${pagesScanned} — ${matched} row(s) (running total: ${total})`);
+                    if (pagesScanned >= effectiveMaxPages)
                         break;
                     if (!await _advancePage(false))
                         break;
@@ -370,7 +445,6 @@ const useTable = (rootLocator, configOptions = {}) => {
         reset: async () => {
             var _a;
             log("Resetting table...");
-            await config.onReset(createStrategyContext());
             if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goToFirst) {
                 log("Auto-navigating to first page...");
                 await config.strategies.pagination.goToFirst(createStrategyContext());
@@ -383,6 +457,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             tableMapper.clear();
             log("Table reset complete. Calling autoInit to restore state.");
             await _autoInit();
+            await config.onReset(createStrategyContext());
         },
         revalidate: async () => {
             log("Revalidating table structure...");
@@ -392,6 +467,11 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         getRow: (filters, options = { exact: false }) => {
             log(`getRow: filters=${safeStringify(filters)} exact=${options.exact}`);
+            const syntheticKeys = Object.keys(filters).filter(k => { var _a; return (_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[k]; });
+            if (syntheticKeys.length > 0) {
+                throw new Error(`getRow() cannot filter by synthetic column(s): ${syntheticKeys.join(', ')}. ` +
+                    `Use findRow() instead — synthetic columns require async evaluation.`);
+            }
             const map = tableMapper.getMapSync();
             if (!map)
                 throw new Error('Initialization Error: You attempted to access a row before the table structure was mapped. Please call "await table.init()" once before using synchronous row access.');
@@ -420,12 +500,19 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw new Error(`findRowByIndex(${index}) requires a strategies.resolveRowIndex to identify rows by their logical index. ` +
                     `Configure one (e.g. read the grid's row-index attribute), or use getRowByIndex() (current render window) / findRow(filters).`);
             }
+            let foundSelector;
             // The currently-mounted row whose logical index === index, if any.
             const findMounted = async () => {
                 const rows = await resolve(config.rowSelector, rootLocator).all();
                 for (const r of rows) {
-                    if ((await resolveRI(r)) === index)
+                    const result = await resolveRI(r);
+                    if (result === undefined)
+                        continue;
+                    const normalized = (0, rowResolution_1.normalizeRowIndexResult)(result);
+                    if (normalized.index === index) {
+                        foundSelector = normalized.selector;
                         return r;
+                    }
                 }
                 return null;
             };
@@ -454,7 +541,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                     `Ensure a viewport.scrollToRow or pagination can bring it into view (searched up to maxPages=${(_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages}).`);
             }
             await (0, debugUtils_1.debugDelay)(config, 'findRow');
-            return _makeSmart(loc, map, index, tableState.currentPageIndex);
+            return _makeSmart(loc, map, index, tableState.currentPageIndex, undefined, foundSelector);
         },
         findRow: async (filters, options) => {
             log(`findRow: filters=${safeStringify(filters)} options=${safeStringify(options)}`);
@@ -474,7 +561,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         sorting: {
             apply: async (columnName, direction) => {
-                var _a;
+                var _a, _b, _c, _d, _e;
                 await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
@@ -489,13 +576,16 @@ const useTable = (rootLocator, configOptions = {}) => {
                     }
                     await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        const deadline = Date.now() + 10000;
+                        const timeout = (_b = config.strategies.loading.sortStabilizationTimeout) !== null && _b !== void 0 ? _b : 10000;
+                        const poll = (_c = config.strategies.loading.sortStabilizationPollInterval) !== null && _c !== void 0 ? _c : 100;
+                        const deadline = Date.now() + timeout;
                         while (Date.now() < deadline && await config.strategies.loading.isTableLoading(context)) {
-                            await rootLocator.page().waitForTimeout(100);
+                            await rootLocator.page().waitForTimeout(poll);
                         }
                     }
                     else {
-                        await rootLocator.page().waitForTimeout(200);
+                        const fallback = (_e = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.sortStabilizationFallbackDelay) !== null && _e !== void 0 ? _e : 200;
+                        await rootLocator.page().waitForTimeout(fallback);
                     }
                     await (0, debugUtils_1.debugDelay)(config, 'default');
                     const newState = await config.strategies.sorting.getSortState({ columnName, context });
@@ -535,8 +625,9 @@ const useTable = (rootLocator, configOptions = {}) => {
                         const barrier = new navigationBarrier_1.NavigationBarrier(newIndices.length);
                         for (const idx of newIndices) {
                             // index = visit-order counter; rowIndex = logical/data index (B-hybrid, #362).
-                            const logical = (_b = yield __await((0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], config, () => rowIndex))) !== null && _b !== void 0 ? _b : rowIndex;
-                            const sr = _makeSmart(pageRows[idx], map, logical, tableState.currentPageIndex, barrier);
+                            const resolved = yield __await((0, rowResolution_1.resolveLogicalRowIndex)(pageRows[idx], config, () => rowIndex));
+                            const logical = (_b = resolved === null || resolved === void 0 ? void 0 : resolved.index) !== null && _b !== void 0 ? _b : rowIndex;
+                            const sr = _makeSmart(pageRows[idx], map, logical, tableState.currentPageIndex, barrier, resolved === null || resolved === void 0 ? void 0 : resolved.selector);
                             // Iterator rows share one per-page DOM snapshot (positional locators); disable
                             // toJSON's scroll-back recovery so reading one row can't invalidate the others (#366).
                             sr._inBatch = true;
@@ -563,7 +654,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
                 advancePage: _advancePage,
-                makeSmartRow: (loc, map, idx, pageIdx, barrier) => _makeSmart(loc, map, idx, pageIdx, barrier),
+                makeSmartRow: (loc, map, idx, pageIdx, barrier, sel) => _makeSmart(loc, map, idx, pageIdx, barrier, sel),
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),
@@ -578,7 +669,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
                 advancePage: _advancePage,
-                makeSmartRow: (loc, map, idx, pageIdx, barrier) => _makeSmart(loc, map, idx, pageIdx, barrier),
+                makeSmartRow: (loc, map, idx, pageIdx, barrier, sel) => _makeSmart(loc, map, idx, pageIdx, barrier, sel),
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),
@@ -603,7 +694,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
                 advancePage: _advancePage,
-                makeSmartRow: (loc, map, idx, pageIdx, barrier) => _makeSmart(loc, map, idx, pageIdx, barrier),
+                makeSmartRow: (loc, map, idx, pageIdx, barrier, sel) => _makeSmart(loc, map, idx, pageIdx, barrier, sel),
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),

package/dist/utils/elementTracker.js

@@ -18,7 +18,8 @@ class ElementTracker {
             const seenMap = win[trackerId];
             const newIndices = [];
             elements.forEach((el, index) => {
-                const signature = el.textContent || '';
+                const htmlEl = el;
+                const signature = htmlEl.offsetTop + '|' + (el.textContent || '');
                 if (seenMap.get(el) !== signature) {
                     newIndices.push(index);
                 }
@@ -39,8 +40,10 @@ class ElementTracker {
             const seenMap = win[trackerId];
             for (const index of indicesToCommit) {
                 const el = elements[index];
-                if (el)
-                    seenMap.set(el, el.textContent || '');
+                if (el) {
+                    const htmlEl = el;
+                    seenMap.set(el, htmlEl.offsetTop + '|' + (el.textContent || ''));
+                }
             }
         }, [this.id, indices]);
     }

package/dist/utils/mergeTableConfig.js

@@ -56,5 +56,9 @@ function mergeTableConfig(base, overrides) {
     if (base.columnOverrides || overrides.columnOverrides) {
         result.columnOverrides = Object.assign(Object.assign({}, base.columnOverrides), overrides.columnOverrides);
     }
+    // Deep-merge syntheticColumns (override keys replace, preset keys retained)
+    if (base.syntheticColumns || overrides.syntheticColumns) {
+        result.syntheticColumns = Object.assign(Object.assign({}, base.syntheticColumns), overrides.syntheticColumns);
+    }
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.19.0",
+  "version": "6.20.1-next.19d3cd3",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -110,6 +110,11 @@
   "peerDependencies": {
     "@playwright/test": "^1.40.0"
   },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@commitlint/cli": "^21.0.0",
     "@commitlint/config-conventional": "^21.0.0",