@rickcedwhat/playwright-smart-table 6.17.1 → 6.19.0

package/dist/useTable.js

@@ -27,6 +27,7 @@ const filterEngine_1 = require("./filterEngine");
 const tableMapper_1 = require("./engine/tableMapper");
 const rowFinder_1 = require("./engine/rowFinder");
 const tableIteration_1 = require("./engine/tableIteration");
+const rowResolution_1 = require("./engine/rowResolution");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
 const elementTracker_1 = require("./utils/elementTracker");
@@ -69,9 +70,11 @@ const useTable = (rootLocator, configOptions = {}) => {
         const vp = config.strategies.viewport;
         let colRangeCache = null;
         let rowRangeCache = null;
+        let rowIndicesCache = null;
         _clearViewportCache = () => {
             colRangeCache = null;
             rowRangeCache = null;
+            rowIndicesCache = null;
         };
         config.strategies.viewport = Object.assign(Object.assign({}, vp), { getVisibleColumnRange: vp.getVisibleColumnRange
                 ? async (ctx) => {
@@ -85,15 +88,23 @@ const useTable = (rootLocator, configOptions = {}) => {
                         rowRangeCache = await vp.getVisibleRowRange(ctx);
                     return rowRangeCache;
                 }
+                : undefined, getVisibleRowIndices: vp.getVisibleRowIndices
+                ? async (ctx) => {
+                    if (!rowIndicesCache)
+                        rowIndicesCache = await vp.getVisibleRowIndices(ctx);
+                    return rowIndicesCache;
+                }
                 : undefined, scrollToColumn: vp.scrollToColumn
                 ? async (ctx, colIndex) => {
                     colRangeCache = null;
                     rowRangeCache = null;
+                    rowIndicesCache = null;
                     await vp.scrollToColumn(ctx, colIndex);
                 }
                 : undefined, scrollToRow: vp.scrollToRow
                 ? async (ctx, rowIndex) => {
                     rowRangeCache = null;
+                    rowIndicesCache = null;
                     await vp.scrollToRow(ctx, rowIndex);
                 }
                 : undefined });
@@ -137,7 +148,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex, barrier) => {
         return (0, smartRow_1.default)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex, barrier);
     };
-    const tableState = { currentPageIndex: 0 };
+    const tableState = { currentPageIndex: 0, empty: false };
     const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState, (useBulk) => _advancePage(useBulk));
     /** Builds a full TableContext/StrategyContext with getHeaderCell, getHeaders, scrollToColumn. Set after result is created. */
     let createStrategyContext = () => ({ root: rootLocator, config, page: rootLocator.page(), resolve });
@@ -215,7 +226,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         set currentPageIndex(v) { tableState.currentPageIndex = v; },
         init: async (options) => {
             var _a;
-            if (tableMapper.isInitialized())
+            if (tableMapper.isInitialized() || tableState.empty)
                 return result;
             if (config.strategies.sorting)
                 (0, validation_1.validateSortingStrategy)(config.strategies.sorting);
@@ -223,7 +234,21 @@ const useTable = (rootLocator, configOptions = {}) => {
                 (0, validation_1.validateFillStrategy)(config.strategies.fill);
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
-            const map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
+            let map;
+            try {
+                map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
+            }
+            catch (headerError) {
+                if (config.emptyState) {
+                    const visible = await config.emptyState.isVisible().catch(() => false);
+                    if (visible) {
+                        tableState.empty = true;
+                        (0, debugUtils_1.logDebug)(config, 'info', 'init: header resolution failed but emptyState locator is visible — table is empty');
+                        return result;
+                    }
+                }
+                throw headerError;
+            }
             (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${map.size} columns`, Array.from(map.keys()));
             if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.detectCurrentPage) {
                 try {
@@ -269,6 +294,8 @@ const useTable = (rootLocator, configOptions = {}) => {
             return resolve(config.headerSelector, rootLocator).nth(idx);
         },
         countRows: async () => {
+            if (tableState.empty)
+                return 0;
             await _autoInit();
             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));
@@ -280,6 +307,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             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));
@@ -292,11 +320,25 @@ const useTable = (rootLocator, configOptions = {}) => {
                     pagesScanned++;
                 }
             }
+            catch (e) {
+                paginationError = e;
+                throw e;
+            }
             finally {
                 await tracker.cleanup(rootLocator.page());
+                // Always restore page 1, even if pagination threw mid-count (#348), so the table
+                // stays usable for callers that catch the error. If reset() itself fails, only let
+                // it surface when pagination succeeded — otherwise preserve the original error.
+                log(`countRows: ${total} total row(s) across ${pagesScanned} page(s) — resetting`);
+                try {
+                    await result.reset();
+                }
+                catch (resetError) {
+                    if (paginationError === undefined)
+                        throw resetError;
+                    (0, debugUtils_1.logDebug)(config, 'error', 'countRows: reset() failed after pagination error', resetError);
+                }
             }
-            log(`countRows: ${total} total row(s) across ${pagesScanned} page(s) — resetting`);
-            await result.reset();
             return total;
         },
         mapColumn: async (columnName, options = {}) => {
@@ -311,7 +353,10 @@ const useTable = (rootLocator, configOptions = {}) => {
                 await cell.bringIntoView();
                 const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[columnName];
                 if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read) {
-                    return await columnOverride.read(cell);
+                    return await columnOverride.read(cell, {
+                        row, columnName, columnIndex: map.get(columnName),
+                        getCell: (name) => row.getCell(name),
+                    });
                 }
                 const text = await cell.innerText();
                 return (text || '').trim();
@@ -334,6 +379,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 log("No goToFirst strategy configured. Table may not be on page 1.");
             }
             tableState.currentPageIndex = 0;
+            tableState.empty = false;
             tableMapper.clear();
             log("Table reset complete. Calling autoInit to restore state.");
             await _autoInit();
@@ -341,6 +387,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         revalidate: async () => {
             log("Revalidating table structure...");
             await tableMapper.remapHeaders();
+            tableState.empty = false;
             log("Table revalidated.");
         },
         getRow: (filters, options = { exact: false }) => {
@@ -360,6 +407,55 @@ const useTable = (rootLocator, configOptions = {}) => {
             const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
             return _makeSmart(rowLocator, map, index);
         },
+        findRowByIndex: async (index, options) => {
+            var _a, _b;
+            log(`findRowByIndex: index=${index} options=${safeStringify(options)}`);
+            await _autoInit();
+            const map = tableMapper.getMapSync();
+            const resolveRI = config.strategies.resolveRowIndex;
+            const viewport = config.strategies.viewport;
+            // Identifying a row by its logical index requires a resolveRowIndex strategy. Without one
+            // the library can only offer render-window-relative getRowByIndex, or filter-based findRow.
+            if (!resolveRI) {
+                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).`);
+            }
+            // 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)
+                        return r;
+                }
+                return null;
+            };
+            // 1. Already mounted (no navigation needed)?
+            let loc = await findMounted();
+            // 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)) {
+                log(`findRowByIndex: scrolling to row ${index}`);
+                await viewport.scrollToRow(createStrategyContext(), index);
+                loc = await findMounted();
+            }
+            // 3. Fallback: advance pages (on infinite-scroll tables, a "page" is a scroll step) until
+            //    the row is reached. Bounded by maxPages so an unreachable index can't loop forever.
+            if (!loc && config.strategies.pagination) {
+                const effectiveMaxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
+                let pagesScanned = 1;
+                while (!loc && pagesScanned < effectiveMaxPages) {
+                    if (!await _advancePage(false))
+                        break;
+                    pagesScanned++;
+                    loc = await findMounted();
+                }
+            }
+            if (!loc) {
+                throw new Error(`findRowByIndex(${index}): could not reach row ${index}. ` +
+                    `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);
+        },
         findRow: async (filters, options) => {
             log(`findRow: filters=${safeStringify(filters)} options=${safeStringify(options)}`);
             return rowFinder.findRow(filters, options);
@@ -369,10 +465,13 @@ const useTable = (rootLocator, configOptions = {}) => {
             return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
         },
         isInitialized: () => {
-            const initialized = tableMapper.isInitialized();
+            const initialized = tableMapper.isInitialized() || tableState.empty;
             log(`isInitialized: ${initialized}`);
             return initialized;
         },
+        isEmpty: () => {
+            return tableState.empty;
+        },
         sorting: {
             apply: async (columnName, direction) => {
                 var _a;
@@ -419,6 +518,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         // ─── Shared async row iterator ───────────────────────────────────────────
         [Symbol.asyncIterator]() {
             return __asyncGenerator(this, arguments, function* _a() {
+                var _b;
                 yield __await(_autoInit());
                 const map = tableMapper.getMapSync();
                 const effectiveMaxPages = config.maxPages;
@@ -434,7 +534,13 @@ const useTable = (rootLocator, configOptions = {}) => {
                         const pageRows = yield __await(rowLocators.all());
                         const barrier = new navigationBarrier_1.NavigationBarrier(newIndices.length);
                         for (const idx of newIndices) {
-                            yield yield __await({ row: _makeSmart(pageRows[idx], map, rowIndex, tableState.currentPageIndex, barrier), index: rowIndex, rowIndex, pageIndex: tableState.currentPageIndex });
+                            // 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);
+                            // 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;
+                            yield yield __await({ row: sr, index: rowIndex, rowIndex: logical, pageIndex: tableState.currentPageIndex });
                             rowIndex++;
                         }
                         if (pagesScanned >= effectiveMaxPages)
@@ -462,6 +568,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
                 getCurrentPageIndex: () => tableState.currentPageIndex,
+                getContext: () => createStrategyContext(),
             }, callback, options);
         },
         map: async (callback, options = {}) => {
@@ -476,6 +583,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
                 getCurrentPageIndex: () => tableState.currentPageIndex,
+                getContext: () => createStrategyContext(),
             }, callback, options);
         },
         toArray: async (callback, options = {}) => {
@@ -500,6 +608,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
                 getCurrentPageIndex: () => tableState.currentPageIndex,
+                getContext: () => createStrategyContext(),
             }, predicate, options);
         },
         generateConfig: async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.17.1",
+  "version": "6.19.0",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -76,11 +76,21 @@
   },
   "typesVersions": {
     "*": {
-      "types": ["./dist/types.d.ts"],
-      "presets": ["./dist/presets/index.d.ts"],
-      "presets/mui": ["./dist/presets/mui.d.ts"],
-      "presets/rdg": ["./dist/presets/rdg.d.ts"],
-      "presets/glide": ["./dist/presets/glide/index.d.ts"]
+      "types": [
+        "./dist/types.d.ts"
+      ],
+      "presets": [
+        "./dist/presets/index.d.ts"
+      ],
+      "presets/mui": [
+        "./dist/presets/mui.d.ts"
+      ],
+      "presets/rdg": [
+        "./dist/presets/rdg.d.ts"
+      ],
+      "presets/glide": [
+        "./dist/presets/glide/index.d.ts"
+      ]
     }
   },
   "keywords": [