@rickcedwhat/playwright-smart-table 6.6.0 → 6.7.1

package/README.md

@@ -76,13 +76,92 @@ const email = await row.getCell('Email').textContent();
 const allActive = await table.findRows({ Status: 'Active' });
 ```
 
+### Iterating Across Pages
+
+```typescript
+// forEach — sequential, safe for interactions (parallel: false default)
+await table.forEach(async ({ row, rowIndex, stop }) => {
+  if (await row.getCell('Status').innerText() === 'Done') stop();
+  await row.getCell('Checkbox').click();
+});
+
+// map — parallel within page, safe for reads (parallel: true default)
+const emails = await table.map(({ row }) => row.getCell('Email').innerText());
+
+// filter — async predicate across all pages, returns SmartRowArray
+const active = await table.filter(async ({ row }) =>
+  await row.getCell('Status').innerText() === 'Active'
+);
+
+// for await...of — low-level page-by-page iteration
+for await (const { row, rowIndex } of table) {
+  console.log(rowIndex, await row.getCell('Name').innerText());
+}
+```
+
+> **`map` + UI interactions:** `map` defaults to `parallel: true`. If your callback opens popovers,
+> fills inputs, or otherwise mutates UI state, pass `{ parallel: false }` to avoid overlapping interactions.
+
+### `filter` vs `findRows`
+
+| Use case | Best tool |
+|---|---|
+| Match by column value / regex / locator | `findRows` |
+| Computed value (math, range, derived) | `filter` |
+| Cross-column OR logic | `filter` |
+| Multi-step interaction in predicate (click, read, close) | `filter` |
+| Early exit after N matches | `filter` + `stop()` |
+
+**`findRows` is faster** for column-value matches — Playwright evaluates the locator natively with no DOM reads. **`filter` is more flexible** for logic that a CSS selector can't express.
+
+```typescript
+// findRows — structural match, no DOM reads, fast
+const notStarted = await table.findRows({
+  Status: (cell) => cell.locator('[class*="gray"]')
+});
+
+// filter — arbitrary async logic
+const expensive = await table.filter(async ({ row }) => {
+  const price = parseFloat(await row.getCell('Price').innerText());
+  const qty = parseFloat(await row.getCell('Qty').innerText());
+  return price * qty > 1000;
+});
+```
+
+### Advanced: `columnOverrides`
+
+For complex DOM structures, custom data extraction, or specialized input widgets, use `columnOverrides` to intercept how Smart Table interacts with specific columns:
+
+```typescript
+const table = useTable(page.locator('#table'), {
+  columnOverrides: {
+    // Override how data is read from the 'Status' column (e.g., for .toJSON())
+    Status: {
+      read: async (cell) => {
+        const isChecked = await cell.locator('input[type="checkbox"]').isChecked();
+        return isChecked ? 'Active' : 'Inactive';
+      }
+    },
+    // Override how data is written to the 'Tags' column (for .smartFill())
+    Tags: {
+      write: async (cell, value) => {
+        await cell.click();
+        await page.keyboard.type(value);
+        await page.keyboard.press('Enter');
+      }
+    }
+  }
+});
+```
+
 ## Key Features
 
 - 🎯 **Smart Locators** - Find rows by content, not position
-- 🧠 **Fuzzy Matching** - Smart suggestions for typos (e.g., incorrectly typed "Firstname" suggests "First Name" in error messages)
+- 🧠 **Fuzzy Matching** - Smart suggestions for typos in column names
 - ⚡ **Smart Initialization** - Handles loading states and dynamic headers automatically
 - 📄 **Auto-Pagination** - Search across all pages automatically
 - 🔍 **Column-Aware Access** - Access cells by column name
+- 🔁 **Iteration Methods** - `forEach`, `map`, `filter`, and `for await...of` across all pages
 - 🛠️ **Debug Mode** - Visual debugging with slow motion and logging
 - 🔌 **[Extensible Strategies](docs/concepts/strategies.md)** - Support any table implementation
 - 💪 **Type-Safe** - Full TypeScript support
@@ -108,11 +187,21 @@ const allActive = await table.findRows({ Status: 'Active' });
 
 ### ⚠️ Important Note on Pagination & Interactions
 
-When using `findRows` across multiple pages, the returned `SmartRow` locators represent elements that may no longer be attached to the current DOM if the table paginated past them.
+When `findRows` or `filter` paginates across pages, returned `SmartRow` locators point to rows that may be off the current DOM page.
+
+- **Data extraction:** Safe — `toJSON()` and cell reads work while the row is visible during iteration.
+- **Interactions after pagination:** Use `await row.bringIntoView()` first — it navigates back to the page the row was originally found on, then you can safely click/fill.
 
-- **Data Extraction:** Safe. You can use `table.iterateThroughTable()` to extract data (`await row.toJSON()`) while the row is visible.
-- **Interactions:** Unsafe directly. You cannot do `await row.click()` if the row is on Page 1 but the table is currently showing Page 3. 
-- **Solution:** If you need to interact with a row found on a previous page, you may be able to use `await row.bringIntoView()` before interacting with it to force the table to paginate back to that row (Note: this specific cross-page interaction flow is currently under testing).
+```typescript
+const active = await table.filter(async ({ row }) =>
+  await row.getCell('Status').innerText() === 'Active'
+);
+
+for (const row of active) {
+  await row.bringIntoView(); // navigate back to the row's page
+  await row.getCell('Checkbox').click(); // safe to interact
+}
+```
 
 ## Documentation
 

package/dist/engine/rowFinder.d.ts

@@ -19,10 +19,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRow<T>>;
-    findRows(filtersOrOptions?: (Partial<T> | Record<string, FilterValue>) & ({
-        exact?: boolean;
-        maxPages?: number;
-    }), legacyOptions?: {
+    findRows(filters?: Partial<T> | Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRowArray<T>>;

package/dist/engine/rowFinder.js

@@ -8,17 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RowFinder = void 0;
 const debugUtils_1 = require("../utils/debugUtils");
@@ -51,46 +40,26 @@ class RowFinder {
             yield (0, debugUtils_1.debugDelay)(this.config, 'findRow');
             const sentinel = this.resolve(this.config.rowSelector, this.rootLocator)
                 .filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
-            return this.makeSmartRow(sentinel, yield this.tableMapper.getMap(), 0);
+            const smartRow = this.makeSmartRow(sentinel, yield this.tableMapper.getMap(), 0);
+            smartRow._isSentinel = true;
+            return smartRow;
         });
     }
-    findRows(filtersOrOptions, 
-    // Deprecated: verify legacy usage pattern support
-    legacyOptions) {
+    findRows(filters, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Detect argument pattern:
-            // Pattern A: findRows({ Name: 'Alice' }, { maxPages: 5 })
-            // Pattern B: findRows({ maxPages: 5 })  <-- No filters, just options
-            // Pattern C: findRows({ Name: 'Alice' }) <-- Only filters
             var _a, _b;
-            let filters = {};
-            let options = {};
-            if (legacyOptions) {
-                // Pattern A
-                filters = filtersOrOptions;
-                options = legacyOptions;
-            }
-            else {
-                // Pattern B or C
-                // We need to separate unknown keys (filters) from known options (exact, maxPages)
-                // However, filtersOrOptions can be null/undefined
-                if (filtersOrOptions) {
-                    const _c = filtersOrOptions, { exact, maxPages } = _c, rest = __rest(_c, ["exact", "maxPages"]);
-                    options = { exact, maxPages };
-                    filters = rest;
-                }
-            }
+            const filtersRecord = filters || {};
             const map = yield this.tableMapper.getMap();
             const allRows = [];
-            const effectiveMaxPages = (_b = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
+            const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
             let pagesScanned = 1;
             const collectMatches = () => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 // ... logic ...
                 let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
                 // Only apply filters if we have them
-                if (Object.keys(filters).length > 0) {
-                    rowLocators = this.filterEngine.applyFilters(rowLocators, filters, map, (_a = options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page());
+                if (Object.keys(filtersRecord).length > 0) {
+                    rowLocators = this.filterEngine.applyFilters(rowLocators, filtersRecord, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page());
                 }
                 const currentRows = yield rowLocators.all();
                 const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
@@ -125,7 +94,7 @@ class RowFinder {
                     }
                     paginationResult = yield this.config.strategies.pagination.goNext(context);
                 }
-                const didPaginate = yield (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
                 if (!didPaginate)
                     break;
                 this.tableState.currentPageIndex++;

package/dist/engine/tableMapper.js

@@ -105,7 +105,7 @@ class TableMapper {
                     text = yield this.config.headerTransformer({
                         text,
                         index: i,
-                        locator: this.rootLocator.locator(this.config.headerSelector).nth(i),
+                        locator: this.resolve(this.config.headerSelector, this.rootLocator).nth(i),
                         seenHeaders
                     });
                 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from './useTable';
-export * from './types';
-export * from './plugins';
-export * from './strategies';
+export { useTable } from './useTable';
+export type { TableConfig, TableResult, SmartRow, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, } from './types';
+export { Strategies } from './strategies';
+export { Plugins } from './plugins';

package/dist/index.js

@@ -1,20 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./useTable"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./plugins"), exports);
-__exportStar(require("./strategies"), exports);
+exports.Plugins = exports.Strategies = exports.useTable = void 0;
+var useTable_1 = require("./useTable");
+Object.defineProperty(exports, "useTable", { enumerable: true, get: function () { return useTable_1.useTable; } });
+// Export namespace-like strategy collections
+var strategies_1 = require("./strategies");
+Object.defineProperty(exports, "Strategies", { enumerable: true, get: function () { return strategies_1.Strategies; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "Plugins", { enumerable: true, get: function () { return plugins_1.Plugins; } });

package/dist/plugins.d.ts

@@ -3,7 +3,6 @@ export declare const Plugins: {
         Strategies: {
             header: (context: import("./types").TableContext) => Promise<string[]>;
             getCellLocator: ({ row, columnIndex }: any) => any;
-            cellNavigation: ({ root, page, index }: any) => Promise<void>;
             navigation: {
                 goRight: ({ root, page }: any) => Promise<void>;
                 goLeft: ({ root, page }: any) => Promise<void>;

package/dist/smartRow.js

@@ -16,7 +16,6 @@ const debugUtils_1 = require("./utils/debugUtils");
 /**
  * Internal helper to navigate to a cell with active cell optimization.
  * Uses navigation primitives (goUp, goDown, goLeft, goRight, goHome) for orchestration.
- * Falls back to cellNavigation for backward compatibility.
  * Returns the target cell locator after navigation.
  */
 const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function* () {
@@ -91,7 +90,6 @@ const _navigateToCell = (params) => __awaiter(void 0, void 0, void 0, function*
         }
         return null;
     }
-    ;
     return null;
 });
 /**
@@ -121,24 +119,30 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
         }
         return resolve(config.cellSelector, rowLocator).nth(idx);
     };
+    smart.wasFound = () => {
+        return !smart._isSentinel;
+    };
     smart.toJSON = (options) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         const result = {};
         const page = rootLocator.page();
+        // Build a getHeaderCell helper for the beforeCellRead context.
+        // 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* () {
+                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;
             }
-            // Check if we have a column override or data mapper for this column
+            // Check if we have a column override for this column
             const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[col];
-            const mapper = (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read) || ((_b = config.dataMapper) === null || _b === void 0 ? void 0 : _b[col]);
-            if (mapper) {
-                // Use custom mapper
-                // Ensure we have the cell first (same navigation logic)
-                // ... wait, the navigation logic below assumes we need to navigate.
-                // If we have a mapper, we still need the cell locator.
-                // Let's reuse the navigation logic to get targetCell
-            }
+            const mapper = columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read;
             // --- Navigation Logic Start ---
             const cell = config.strategies.getCellLocator
                 ? config.strategies.getCellLocator({
@@ -168,6 +172,19 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 }
             }
             // --- Navigation Logic End ---
+            // Call beforeCellRead hook if configured.
+            // Fires for BOTH columnOverrides.read and the default innerText path.
+            if (config.strategies.beforeCellRead) {
+                yield config.strategies.beforeCellRead({
+                    cell: targetCell,
+                    columnName: col,
+                    columnIndex: idx,
+                    row: rowLocator,
+                    page,
+                    root: rootLocator,
+                    getHeaderCell,
+                });
+            }
             if (mapper) {
                 // Apply mapper
                 const mappedValue = yield mapper(targetCell);
@@ -182,6 +199,7 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
         return result;
     });
     smart.smartFill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
         (0, debugUtils_1.logDebug)(config, 'info', 'Filling row', data);
         for (const [colName, value] of Object.entries(data)) {
             if (value === undefined)
@@ -200,19 +218,35 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
                 rowLocator,
                 rowIndex
             });
-            const strategy = config.strategies.fill || fill_1.FillStrategies.default;
-            (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);
-            yield strategy({
-                row: smart,
-                columnName: colName,
-                value,
-                index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
-                page: rowLocator.page(),
-                rootLocator,
-                config,
-                table: table,
-                fillOptions
-            });
+            const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[colName];
+            if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.write) {
+                const cellLocator = smart.getCell(colName);
+                let currentValue;
+                if (columnOverride.read) {
+                    currentValue = yield columnOverride.read(cellLocator);
+                }
+                yield columnOverride.write({
+                    cell: cellLocator,
+                    targetValue: value,
+                    currentValue,
+                    row: smart
+                });
+            }
+            else {
+                const strategy = config.strategies.fill || fill_1.FillStrategies.default;
+                (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);
+                yield strategy({
+                    row: smart,
+                    columnName: colName,
+                    value,
+                    index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
+                    page: rowLocator.page(),
+                    rootLocator,
+                    config,
+                    table: table,
+                    fillOptions
+                });
+            }
             // Delay after filling
             yield (0, debugUtils_1.debugDelay)(config, 'getCell');
         }

package/dist/strategies/index.d.ts

@@ -8,25 +8,23 @@ export * from './dedupe';
 export * from './loading';
 export declare const Strategies: {
     Pagination: {
-        clickNext: (nextButtonSelector: import("..").Selector, options?: {
-            stabilization?: import("./stabilization").StabilizationStrategy;
-            timeout?: number;
-        }) => import("..").PaginationStrategy;
         click: (selectors: {
             next?: import("..").Selector;
             previous?: import("..").Selector;
+            nextBulk?: import("..").Selector;
+            previousBulk?: import("..").Selector;
             first?: import("..").Selector;
         }, options?: {
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
-        }) => import("..").PaginationStrategy;
+        }) => import("../types").PaginationStrategy;
         infiniteScroll: (options?: {
             action?: "scroll" | "js-scroll";
             scrollTarget?: import("..").Selector;
             scrollAmount?: number;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
-        }) => import("..").PaginationStrategy;
+        }) => import("../types").PaginationStrategy;
     };
     Sorting: {
         AriaSort: () => import("..").SortingStrategy;
@@ -38,13 +36,13 @@ export declare const Strategies: {
         visible: ({ config, resolve, root }: import("..").StrategyContext) => Promise<string[]>;
     };
     Fill: {
-        default: ({ row, columnName, value, fillOptions, config, table }: Parameters<import("..").FillStrategy>[0]) => Promise<void>;
+        default: ({ row, columnName, value, fillOptions, config, table }: Parameters<import("../types").FillStrategy>[0]) => Promise<void>;
     };
     Resolution: {
         default: import("./resolution").ColumnResolutionStrategy;
     };
     Dedupe: {
-        byTopPosition: (tolerance?: number) => import("..").DedupeStrategy;
+        byTopPosition: (tolerance?: number) => import("../types").DedupeStrategy;
     };
     Loading: {
         Table: {

package/dist/strategies/pagination.d.ts

@@ -1,27 +1,11 @@
 import type { PaginationStrategy, Selector } from '../types';
 import { StabilizationStrategy } from './stabilization';
 export declare const PaginationStrategies: {
-    /**
-     * Strategy: Clicks a "Next" button and waits for stabilization.
-     * Backward compatibility for when only a single 'next' selector was needed.
-     * @deprecated Use `click` with `{ next: selector }` instead.
-     */
-    clickNext: (nextButtonSelector: Selector, options?: {
-        stabilization?: StabilizationStrategy;
-        timeout?: number;
-    }) => PaginationStrategy;
-    /**
-     * Strategy: Classic Pagination Buttons.
-     * Clicks 'Next', 'Previous', or 'First' buttons and waits for stabilization.
-     *
-     * @param selectors Selectors for pagination buttons.
-     * @param options.stabilization Strategy to determine when the page has updated.
-     *        Defaults to `contentChanged({ scope: 'first' })`.
-     * @param options.timeout Timeout for the click action.
-     */
     click: (selectors: {
         next?: Selector;
         previous?: Selector;
+        nextBulk?: Selector;
+        previousBulk?: Selector;
         first?: Selector;
     }, options?: {
         stabilization?: StabilizationStrategy;

package/dist/strategies/pagination.js

@@ -12,23 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationStrategies = void 0;
 const stabilization_1 = require("./stabilization");
 exports.PaginationStrategies = {
-    /**
-     * Strategy: Clicks a "Next" button and waits for stabilization.
-     * Backward compatibility for when only a single 'next' selector was needed.
-     * @deprecated Use `click` with `{ next: selector }` instead.
-     */
-    clickNext: (nextButtonSelector, options = {}) => {
-        return exports.PaginationStrategies.click({ next: nextButtonSelector }, options);
-    },
-    /**
-     * Strategy: Classic Pagination Buttons.
-     * Clicks 'Next', 'Previous', or 'First' buttons and waits for stabilization.
-     *
-     * @param selectors Selectors for pagination buttons.
-     * @param options.stabilization Strategy to determine when the page has updated.
-     *        Defaults to `contentChanged({ scope: 'first' })`.
-     * @param options.timeout Timeout for the click action.
-     */
     click: (selectors, options = {}) => {
         var _a;
         const defaultStabilize = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.contentChanged({ scope: 'first', timeout: options.timeout });
@@ -49,6 +32,8 @@ exports.PaginationStrategies = {
         return {
             goNext: createClicker(selectors.next),
             goPrevious: createClicker(selectors.previous),
+            goNextBulk: createClicker(selectors.nextBulk),
+            goPreviousBulk: createClicker(selectors.previousBulk),
             goToFirst: createClicker(selectors.first)
         };
     },

package/dist/strategies/rdg.d.ts

@@ -9,10 +9,6 @@ export declare const scrollRightHeaderRDG: (context: TableContext) => Promise<st
  * changing during pagination/scrolling.
  */
 export declare const rdgGetCellLocator: ({ row, columnIndex }: any) => any;
-/**
- * Scrolls virtualized columns into view before reading.
- */
-export declare const rdgCellNavigation: ({ root, page, index }: any) => Promise<void>;
 /**
  * Scrolls the grid vertically to load more virtualized rows.
  */
@@ -27,7 +23,6 @@ export declare const rdgNavigation: {
 export declare const RDGStrategies: {
     header: (context: TableContext) => Promise<string[]>;
     getCellLocator: ({ row, columnIndex }: any) => any;
-    cellNavigation: ({ root, page, index }: any) => Promise<void>;
     navigation: {
         goRight: ({ root, page }: any) => Promise<void>;
         goLeft: ({ root, page }: any) => Promise<void>;

package/dist/strategies/rdg.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RDGStrategies = exports.rdgNavigation = exports.rdgPaginationStrategy = exports.rdgCellNavigation = exports.rdgGetCellLocator = exports.scrollRightHeaderRDG = void 0;
+exports.RDGStrategies = exports.rdgNavigation = exports.rdgPaginationStrategy = exports.rdgGetCellLocator = exports.scrollRightHeaderRDG = void 0;
 /**
  * Scrolls the grid horizontally to collect all column headers.
  * Handles empty headers by labeling them (e.g. "Checkbox").
@@ -64,22 +64,6 @@ const rdgGetCellLocator = ({ row, columnIndex }) => {
     return row.locator(`[role="gridcell"][aria-colindex="${ariaColIndex}"]`);
 };
 exports.rdgGetCellLocator = rdgGetCellLocator;
-/**
- * Scrolls virtualized columns into view before reading.
- */
-const rdgCellNavigation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page, index }) {
-    // Check if the column header is visible and scroll horizontally if needed
-    const headerCell = root.locator(`[role="columnheader"][aria-colindex="${index + 1}"]`);
-    const isVisible = yield headerCell.isVisible().catch(() => false);
-    if (!isVisible) {
-        const estimatedScroll = index * 150;
-        yield root.evaluate((el, scrollAmount) => {
-            el.scrollLeft = scrollAmount;
-        }, estimatedScroll);
-        yield page.waitForTimeout(300);
-    }
-});
-exports.rdgCellNavigation = rdgCellNavigation;
 /**
  * Scrolls the grid vertically to load more virtualized rows.
  */
@@ -136,7 +120,6 @@ exports.rdgNavigation = {
 exports.RDGStrategies = {
     header: exports.scrollRightHeaderRDG,
     getCellLocator: exports.rdgGetCellLocator,
-    cellNavigation: exports.rdgCellNavigation,
     navigation: exports.rdgNavigation,
     pagination: exports.rdgPaginationStrategy
 };

package/dist/strategies/sorting.js

@@ -23,44 +23,26 @@ exports.SortingStrategies = {
         return {
             doSort(_a) {
                 return __awaiter(this, arguments, void 0, function* ({ columnName, direction, context }) {
-                    const { resolve, config, root } = context;
-                    const headerLoc = resolve(config.headerSelector, root);
-                    const headers = yield headerLoc.all();
-                    const headerTexts = yield Promise.all(headers.map(h => h.innerText()));
-                    const columnIndex = headerTexts.findIndex(text => text.trim() === columnName);
-                    if (columnIndex === -1) {
-                        throw new Error(`[AriaSort] Header with text "${columnName}" not found.`);
-                    }
-                    const targetHeader = headers[columnIndex];
-                    // Click repeatedly to cycle through sort states
-                    for (let i = 0; i < 3; i++) { // Max 3 clicks to prevent infinite loops (none -> asc -> desc)
-                        const currentState = yield targetHeader.getAttribute('aria-sort');
-                        const mappedState = currentState === 'ascending' ? 'asc' : currentState === 'descending' ? 'desc' : 'none';
-                        if (mappedState === direction) {
-                            return; // Desired state achieved
-                        }
-                        yield targetHeader.click();
-                    }
-                    throw new Error(`[AriaSort] Could not achieve sort direction "${direction}" for column "${columnName}" after 3 clicks.`);
+                    // getHeaderCell is always present on TableContext after table is initialized
+                    const targetHeader = yield context.getHeaderCell(columnName);
+                    // The table engine handles verify-and-retry. We only provide the trigger here.
+                    yield targetHeader.click();
                 });
             },
             getSortState(_a) {
                 return __awaiter(this, arguments, void 0, function* ({ columnName, context }) {
-                    const { resolve, config, root } = context;
-                    const headerLoc = resolve(config.headerSelector, root);
-                    const headers = yield headerLoc.all();
-                    const headerTexts = yield Promise.all(headers.map(h => h.innerText()));
-                    const columnIndex = headerTexts.findIndex(text => text.trim() === columnName);
-                    if (columnIndex === -1) {
-                        return 'none'; // Header not found, so it's not sorted
+                    try {
+                        const targetHeader = yield context.getHeaderCell(columnName);
+                        const ariaSort = yield targetHeader.getAttribute('aria-sort');
+                        if (ariaSort === 'ascending')
+                            return 'asc';
+                        if (ariaSort === 'descending')
+                            return 'desc';
+                        return 'none';
+                    }
+                    catch (_b) {
+                        return 'none'; // Header not found, treat as unsorted
                     }
-                    const targetHeader = headers[columnIndex];
-                    const ariaSort = yield targetHeader.getAttribute('aria-sort');
-                    if (ariaSort === 'ascending')
-                        return 'asc';
-                    if (ariaSort === 'descending')
-                        return 'desc';
-                    return 'none';
                 });
             },
         };