@rickcedwhat/playwright-smart-table 6.8.2 → 6.10.0

package/dist/smartRow.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const fill_1 = require("./strategies/fill");
 const stringUtils_1 = require("./utils/stringUtils");
@@ -19,13 +10,14 @@ const sentinel_1 = require("./utils/sentinel");
  * Uses `strategies.navigation` primitives (goUp/goDown/goLeft/goRight, optional snap/seek/goHome).
  * Returns the target cell locator after navigation.
  */
-const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function* () {
+const _navigateToCell = async (params) => {
     const { config, rootLocator, page, resolve, column, index, rowLocator, rowIndex, barrier } = params;
-    (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: navigating to column "${column}" (index ${index})`);
+    const rowLabel = typeof rowIndex === 'number' ? `row ${rowIndex}` : 'row ?';
+    (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: resolving column "${column}" (colIndex ${index}), ${rowLabel}`);
     // Get active cell if strategy is available
     let activeCell = null;
     if (config.strategies.getActiveCell) {
-        activeCell = yield config.strategies.getActiveCell({
+        activeCell = await config.strategies.getActiveCell({
             config,
             root: rootLocator,
             page,
@@ -38,18 +30,107 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
         }
     }
     const context = { config, root: rootLocator, page, resolve };
+    // Shared helper: is the target cell currently in the DOM?
+    const targetReached = async () => {
+        if (config.strategies.getActiveCell) {
+            const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+            if (ac && ac.rowIndex === rowIndex && ac.columnIndex === index)
+                return true;
+        }
+        // Locator presence: virtualized grids (e.g. Glide) often attach the target `td` after scroll
+        // while focus id lags; do not require getActiveCell to match for this to count as reached.
+        const cell = config.strategies.getCellLocator
+            ? config.strategies.getCellLocator({ row: rowLocator, root: rootLocator, columnName: column, columnIndex: index, rowIndex, page, config })
+            : resolve(config.cellSelector, rowLocator).nth(index);
+        return (await cell.count() > 0);
+    };
+    const getCellLocator = () => config.strategies.getCellLocator
+        ? config.strategies.getCellLocator({ row: rowLocator, root: rootLocator, columnName: column, columnIndex: index, rowIndex, page, config })
+        : resolve(config.cellSelector, rowLocator).nth(index);
+    // Viewport-oracle phase: direct positioning for 2D virtualized tables.
+    // Runs before navigation primitives; falls through to them if cell still not accessible.
+    const viewport = config.strategies.viewport;
+    if (viewport && typeof rowIndex === 'number') {
+        // Fast path via range oracle: if the user provides getVisibleColumnRange (and memoizes it),
+        // this check is a near-instant JS lookup — no DOM count() round-trip needed.
+        // Rows do NOT sync at the barrier here — only scroll boundaries need coordination.
+        if (viewport.getVisibleColumnRange) {
+            const colRange = await viewport.getVisibleColumnRange(context);
+            if (colRange && index >= colRange.first && index <= colRange.last) {
+                const rowRange = viewport.getVisibleRowRange
+                    ? await viewport.getVisibleRowRange(context)
+                    : null;
+                const rowVisible = !rowRange || (rowIndex >= rowRange.first && rowIndex <= rowRange.last);
+                if (rowVisible && await targetReached()) {
+                    (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: col ${index} in visible range [${colRange.first}-${colRange.last}], reading directly`);
+                    return getCellLocator();
+                }
+            }
+        }
+        else if (await targetReached()) {
+            // No range oracle — fall back to DOM count() check.
+            if (barrier)
+                await barrier.sync(index);
+            return getCellLocator();
+        }
+        // Column is out of view. Scroll to bring it in.
+        // In synchronized mode, the last row to arrive triggers the scroll once for all rows.
+        const scrollIntoViewport = async () => {
+            const colRange = viewport.getVisibleColumnRange
+                ? await viewport.getVisibleColumnRange(context)
+                : null;
+            const colOutOfView = !colRange || index < colRange.first || index > colRange.last;
+            if (colOutOfView) {
+                (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: col ${index} out of view, scrolling`);
+                if (viewport.scrollToColumn) {
+                    await viewport.scrollToColumn(context, index);
+                }
+            }
+            // Some row locators (notably rows returned by findRow()) have a logical
+            // rowIndex that is not the grid's viewport coordinate. If the target cell
+            // is already mounted after any column scroll, avoid a misleading row jump.
+            if (await targetReached()) {
+                return;
+            }
+            // 2D scroll hazard guard: scrolling horizontally may have unmounted the target row.
+            const rowRange = viewport.getVisibleRowRange
+                ? await viewport.getVisibleRowRange(context)
+                : null;
+            const rowOutOfView = rowRange && (rowIndex < rowRange.first || rowIndex > rowRange.last);
+            if (rowOutOfView) {
+                (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: row ${rowIndex} out of view after col scroll, recovering`);
+                if (viewport.scrollToRow) {
+                    await viewport.scrollToRow(context, rowIndex);
+                }
+            }
+        };
+        if (barrier) {
+            await barrier.sync(index, scrollIntoViewport);
+        }
+        else {
+            await scrollIntoViewport();
+        }
+        if (await targetReached()) {
+            return getCellLocator();
+        }
+        // Cell still not accessible — fall through to navigation primitives if configured.
+        if (!config.strategies.navigation) {
+            (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: viewport phase could not reach cell, no navigation fallback configured');
+            return null;
+        }
+    }
     // Use navigation primitives if available
     if (config.strategies.navigation) {
         const nav = config.strategies.navigation;
         if (typeof rowIndex !== 'number') {
             throw new Error('Row index is required for navigation');
         }
-        const navigateOnce = () => __awaiter(void 0, void 0, void 0, function* () {
+        const navigateOnce = async () => {
             // Get current position again to be sure
             let currRow = 0;
             let currCol = 0;
             if (config.strategies.getActiveCell) {
-                const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                 if (ac) {
                     currRow = ac.rowIndex;
                     currCol = ac.columnIndex;
@@ -60,67 +141,51 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             // Move one step vertically
             if (rDiff > 0 && nav.goDown) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving down');
-                yield nav.goDown(context);
+                await nav.goDown(context);
             }
             else if (rDiff < 0 && nav.goUp) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving up');
-                yield nav.goUp(context);
+                await nav.goUp(context);
             }
             // Move one step horizontally
             if (cDiff > 0 && nav.goRight) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving right');
-                yield nav.goRight(context);
+                await nav.goRight(context);
             }
             else if (cDiff < 0 && nav.goLeft) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: moving left');
-                yield nav.goLeft(context);
+                await nav.goLeft(context);
             }
-        });
-        const targetReached = () => __awaiter(void 0, void 0, void 0, function* () {
-            if (config.strategies.getActiveCell) {
-                const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
-                if (ac && ac.rowIndex === rowIndex && ac.columnIndex === index)
-                    return true;
-            }
-            // Locator presence: virtualized grids (e.g. Glide) often attach the target `td` after scroll
-            // while focus id lags; do not require getActiveCell to match for this to count as reached.
-            const cell = config.strategies.getCellLocator
-                ? config.strategies.getCellLocator({ row: rowLocator, columnName: column, columnIndex: index, page })
-                : resolve(config.cellSelector, rowLocator).nth(index);
-            return ((yield cell.count()) > 0);
-        });
-        if (yield targetReached()) {
+        };
+        if (await targetReached()) {
             // Already there. If we have a barrier, check-in to stay in lock-step.
             if (barrier)
-                yield barrier.sync(index);
-            const cell = config.strategies.getCellLocator
-                ? config.strategies.getCellLocator({ row: rowLocator, columnName: column, columnIndex: index, page })
-                : resolve(config.cellSelector, rowLocator).nth(index);
-            return cell;
+                await barrier.sync(index);
+            return getCellLocator();
         }
         // If getActiveCell is present but returns null (no focus), and cell is in DOM,
         // try to focus it once before entering navigation loop.
         if (config.strategies.getActiveCell) {
-            const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+            const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
             if (!ac) {
                 const cell = resolve(config.cellSelector, rowLocator).nth(index);
-                if ((yield cell.count()) > 0) {
+                if (await cell.count() > 0) {
                     (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: cell "${column}" found but not focused; focusing.`);
-                    yield cell.focus();
+                    await cell.focus();
                     // Re-check target
-                    if (yield targetReached()) {
+                    if (await targetReached()) {
                         if (barrier)
-                            yield barrier.sync(index);
+                            await barrier.sync(index);
                         return cell;
                     }
                 }
             }
         }
-        const navigateUntilReached = () => __awaiter(void 0, void 0, void 0, function* () {
+        const navigateUntilReached = async () => {
             let currRow = 0;
             let currCol = 0;
             if (config.strategies.getActiveCell) {
-                const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                 if (ac) {
                     currRow = ac.rowIndex;
                     currCol = ac.columnIndex;
@@ -130,12 +195,12 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             // Navigate vertically (tight loop)
             for (let i = 0; i < Math.abs(rDiff); i++) {
                 if (rDiff > 0 && nav.goDown)
-                    yield nav.goDown(context);
+                    await nav.goDown(context);
                 else if (rDiff < 0 && nav.goUp)
-                    yield nav.goUp(context);
+                    await nav.goUp(context);
             }
             if (config.strategies.getActiveCell) {
-                const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                 if (ac) {
                     currRow = ac.rowIndex;
                     currCol = ac.columnIndex;
@@ -143,9 +208,9 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             }
             if (index === 0 && nav.snapFirstColumnIntoView) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', '_navigateToCell: snapFirstColumnIntoView for column index 0');
-                yield nav.snapFirstColumnIntoView(context);
+                await nav.snapFirstColumnIntoView(context);
                 if (config.strategies.getActiveCell) {
-                    const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                    const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                     if (ac) {
                         currRow = ac.rowIndex;
                         currCol = ac.columnIndex;
@@ -154,7 +219,7 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
                 // Home moves a11y focus within the current row to column 0. If focus row !== target row
                 // (e.g. still on previous row), Home jumps to grid origin and breaks `tr.nth(k)` reads.
                 if (typeof rowIndex === 'number' && currRow === rowIndex) {
-                    yield rootLocator.evaluate((el) => {
+                    await rootLocator.evaluate((el) => {
                         var _a;
                         const canvas = el.closest('canvas') || ((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.querySelector('canvas'));
                         if (canvas instanceof HTMLCanvasElement) {
@@ -162,10 +227,10 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
                             canvas.focus();
                         }
                     });
-                    yield page.keyboard.press('Home');
-                    yield page.waitForTimeout(120);
+                    await page.keyboard.press('Home');
+                    await page.waitForTimeout(120);
                     if (config.strategies.getActiveCell) {
-                        const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                        const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                         if (ac) {
                             currRow = ac.rowIndex;
                             currCol = ac.columnIndex;
@@ -176,9 +241,9 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             let cDiff = index - currCol;
             if (Math.abs(cDiff) > 12 && nav.seekColumnIndex) {
                 (0, debugUtils_1.logDebug)(config, 'verbose', `_navigateToCell: seekColumnIndex approx for column ${index}`);
-                yield nav.seekColumnIndex(context, index);
+                await nav.seekColumnIndex(context, index);
                 if (config.strategies.getActiveCell) {
-                    const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                    const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                     if (ac) {
                         currRow = ac.rowIndex;
                         currCol = ac.columnIndex;
@@ -188,14 +253,14 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             }
             for (let i = 0; i < Math.abs(cDiff); i++) {
                 if (cDiff > 0 && nav.goRight)
-                    yield nav.goRight(context);
+                    await nav.goRight(context);
                 else if (cDiff < 0 && nav.goLeft)
-                    yield nav.goLeft(context);
+                    await nav.goLeft(context);
             }
             const horizontalSteps = Math.abs(cDiff);
             if (horizontalSteps > 0) {
                 const settleMs = Math.min(2500, 60 + horizontalSteps * 12);
-                yield page.waitForTimeout(settleMs);
+                await page.waitForTimeout(settleMs);
             }
             // Wait for active cell to match target: poll getActiveCell or fallback to fixed delay
             // This is the "Midas Touch" buffer needed for Glide's async accessibility updates.
@@ -204,40 +269,38 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
             const start = Date.now();
             while (Date.now() - start < maxWaitMs) {
                 if (config.strategies.getActiveCell) {
-                    const ac = yield config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
+                    const ac = await config.strategies.getActiveCell({ config, root: rootLocator, page, resolve });
                     if (ac && ac.rowIndex === rowIndex && ac.columnIndex === index) {
                         return ac.locator;
                     }
                 }
-                if (yield targetReached()) {
+                if (await targetReached()) {
                     break;
                 }
-                yield page.waitForTimeout(pollIntervalMs);
+                await page.waitForTimeout(pollIntervalMs);
             }
-        });
+        };
         // Not there, perform (coordinated) navigation
         let navResult;
         if (barrier) {
-            navResult = yield barrier.sync(index, navigateUntilReached);
+            navResult = await barrier.sync(index, navigateUntilReached);
         }
         else {
-            navResult = yield navigateUntilReached();
+            navResult = await navigateUntilReached();
         }
         if (navResult instanceof Object && navResult._isLocator) {
             const loc = navResult;
-            if ((yield loc.count()) > 0)
+            if (await loc.count() > 0)
                 return loc;
         }
         // Return final locator if reached
-        const finalCell = config.strategies.getCellLocator
-            ? config.strategies.getCellLocator({ row: rowLocator, columnName: column, columnIndex: index, page })
-            : resolve(config.cellSelector, rowLocator).nth(index);
-        if ((yield finalCell.count()) > 0)
+        const finalCell = getCellLocator();
+        if (await finalCell.count() > 0)
             return finalCell;
         return null;
     }
     return null;
-});
+};
 /**
  * Factory to create a SmartRow by extending a Playwright Locator.
  * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
@@ -262,10 +325,12 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
         if (config.strategies.getCellLocator) {
             return config.strategies.getCellLocator({
                 row: rowLocator,
+                root: rootLocator,
                 columnName: colName,
                 columnIndex: idx,
                 rowIndex: rowIndex,
-                page: rootLocator.page()
+                page: rootLocator.page(),
+                config
             });
         }
         return resolve(config.cellSelector, rowLocator).nth(idx);
@@ -273,7 +338,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
     smart.wasFound = () => {
         return !smart[sentinel_1.SENTINEL_ROW];
     };
-    smart.toJSON = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    smart.toJSON = async (options) => {
         var _a;
         const result = {};
         const page = rootLocator.page();
@@ -281,12 +346,12 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
         // Uses the table reference if available, otherwise falls back to index-based lookup.
         const getHeaderCell = (table === null || table === void 0 ? void 0 : table.getHeaderCell)
             ? table.getHeaderCell.bind(table)
-            : (colName) => __awaiter(void 0, void 0, void 0, function* () {
+            : async (colName) => {
                 const idx = map.get(colName);
                 if (idx === undefined)
                     throw new Error(`Column "${colName}" not found`);
                 return resolve(config.headerSelector, rootLocator).nth(idx);
-            });
+            };
         for (const [col, idx] of map.entries()) {
             if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(col)) {
                 continue;
@@ -298,16 +363,18 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             const cell = config.strategies.getCellLocator
                 ? config.strategies.getCellLocator({
                     row: rowLocator,
+                    root: rootLocator,
                     columnName: col,
                     columnIndex: idx,
                     rowIndex: rowIndex,
-                    page: page
+                    page: page,
+                    config
                 })
                 : resolve(config.cellSelector, rowLocator).nth(idx);
             let targetCell = cell;
             // Always call _navigateToCell to ensure Lock-Step synchronization
             // even if the cell is already present (it handles check-in inside)
-            const navigatedCell = yield _navigateToCell({
+            const navigatedCell = await _navigateToCell({
                 config,
                 rootLocator,
                 page,
@@ -325,7 +392,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             // Call beforeCellRead hook if configured.
             // Fires for BOTH columnOverrides.read and the default innerText path.
             if (config.strategies.beforeCellRead) {
-                yield config.strategies.beforeCellRead({
+                await config.strategies.beforeCellRead({
                     cell: targetCell,
                     columnName: col,
                     columnIndex: idx,
@@ -337,18 +404,18 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             }
             if (mapper) {
                 // Apply mapper
-                const mappedValue = yield mapper(targetCell);
+                const mappedValue = await mapper(targetCell);
                 result[col] = mappedValue;
             }
             else {
                 // Default string extraction
-                const text = yield targetCell.innerText();
+                const text = await targetCell.innerText();
                 result[col] = (text || '').trim();
             }
         }
         return result;
-    });
-    smart.smartFill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    smart.smartFill = async (data, fillOptions) => {
         var _a;
         (0, debugUtils_1.logDebug)(config, 'info', 'Filling row', data);
         for (const [colName, value] of Object.entries(data)) {
@@ -358,7 +425,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             if (colIdx === undefined) {
                 throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
             }
-            yield _navigateToCell({
+            await _navigateToCell({
                 config,
                 rootLocator,
                 page: rootLocator.page(),
@@ -374,9 +441,9 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 const cellLocator = smart.getCell(colName);
                 let currentValue;
                 if (columnOverride.read) {
-                    currentValue = yield columnOverride.read(cellLocator);
+                    currentValue = await columnOverride.read(cellLocator);
                 }
-                yield columnOverride.write({
+                await columnOverride.write({
                     cell: cellLocator,
                     targetValue: value,
                     currentValue,
@@ -386,7 +453,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             else {
                 const strategy = config.strategies.fill || fill_1.FillStrategies.default;
                 (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);
-                yield strategy({
+                await strategy({
                     row: smart,
                     columnName: colName,
                     value,
@@ -399,11 +466,11 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 });
             }
             // Delay after filling
-            yield (0, debugUtils_1.debugDelay)(config, 'getCell');
+            await (0, debugUtils_1.debugDelay)(config, 'getCell');
         }
         (0, debugUtils_1.logDebug)(config, 'info', 'Row fill complete');
-    });
-    smart.bringIntoView = () => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    smart.bringIntoView = async () => {
         if (rowIndex === undefined) {
             throw new Error('Cannot bring row into view - row index is unknown. Use getRowByIndex() instead of getRow().');
         }
@@ -416,19 +483,19 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             const setCurrent = (n) => { parentTable.currentPageIndex = n; };
             if (primitives.goToPage) {
                 (0, debugUtils_1.logDebug)(config, 'info', `bringIntoView: Navigating to page ${tablePageIndex} (goToPage retry loop)`);
-                yield (0, paginationPath_1.executeNavigationWithGoToPageRetry)(tablePageIndex, primitives, context, getCurrent, setCurrent);
+                await (0, paginationPath_1.executeNavigationWithGoToPageRetry)(tablePageIndex, primitives, context, getCurrent, setCurrent);
             }
             else {
                 const path = (0, paginationPath_1.planNavigationPath)(getCurrent(), tablePageIndex, primitives);
                 if (path.length > 0) {
                     (0, debugUtils_1.logDebug)(config, 'info', `bringIntoView: Executing navigation path to page ${tablePageIndex} (${path.length} step(s))`);
-                    yield (0, paginationPath_1.executeNavigationPath)(path, primitives, context, getCurrent, setCurrent);
+                    await (0, paginationPath_1.executeNavigationPath)(path, primitives, context, getCurrent, setCurrent);
                 }
                 else if (primitives.goToFirst && primitives.goNext && tablePageIndex >= 0) {
                     (0, debugUtils_1.logDebug)(config, 'info', `bringIntoView: going to first page and looping goNext until we reach page ${tablePageIndex}`);
-                    yield primitives.goToFirst(context);
+                    await primitives.goToFirst(context);
                     for (let i = 0; i < tablePageIndex; i++) {
-                        const ok = yield primitives.goNext(context);
+                        const ok = await primitives.goNext(context);
                         if (!ok)
                             throw new Error(`bringIntoView: goNext failed before reaching page ${tablePageIndex}.`);
                     }
@@ -441,10 +508,10 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             }
         }
         // Delay after pagination/finding before scrolling
-        yield (0, debugUtils_1.debugDelay)(config, 'findRow');
+        await (0, debugUtils_1.debugDelay)(config, 'findRow');
         // Scroll row into view using Playwright's built-in method
-        yield rowLocator.scrollIntoViewIfNeeded();
-    });
+        await rowLocator.scrollIntoViewIfNeeded();
+    };
     return smart;
 };
 exports.default = createSmartRow;

package/dist/strategies/columns.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CellNavigationStrategies = void 0;
 exports.CellNavigationStrategies = {
@@ -15,7 +6,7 @@ exports.CellNavigationStrategies = {
      * Default strategy: Assumes column is accessible or standard scrolling works.
      * No specific action taken other than what Playwright's default locator handling does.
      */
-    default: () => __awaiter(void 0, void 0, void 0, function* () {
+    default: async () => {
         // No-op
-    })
+    }
 };

package/dist/strategies/dedupe.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DedupeStrategies = void 0;
 exports.DedupeStrategies = {
@@ -16,12 +7,12 @@ exports.DedupeStrategies = {
      * Useful for virtualized tables where row DOM elements are reused but content changes.
      * @param tolerance Pixel tolerance for position comparison (default: 2)
      */
-    byTopPosition: (tolerance = 2) => (row) => __awaiter(void 0, void 0, void 0, function* () {
-        const box = yield row.boundingBox();
+    byTopPosition: (tolerance = 2) => async (row) => {
+        const box = await row.boundingBox();
         if (!box)
             return 'unknown';
         // Round to nearest tolerance
         const y = Math.round(box.y / tolerance) * tolerance;
         return `pos_${y}`;
-    })
+    }
 };