@rickcedwhat/playwright-smart-table 6.7.0 → 6.7.3

package/README.md

@@ -128,6 +128,32 @@ const expensive = await table.filter(async ({ row }) => {
 });
 ```
 
+### 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

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,22 +8,12 @@ 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");
 const smartRowArray_1 = require("../utils/smartRowArray");
 const validation_1 = require("../strategies/validation");
+const elementTracker_1 = require("../utils/elementTracker");
 class RowFinder {
     constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }) {
         this.rootLocator = rootLocator;
@@ -51,87 +41,75 @@ 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());
-                }
-                const currentRows = yield rowLocators.all();
-                const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
-                for (let i = 0; i < currentRows.length; i++) {
-                    const smartRow = this.makeSmartRow(currentRows[i], map, allRows.length + i, this.tableState.currentPageIndex);
-                    if (isRowLoading && (yield isRowLoading(smartRow)))
-                        continue;
-                    allRows.push(smartRow);
-                }
-            });
-            // Scan first page
-            yield collectMatches();
-            // Pagination Loop - Corrected logic
-            // We always scan at least 1 page.
-            // If maxPages > 1, and we have a pagination strategy, we try to go next.
-            while (pagesScanned < effectiveMaxPages && this.config.strategies.pagination) {
-                const context = {
-                    root: this.rootLocator,
-                    config: this.config,
-                    resolve: this.resolve,
-                    page: this.rootLocator.page()
-                };
-                // Check if we should stop? (e.g. if we found enough rows? No, findRows finds ALL)
-                let paginationResult;
-                if (typeof this.config.strategies.pagination === 'function') {
-                    paginationResult = yield this.config.strategies.pagination(context);
-                }
-                else {
-                    // It's a PaginationPrimitives object, use goNext by default for findRows
-                    if (!this.config.strategies.pagination.goNext) {
-                        break; // Cannot paginate forward
+            const tracker = new elementTracker_1.ElementTracker('findRows');
+            try {
+                const collectMatches = () => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
+                    // Only apply filters if we have them
+                    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());
                     }
-                    paginationResult = yield this.config.strategies.pagination.goNext(context);
-                }
-                const didPaginate = yield (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
-                if (!didPaginate)
-                    break;
-                this.tableState.currentPageIndex++;
-                pagesScanned++;
-                // Wait for reload logic if needed? Usually pagination handles it.
+                    // Get only newly seen matched rows
+                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                    const currentRows = yield rowLocators.all();
+                    const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
+                    for (const idx of newIndices) {
+                        const smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex);
+                        if (isRowLoading && (yield isRowLoading(smartRow)))
+                            continue;
+                        allRows.push(smartRow);
+                    }
+                });
+                // Scan first page
                 yield collectMatches();
+                // Pagination Loop
+                while (pagesScanned < effectiveMaxPages && this.config.strategies.pagination) {
+                    const context = {
+                        root: this.rootLocator,
+                        config: this.config,
+                        resolve: this.resolve,
+                        page: this.rootLocator.page()
+                    };
+                    let paginationResult;
+                    if (typeof this.config.strategies.pagination === 'function') {
+                        paginationResult = yield this.config.strategies.pagination(context);
+                    }
+                    else {
+                        if (this.config.strategies.pagination.goNextBulk) {
+                            paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
+                        }
+                        else if (this.config.strategies.pagination.goNext) {
+                            paginationResult = yield this.config.strategies.pagination.goNext(context);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                    if (!didPaginate)
+                        break;
+                    const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
+                    this.tableState.currentPageIndex += pagesJumped;
+                    pagesScanned += pagesJumped;
+                    yield collectMatches();
+                }
+            }
+            finally {
+                yield tracker.cleanup(this.rootLocator.page());
             }
             return (0, smartRowArray_1.createSmartRowArray)(allRows);
         });
@@ -192,16 +170,22 @@ class RowFinder {
                         paginationResult = yield this.config.strategies.pagination(context);
                     }
                     else {
-                        if (!this.config.strategies.pagination.goNext) {
-                            this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext primitive).`);
+                        if (this.config.strategies.pagination.goNextBulk) {
+                            paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
+                        }
+                        else if (this.config.strategies.pagination.goNext) {
+                            paginationResult = yield this.config.strategies.pagination.goNext(context);
+                        }
+                        else {
+                            this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
                             return null;
                         }
-                        paginationResult = yield this.config.strategies.pagination.goNext(context);
                     }
                     const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
                     if (didLoadMore) {
-                        this.tableState.currentPageIndex++;
-                        pagesScanned++;
+                        const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
+                        this.tableState.currentPageIndex += pagesJumped;
+                        pagesScanned += pagesJumped;
                         continue;
                     }
                     else {

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 { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, } from './types';
+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/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>;
@@ -31,6 +30,9 @@ export declare const Plugins: {
                 goRight: (context: import("./types").StrategyContext) => Promise<void>;
                 goHome: (context: import("./types").StrategyContext) => Promise<void>;
             };
+            loading: {
+                isHeaderLoading: () => Promise<boolean>;
+            };
             getCellLocator: ({ row, columnIndex }: any) => any;
             getActiveCell: ({ page }: any) => Promise<{
                 rowIndex: number;

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,10 +119,23 @@ 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;
         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;
@@ -132,13 +143,6 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             // 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;
-            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
-            }
             // --- 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/glide.d.ts

@@ -33,6 +33,9 @@ export declare const GlideStrategies: {
         goRight: (context: import("../types").StrategyContext) => Promise<void>;
         goHome: (context: import("../types").StrategyContext) => Promise<void>;
     };
+    loading: {
+        isHeaderLoading: () => Promise<boolean>;
+    };
     getCellLocator: ({ row, columnIndex }: any) => any;
     getActiveCell: ({ page }: any) => Promise<{
         rowIndex: number;

package/dist/strategies/glide.js

@@ -115,6 +115,9 @@ exports.GlideStrategies = {
         goRight: columns_1.glideGoRight,
         goHome: columns_1.glideGoHome
     },
+    loading: {
+        isHeaderLoading: () => __awaiter(void 0, void 0, void 0, function* () { return false; }) // Glide renders headers on a canvas, there is no innerText delay
+    },
     getCellLocator: exports.glideGetCellLocator,
     getActiveCell: exports.glideGetActiveCell
 };

package/dist/strategies/index.d.ts

@@ -15,6 +15,8 @@ export declare const Strategies: {
             previousBulk?: import("..").Selector;
             first?: import("..").Selector;
         }, options?: {
+            nextBulkPages?: number;
+            previousBulkPages?: number;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
         }) => import("../types").PaginationStrategy;
@@ -33,7 +35,7 @@ export declare const Strategies: {
         default: () => Promise<void>;
     };
     Header: {
-        visible: ({ config, resolve, root }: import("../types").StrategyContext) => Promise<string[]>;
+        visible: ({ config, resolve, root }: import("..").StrategyContext) => Promise<string[]>;
     };
     Fill: {
         default: ({ row, columnName, value, fillOptions, config, table }: Parameters<import("../types").FillStrategy>[0]) => Promise<void>;
@@ -46,8 +48,8 @@ export declare const Strategies: {
     };
     Loading: {
         Table: {
-            hasSpinner: (selector?: string) => ({ root }: import("../types").TableContext) => Promise<boolean>;
-            custom: (fn: (context: import("../types").TableContext) => Promise<boolean>) => (context: import("../types").TableContext) => Promise<boolean>;
+            hasSpinner: (selector?: string) => ({ root }: import("..").TableContext) => Promise<boolean>;
+            custom: (fn: (context: import("..").TableContext) => Promise<boolean>) => (context: import("..").TableContext) => Promise<boolean>;
             never: () => Promise<boolean>;
         };
         Row: {
@@ -57,7 +59,7 @@ export declare const Strategies: {
             never: () => Promise<boolean>;
         };
         Headers: {
-            stable: (duration?: number) => (context: import("../types").TableContext) => Promise<boolean>;
+            stable: (duration?: number) => (context: import("..").TableContext) => Promise<boolean>;
             never: () => Promise<boolean>;
         };
     };

package/dist/strategies/pagination.d.ts

@@ -8,6 +8,8 @@ export declare const PaginationStrategies: {
         previousBulk?: Selector;
         first?: Selector;
     }, options?: {
+        nextBulkPages?: number;
+        previousBulkPages?: number;
         stabilization?: StabilizationStrategy;
         timeout?: number;
     }) => PaginationStrategy;

package/dist/strategies/pagination.js

@@ -13,9 +13,9 @@ exports.PaginationStrategies = void 0;
 const stabilization_1 = require("./stabilization");
 exports.PaginationStrategies = {
     click: (selectors, options = {}) => {
-        var _a;
+        var _a, _b, _c;
         const defaultStabilize = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.contentChanged({ scope: 'first', timeout: options.timeout });
-        const createClicker = (selector) => {
+        const createClicker = (selector, returnVal = true) => {
             if (!selector)
                 return undefined;
             return (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -26,14 +26,14 @@ exports.PaginationStrategies = {
                 }
                 return yield defaultStabilize(context, () => __awaiter(void 0, void 0, void 0, function* () {
                     yield btn.click({ timeout: 2000 }).catch(() => { });
-                }));
+                })).then(stabilized => stabilized ? returnVal : false);
             });
         };
         return {
             goNext: createClicker(selectors.next),
             goPrevious: createClicker(selectors.previous),
-            goNextBulk: createClicker(selectors.nextBulk),
-            goPreviousBulk: createClicker(selectors.previousBulk),
+            goNextBulk: createClicker(selectors.nextBulk, (_b = options.nextBulkPages) !== null && _b !== void 0 ? _b : 10),
+            goPreviousBulk: createClicker(selectors.previousBulk, (_c = options.previousBulkPages) !== null && _c !== void 0 ? _c : 10),
             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,21 +23,16 @@ exports.SortingStrategies = {
         return {
             doSort(_a) {
                 return __awaiter(this, arguments, void 0, function* ({ columnName, direction, context }) {
-                    const { getHeaderCell } = context;
-                    if (!getHeaderCell)
-                        throw new Error('getHeaderCell is required in StrategyContext for sorting.');
+                    // 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.
-                    const targetHeader = yield getHeaderCell(columnName);
                     yield targetHeader.click();
                 });
             },
             getSortState(_a) {
                 return __awaiter(this, arguments, void 0, function* ({ columnName, context }) {
-                    const { getHeaderCell } = context;
                     try {
-                        if (!getHeaderCell)
-                            throw new Error('getHeaderCell is required');
-                        const targetHeader = yield getHeaderCell(columnName);
+                        const targetHeader = yield context.getHeaderCell(columnName);
                         const ariaSort = yield targetHeader.getAttribute('aria-sort');
                         if (ariaSort === 'ascending')
                             return 'asc';
@@ -46,7 +41,7 @@ exports.SortingStrategies = {
                         return 'none';
                     }
                     catch (_b) {
-                        return 'none'; // Header not found, so it's not sorted
+                        return 'none'; // Header not found, treat as unsorted
                     }
                 });
             },

package/dist/strategies/validation.js

@@ -10,10 +10,13 @@ exports.validateFillStrategy = validateFillStrategy;
  * @param strategyName - Name of the strategy for error messages
  */
 function validatePaginationResult(result, strategyName = 'Custom Pagination Strategy') {
-    if (typeof result !== 'boolean') {
-        throw new Error(`[${strategyName}] Pagination strategy must return a boolean (true if paginated, false if no more pages). ` +
+    if (typeof result !== 'boolean' && typeof result !== 'number') {
+        throw new Error(`[${strategyName}] Pagination strategy must return a boolean (true if paginated, false if no more pages) or a number (pages jumped). ` +
             `Received: ${typeof result} (${JSON.stringify(result)})`);
     }
+    if (typeof result === 'number') {
+        return result > 0;
+    }
     return result;
 }
 /**