@rickcedwhat/playwright-smart-table 3.2.0 → 4.0.0

package/README.md

@@ -63,7 +63,7 @@ console.log(data);
 **Key Benefits:**
 - ✅ Column names instead of indices (survives column reordering)
 - ✅ Extends Playwright's `Locator` API (all `.click()`, `.isVisible()`, etc. work)
-- ✅ `.toJSON()` for quick data extraction
+- ✅ `.toJSON()` for quick data extraction (uses `columnStrategy` to ensure visibility)
 
 ---
 
@@ -81,9 +81,11 @@ const table = useTable(page.locator('#example'), {
   headerSelector: 'thead th',
   cellSelector: 'td',
   // Strategy: Tell it how to find the next page
-  pagination: PaginationStrategies.clickNext(() =>
-    page.getByRole('link', { name: 'Next' })
-  ),
+  strategies: {
+    pagination: Strategies.Pagination.clickNext(() =>
+      page.getByRole('link', { name: 'Next' })
+    )
+  },
   maxPages: 5 // Allow scanning up to 5 pages
 });
 await table.init();
@@ -229,9 +231,11 @@ const table = useTable(page.locator('.MuiDataGrid-root').first(), {
   rowSelector: '.MuiDataGrid-row',
   headerSelector: '.MuiDataGrid-columnHeader',
   cellSelector: '.MuiDataGrid-cell',
-  pagination: PaginationStrategies.clickNext(
-    (root) => root.getByRole("button", { name: "Go to next page" })
-  ),
+  strategies: {
+    pagination: Strategies.Pagination.clickNext(
+      (root) => root.getByRole("button", { name: "Go to next page" })
+    )
+  },
   maxPages: 5,
   // Transform empty columns (detected as __col_0, __col_1, etc.) to meaningful names
   headerTransformer: ({ text }) => {
@@ -333,6 +337,10 @@ const data = await row.toJSON();
 
 expect(data).toHaveProperty('Name', 'Airi Satou');
 expect(data).toHaveProperty('Position');
+
+// Get specific columns only (faster for large tables)
+const partial = await row.toJSON({ columns: ['Name'] });
+expect(partial).toEqual({ Name: 'Airi Satou' });
 ```
 <!-- /embed: get-by-row-json -->
 
@@ -463,32 +471,38 @@ This library uses the **Strategy Pattern** for pagination. Use built-in strategi
 
 ### Built-in Strategies
 
-#### <a name="tablestrategiesclicknext"></a>`TableStrategies.clickNext(selector)`
+#### <a name="tablestrategiesclicknext"></a>`Strategies.Pagination.clickNext(selector)`
 
 Best for standard paginated tables (Datatables, lists). Clicks a button/link and waits for table content to change.
 
 ```typescript
-pagination: TableStrategies.clickNext((root) =>
-  root.page().getByRole('button', { name: 'Next' })
-)
+strategies: {
+  pagination: Strategies.Pagination.clickNext((root) =>
+    root.page().getByRole('button', { name: 'Next' })
+  )
+}
 ```
 
-#### <a name="tablestrategiesinfinitescroll"></a>`TableStrategies.infiniteScroll()`
+#### <a name="tablestrategiesinfinitescroll"></a>`Strategies.Pagination.infiniteScroll()`
 
 Best for virtualized grids (AG-Grid, HTMX). Aggressively scrolls to trigger data loading.
 
 ```typescript
-pagination: TableStrategies.infiniteScroll()
+strategies: {
+  pagination: Strategies.Pagination.infiniteScroll()
+}
 ```
 
-#### <a name="tablestrategiesclickloadmore"></a>`TableStrategies.clickLoadMore(selector)`
+#### <a name="tablestrategiesclickloadmore"></a>`Strategies.Pagination.clickLoadMore(selector)`
 
 Best for "Load More" buttons. Clicks and waits for row count to increase.
 
 ```typescript
-pagination: TableStrategies.clickLoadMore((root) =>
-  root.getByRole('button', { name: 'Load More' })
-)
+strategies: {
+  pagination: Strategies.Pagination.clickLoadMore((root) =>
+    root.getByRole('button', { name: 'Load More' })
+  )
+}
 ```
 
 ### Custom Strategies
@@ -559,19 +573,24 @@ A `SmartRow` extends Playwright's `Locator` with table-aware methods.
 
 <!-- embed-type: SmartRow -->
 ```typescript
-export type SmartRow = Locator & {
-  getRequestIndex(): number | undefined; // Helper to get the row index if known
+export type SmartRow<T = any> = Locator & {
+  getRequestIndex(): number | undefined;
   rowIndex?: number;
   getCell(column: string): Locator;
-  toJSON(): Promise<Record<string, string>>;
+  toJSON(options?: { columns?: string[] }): Promise<T>;
   /**
-   * Fills the row with data. Automatically detects input types (text input, select, checkbox, etc.).
+   * Scrolls/paginates to bring this row into view.
+   * Only works if rowIndex is known.
    */
-  fill: (data: Record<string, any>, options?: FillOptions) => Promise<void>;
+  bringIntoView(): Promise<void>;
   /**
-   * Alias for fill() to avoid conflict with Locator.fill() 
+   * Fills the row with data. Automatically detects input types.
    */
-  smartFill: (data: Record<string, any>, options?: FillOptions) => Promise<void>;
+  fill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;
+  /**
+   * Alias for fill() to avoid conflict with Locator.fill()
+   */
+  smartFill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;
 };
 ```
 <!-- /embed-type: SmartRow -->
@@ -590,29 +609,36 @@ Configuration options for `useTable()`.
 <!-- embed-type: TableConfig -->
 ```typescript
 /**
-   * Output Strategy:
-   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).
-   * - 'console': Standard console logs (Default).
-   */
-  output?: 'console' | 'error';
-  includeTypes?: boolean;
+ * Strategy to filter rows based on criteria.
+ */
+export interface FilterStrategy {
+  apply(options: {
+    rows: Locator;
+    filter: { column: string, value: string | RegExp | number };
+    colIndex: number;
+    tableContext: TableContext;
+  }): Locator;
 }
 
-export type FillStrategy = (options: {
-  row: SmartRow;
-  columnName: string;
-  value: any;
-  index: number;
-  page: Page;
-  rootLocator: Locator;
-  table: TableResult; // The parent table instance
-  fillOptions?: FillOptions;
-}) => Promise<void>;
-
-export type { HeaderStrategy } from './strategies/headers';
-export type { ColumnStrategy } from './strategies/columns';
-import { HeaderStrategy } from './strategies/headers';
-import { ColumnStrategy } from './strategies/columns';
+/**
+ * Organized container for all table interaction strategies.
+ */
+export interface TableStrategies {
+  /** Strategy for discovering/scanning headers */
+  header?: HeaderStrategy;
+  /** Strategy for navigating to specific cells (row + column) */
+  cellNavigation?: CellNavigationStrategy;
+  /** Strategy for filling form inputs */
+  fill?: FillStrategy;
+  /** Strategy for paginating through data */
+  pagination?: PaginationStrategy;
+  /** Strategy for sorting columns */
+  sorting?: SortingStrategy;
+  /** Function to get a cell locator */
+  getCellLocator?: GetCellLocatorFn;
+  /** Function to get the currently active/focused cell */
+  getActiveCell?: GetActiveCellFn;
+}
 
 /**
  * Configuration options for useTable.
@@ -624,22 +650,9 @@ export interface TableConfig {
   rowSelector?: string;
   /** Selector for the cells within a row */
   cellSelector?: string;
-  /** Strategy for filling forms within the table */
-  fillStrategy?: FillStrategy;
-  /** Strategy for discovering headers */
-  headerStrategy?: HeaderStrategy;
-  /** Strategy for navigating to columns */
-  columnStrategy?: ColumnStrategy;
   /** Number of pages to scan for verification */
   maxPages?: number;
-
-  /** Pagination Strategy */
-  pagination?: PaginationStrategy;
-  /** Sorting Strategy */
-  sorting?: SortingStrategy;
-  /** 
-   * Hook to rename columns dynamically.
-   */
+  /** Hook to rename columns dynamically */
   headerTransformer?: (args: { text: string, index: number, locator: Locator }) => string | Promise<string>;
   /** Automatically scroll to table on init */
   autoScroll?: boolean;
@@ -647,12 +660,8 @@ export interface TableConfig {
   debug?: boolean;
   /** Reset hook */
   onReset?: (context: TableContext) => Promise<void>;
-  /**
-   * Custom resolver for finding a cell. 
-   * Overrides cellSelector logic if provided.
-   * Useful for virtualized tables where nth() index doesn't match DOM index.
-  */
-  cellResolver?: (args: { row: Locator, columnName: string, columnIndex: number, rowIndex?: number }) => Locator;
+  /** All interaction strategies */
+  strategies?: TableStrategies;
 }
 ```
 <!-- /embed-type: TableConfig -->
@@ -662,7 +671,7 @@ export interface TableConfig {
 - `rowSelector`: CSS selector or function for table rows (default: `"tbody tr"`)
 - `headerSelector`: CSS selector or function for header cells (default: `"th"`)
 - `cellSelector`: CSS selector or function for data cells (default: `"td"`)
-- `pagination`: Strategy function for navigating pages (default: no pagination)
+- `strategies`: Configuration object for interaction strategies (pagination, sorting, etc.)
 - `maxPages`: Maximum pages to scan when searching (default: `1`)
 - `headerTransformer`: Function to transform/rename column headers dynamically
 - `autoScroll`: Automatically scroll table into view (default: `true`)
@@ -676,6 +685,11 @@ Flexible selector type supporting strings, functions, or existing locators.
 <!-- embed-type: Selector -->
 ```typescript
 export type Selector = string | ((root: Locator | Page) => Locator);
+
+/**
+ * Function to get a cell locator given row, column info.
+ * Replaces the old cellResolver.
+ */
 ```
 <!-- /embed-type: Selector -->
 
@@ -699,11 +713,70 @@ Function signature for custom pagination logic.
 export type PaginationStrategy = (context: TableContext) => Promise<boolean>;
 ```
 <!-- /embed-type: PaginationStrategy -->
-
 Returns `true` if more data was loaded, `false` if pagination should stop.
 
 ---
 
+## 🔄 Migration Guide
+
+### Upgrading from v3.x to v4.0
+
+**Breaking Change**: Strategy imports are now consolidated under the `Strategies` object.
+
+#### Import Changes
+```typescript
+// ❌ Old (v3.x)
+import { PaginationStrategies, SortingStrategies } from '../src/useTable';
+
+// ✅ New (v4.0)
+import { Strategies } from '../src/strategies';
+// or
+import { useTable, Strategies } from '../src/useTable';
+```
+
+#### Strategy Usage
+```typescript
+// ❌ Old (v3.x)
+strategies: {
+  pagination: PaginationStrategies.clickNext(() => page.locator('#next')),
+  sorting: SortingStrategies.AriaSort(),
+  header: HeaderStrategies.scrollRight,
+  cellNavigation: ColumnStrategies.keyboard
+}
+
+// ✅ New (v4.0)
+strategies: {
+  pagination: Strategies.Pagination.clickNext(() => page.locator('#next')),
+  sorting: Strategies.Sorting.AriaSort(),
+  header: Strategies.Header.scrollRight,
+  cellNavigation: Strategies.Column.keyboard
+}
+```
+
+#### New Features (Optional)
+
+**Generic Type Support:**
+```typescript
+interface User {
+  Name: string;
+  Email: string;
+  Office: string;
+}
+
+const table = useTable<User>(page.locator('#table'), config);
+const data = await row.toJSON(); // Type: User (not Record<string, string>)
+```
+
+**Revalidate Method:**
+```typescript
+// Refresh column mappings when table structure changes
+await table.revalidate();
+```
+
+For detailed migration instructions optimized for AI code transformation, see the [AI Migration Guide](./MIGRATION_v4.md).
+
+---
+
 ## 🚀 Tips & Best Practices
 
 1. **Start Simple**: Try the defaults first - they work for most standard HTML tables

package/dist/filterEngine.d.ts

@@ -0,0 +1,11 @@
+import { Locator, Page } from "@playwright/test";
+import { FinalTableConfig } from "./types";
+export declare class FilterEngine {
+    private config;
+    private resolve;
+    constructor(config: FinalTableConfig, resolve: (selector: any, parent: Locator | Page) => Locator);
+    /**
+     * Applies filters to a set of rows.
+     */
+    applyFilters(baseRows: Locator, filters: Record<string, string | RegExp | number>, map: Map<string, number>, exact: boolean, page: Page): Locator;
+}

package/dist/filterEngine.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterEngine = void 0;
+class FilterEngine {
+    constructor(config, resolve) {
+        this.config = config;
+        this.resolve = resolve;
+    }
+    /**
+     * Applies filters to a set of rows.
+     */
+    applyFilters(baseRows, filters, map, exact, page) {
+        let filtered = baseRows;
+        // Iterate through each filter criteria
+        for (const [colName, value] of Object.entries(filters)) {
+            // Find column index
+            const colIndex = map.get(colName);
+            // TODO: Use ColumnStrategy for better resolution error handling
+            if (colIndex === undefined) {
+                throw new Error(`Filter Error: Column "${colName}" not found.`);
+            }
+            const filterVal = typeof value === 'number' ? String(value) : value;
+            // Use strategy if provided (For future: configured filter strategies)
+            // But for now, we implement the default logic or use custom if we add it to config later
+            // Default Filter Logic
+            const cellTemplate = this.resolve(this.config.cellSelector, page);
+            // This logic assumes 1:1 row-to-cell mapping based on index.
+            // filter({ has: ... }) checks if the row *contains* the matching cell.
+            // But we need to be specific about WHICH cell.
+            // Locator filtering by `has: locator.nth(index)` works if `locator` search is relative to the row.
+            filtered = filtered.filter({
+                has: cellTemplate.nth(colIndex).getByText(filterVal, { exact }),
+            });
+        }
+        return filtered;
+    }
+}
+exports.FilterEngine = FilterEngine;

package/dist/smartRow.d.ts

@@ -0,0 +1,7 @@
+import type { Locator, Page } from '@playwright/test';
+import { SmartRow as SmartRowType, FinalTableConfig, TableResult } from './types';
+/**
+ * Factory to create a SmartRow by extending a Playwright Locator.
+ * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
+ */
+export declare const createSmartRow: <T = any>(rowLocator: Locator, map: Map<string, number>, rowIndex: number | undefined, config: FinalTableConfig, rootLocator: Locator, resolve: (item: any, parent: Locator | Page) => Locator, table: TableResult<T> | null) => SmartRowType<T>;

package/dist/smartRow.js

@@ -0,0 +1,155 @@
+"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.createSmartRow = void 0;
+const fill_1 = require("./strategies/fill");
+/**
+ * Factory to create a SmartRow by extending a Playwright Locator.
+ * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
+ */
+const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve, table) => {
+    const smart = rowLocator;
+    // Attach State
+    smart.rowIndex = rowIndex;
+    smart.getRequestIndex = () => rowIndex;
+    // Attach Methods
+    smart.getCell = (colName) => {
+        const idx = map.get(colName);
+        if (idx === undefined) {
+            const availableColumns = Array.from(map.keys());
+            throw new Error(`Column "${colName}" not found. Available: ${availableColumns.join(', ')}`);
+        }
+        if (config.strategies.getCellLocator) {
+            return config.strategies.getCellLocator({
+                row: rowLocator,
+                columnName: colName,
+                columnIndex: idx,
+                rowIndex: rowIndex,
+                page: rootLocator.page()
+            });
+        }
+        return resolve(config.cellSelector, rowLocator).nth(idx);
+    };
+    smart.toJSON = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = {};
+        const page = rootLocator.page();
+        for (const [col, idx] of map.entries()) {
+            if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(col)) {
+                continue;
+            }
+            // Get the cell locator
+            const cell = config.strategies.getCellLocator
+                ? config.strategies.getCellLocator({
+                    row: rowLocator,
+                    columnName: col,
+                    columnIndex: idx,
+                    rowIndex: rowIndex,
+                    page: page
+                })
+                : resolve(config.cellSelector, rowLocator).nth(idx);
+            let targetCell = cell;
+            // Check if cell exists
+            const count = yield cell.count();
+            if (count === 0) {
+                // Optimization: Check if we are ALREADY at the target cell
+                if (config.strategies.getActiveCell) {
+                    const active = yield config.strategies.getActiveCell({
+                        config,
+                        root: rootLocator,
+                        page,
+                        resolve
+                    });
+                    if (active && active.rowIndex === rowIndex && active.columnIndex === idx) {
+                        if (config.debug)
+                            console.log(`[SmartRow] Already at target cell (r:${active.rowIndex}, c:${active.columnIndex}), skipping navigation.`);
+                        targetCell = active.locator;
+                        // Skip navigation and go to reading text
+                        const text = yield targetCell.innerText();
+                        result[col] = (text || '').trim();
+                        continue;
+                    }
+                }
+                // Cell doesn't exist - navigate to it
+                if (config.debug) {
+                    console.log(`[SmartRow.toJSON] Cell not found for column "${col}" (index ${idx}), navigating...`);
+                }
+                yield config.strategies.cellNavigation({
+                    config: config,
+                    root: rootLocator,
+                    page: page,
+                    resolve: resolve,
+                    column: col,
+                    index: idx,
+                    rowLocator: rowLocator,
+                    rowIndex: rowIndex
+                });
+                // Optimization: check if we can get the active cell directly
+                if (config.strategies.getActiveCell) {
+                    const activeCell = yield config.strategies.getActiveCell({
+                        config,
+                        root: rootLocator,
+                        page,
+                        resolve
+                    });
+                    if (activeCell) {
+                        if (config.debug) {
+                            console.log(`[SmartRow.toJSON] switching to active cell locator (r:${activeCell.rowIndex}, c:${activeCell.columnIndex})`);
+                        }
+                        targetCell = activeCell.locator;
+                    }
+                }
+            }
+            const text = yield targetCell.innerText();
+            result[col] = (text || '').trim();
+        }
+        return result;
+    });
+    // @ts-ignore
+    smart.fill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
+        for (const [colName, value] of Object.entries(data)) {
+            const colIdx = map.get(colName);
+            if (colIdx === undefined) {
+                throw new Error(`Column "${colName}" not found in fill data.`);
+            }
+            yield config.strategies.cellNavigation({
+                config: config,
+                root: rootLocator,
+                page: rootLocator.page(),
+                resolve: resolve,
+                column: colName,
+                index: colIdx,
+                rowLocator: rowLocator,
+                rowIndex: rowIndex
+            });
+            const strategy = config.strategies.fill || fill_1.FillStrategies.default;
+            yield strategy({
+                row: smart,
+                columnName: colName,
+                value,
+                index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
+                page: rowLocator.page(),
+                rootLocator,
+                table: table,
+                fillOptions
+            });
+        }
+    });
+    smart.bringIntoView = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (rowIndex === undefined) {
+            throw new Error('Cannot bring row into view - row index is unknown. Use getByRowIndex() instead of getByRow().');
+        }
+        // Scroll row into view using Playwright's built-in method
+        yield rowLocator.scrollIntoViewIfNeeded();
+    });
+    smart.smartFill = smart.fill;
+    return smart;
+};
+exports.createSmartRow = createSmartRow;

package/dist/strategies/columns.d.ts

@@ -1,14 +1,36 @@
 import { StrategyContext } from '../types';
 /**
- * Defines the contract for a column navigation strategy.
- * It is responsible for ensuring a specific column is visible/focused,
- * typically by scrolling or navigating to it.
+ * Defines the contract for a cell navigation strategy.
+ * It is responsible for ensuring a specific CELL is visible/focused (navigates to row + column),
+ * typically by scrolling or using keyboard navigation.
  */
-export type ColumnStrategy = (context: StrategyContext & {
+export type CellNavigationStrategy = (context: StrategyContext & {
     column: string;
     index: number;
     rowIndex?: number;
 }) => Promise<void>;
+/** @deprecated Use CellNavigationStrategy instead */
+export type ColumnStrategy = CellNavigationStrategy;
+export declare const 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: () => Promise<void>;
+    /**
+     * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
+     * to navigate to the target CELL (navigates down to the row, then right to the column).
+     *
+     * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
+     * or where keyboard navigation is the primary way to move focus.
+     */
+    keyboard: (context: StrategyContext & {
+        column: string;
+        index: number;
+        rowIndex?: number;
+    }) => Promise<void>;
+};
+/** @deprecated Use CellNavigationStrategies instead */
 export declare const ColumnStrategies: {
     /**
      * Default strategy: Assumes column is accessible or standard scrolling works.
@@ -17,7 +39,7 @@ export declare const ColumnStrategies: {
     default: () => Promise<void>;
     /**
      * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate to the target column index.
+     * to navigate to the target CELL (navigates down to the row, then right to the column).
      *
      * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
      * or where keyboard navigation is the primary way to move focus.

package/dist/strategies/columns.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnStrategies = void 0;
-exports.ColumnStrategies = {
+exports.ColumnStrategies = exports.CellNavigationStrategies = void 0;
+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.
@@ -20,7 +20,7 @@ exports.ColumnStrategies = {
     }),
     /**
      * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate to the target column index.
+     * to navigate to the target CELL (navigates down to the row, then right to the column).
      *
      * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
      * or where keyboard navigation is the primary way to move focus.
@@ -30,15 +30,14 @@ exports.ColumnStrategies = {
         if (typeof rowIndex !== 'number') {
             throw new Error('Row index is required for keyboard navigation');
         }
-        console.log(`[ColumnStrat:keyboard] Using Row Index Navigation: Row ${rowIndex}, Col ${index}`);
         yield root.focus();
-        yield page.waitForTimeout(200);
+        yield page.waitForTimeout(100);
         // Robust Navigation:
         // 1. Jump to Top-Left (Reset) - Sequence for Cross-OS (Mac/Windows)
         yield page.keyboard.press('Control+Home');
         yield page.keyboard.press('Meta+ArrowUp'); // Mac Go-To-Top
         yield page.keyboard.press('Home'); // Ensure start of row
-        yield page.waitForTimeout(300);
+        yield page.waitForTimeout(150);
         // 2. Move Down to Target Row
         for (let i = 0; i < rowIndex; i++) {
             yield page.keyboard.press('ArrowDown');
@@ -47,7 +46,9 @@ exports.ColumnStrategies = {
         for (let i = 0; i < index; i++) {
             yield page.keyboard.press('ArrowRight');
         }
-        yield page.waitForTimeout(100);
-        yield page.waitForTimeout(100);
+        yield page.waitForTimeout(50);
     })
 };
+// Backwards compatibility - deprecated
+/** @deprecated Use CellNavigationStrategies instead */
+exports.ColumnStrategies = exports.CellNavigationStrategies;

package/dist/strategies/headers.js

@@ -63,7 +63,6 @@ exports.HeaderStrategies = {
                 yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
                 yield page.waitForTimeout(300);
                 const newHeaders = yield getVisible();
-                console.log(`[HeaderStrat:scrollRight] Scrolled ${scrollAmount}, found: ${newHeaders.length} visible.`);
                 newHeaders.forEach(h => collectedHeaders.add(h));
                 if (collectedHeaders.size === sizeBefore) {
                     yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
@@ -115,7 +114,8 @@ exports.HeaderStrategies = {
         // Reset to home
         yield page.keyboard.press('Control+Home');
         yield page.keyboard.press('Home');
-        yield page.waitForTimeout(200);
+        // Wait for potential scroll/focus reset
+        yield page.evaluate(() => new Promise(requestAnimationFrame));
         currentHeaders = yield getVisible();
         currentHeaders.forEach(h => collectedHeaders.add(h));
         // 3. Navigate right loop
@@ -123,9 +123,9 @@ exports.HeaderStrategies = {
         for (let i = 0; i < limit; i++) {
             const sizeBefore = collectedHeaders.size;
             yield page.keyboard.press('ArrowRight');
-            yield page.waitForTimeout(100);
+            // Small breathing room for key press to register
+            yield page.evaluate(() => new Promise(requestAnimationFrame));
             const newHeaders = yield getVisible();
-            console.log(`[HeaderStrat:keyboard] Step ${i}, found visible: ${newHeaders}`);
             newHeaders.forEach(h => collectedHeaders.add(h));
             if (collectedHeaders.size === sizeBefore) {
                 silentCounter++;