@rickcedwhat/playwright-smart-table 3.1.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: TableStrategies.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();
@@ -127,10 +129,10 @@ If your tests navigate deep into a paginated table, use `.reset()` to return to
 // Navigate deep into the table by searching for a row on a later page
 try {
   await table.searchForRow({ Name: 'Angelica Ramos' });
-} catch (e) {}
+} catch (e) { }
 
 // Reset internal state (and potentially UI) to initial page
-await table.reset(); 
+await table.reset();
 await table.init(); // Re-init after reset
 
 // Now subsequent searches start from the beginning
@@ -147,7 +149,7 @@ Efficiently extract all values from a specific column:
 ```typescript
 // Example from: https://datatables.net/examples/data_sources/dom
 // Quickly grab all text values from the "Office" column
-const offices = await table.getColumnValues('Office'); 
+const offices = await table.getColumnValues('Office');
 expect(offices).toContain('Tokyo');
 expect(offices.length).toBeGreaterThan(0);
 ```
@@ -193,8 +195,6 @@ For edge cases where auto-detection doesn't work (e.g., custom components, multi
 
 <!-- embed: fill-custom-mappers -->
 ```typescript
-const row = table.getByRow({ ID: '1' });
-
 // Use custom input mappers for specific columns
 await row.smartFill({
   Name: 'John Updated',
@@ -231,9 +231,11 @@ const table = useTable(page.locator('.MuiDataGrid-root').first(), {
   rowSelector: '.MuiDataGrid-row',
   headerSelector: '.MuiDataGrid-columnHeader',
   cellSelector: '.MuiDataGrid-cell',
-  pagination: TableStrategies.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 }) => {
@@ -335,18 +337,24 @@ 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 -->
 
-#### <a name="getallrows"></a>`getAllRows(options?)`
+#### <a name="getallcurrentrows"></a>`getAllCurrentRows(options?)`
+
+**Purpose:** Inclusive retrieval - gets all rows on the current page matching optional filters.
 
-**Purpose:** Inclusive retrieval - gets all rows matching optional filters.
+**Best for:** Checking existence, validating sort order, bulk data extraction on the current page.
 
-**Best for:** Checking existence, validating sort order, bulk data extraction.
+> **Note:** `getAllRows` is deprecated and will be removed in a future major version. Use `getAllCurrentRows` instead. The deprecated method still works for backwards compatibility.
 
 **Type Signature:**
 ```typescript
-getAllRows: <T extends { asJSON?: boolean }>(
+getAllCurrentRows: <T extends { asJSON?: boolean }>(
   options?: { filter?: Record<string, any>, exact?: boolean } & T
 ) => Promise<T['asJSON'] extends true ? Record<string, string>[] : SmartRow[]>;
 ```
@@ -355,17 +363,17 @@ getAllRows: <T extends { asJSON?: boolean }>(
 ```typescript
 // Example from: https://datatables.net/examples/data_sources/dom
 // 1. Get ALL rows on the current page
-const allRows = await table.getAllRows();
+const allRows = await table.getAllCurrentRows();
 expect(allRows.length).toBeGreaterThan(0);
 
 // 2. Get subset of rows (Filtering)
-const tokyoUsers = await table.getAllRows({
+const tokyoUsers = await table.getAllCurrentRows({
   filter: { Office: 'Tokyo' }
 });
 expect(tokyoUsers.length).toBeGreaterThan(0);
 
 // 3. Dump data to JSON
-const data = await table.getAllRows({ asJSON: true });
+const data = await table.getAllCurrentRows({ asJSON: true });
 console.log(data); // [{ Name: "Airi Satou", ... }, ...]
 expect(data.length).toBeGreaterThan(0);
 expect(data[0]).toHaveProperty('Name');
@@ -376,7 +384,7 @@ Filter rows with exact match:
 <!-- embed: get-all-rows-exact -->
 ```typescript
 // Get rows with exact match (default is fuzzy/contains match)
-const exactMatches = await table.getAllRows({
+const exactMatches = await table.getAllCurrentRows({
   filter: { Office: 'Tokyo' },
   exact: true // Requires exact string match
 });
@@ -405,7 +413,7 @@ Basic usage:
 ```typescript
 // Example from: https://datatables.net/examples/data_sources/dom
 // Quickly grab all text values from the "Office" column
-const offices = await table.getColumnValues('Office'); 
+const offices = await table.getColumnValues('Office');
 expect(offices).toContain('Tokyo');
 expect(offices.length).toBeGreaterThan(0);
 ```
@@ -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,13 +573,24 @@ A `SmartRow` extends Playwright's `Locator` with table-aware methods.
 
 <!-- embed-type: SmartRow -->
 ```typescript
-export type SmartRow = Locator & {
+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.
    */
-  smartFill: (data: Record<string, any>, options?: FillOptions) => Promise<void>;
+  bringIntoView(): Promise<void>;
+  /**
+   * Fills the row with data. Automatically detects input types.
+   */
+  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 -->
@@ -583,30 +608,60 @@ Configuration options for `useTable()`.
 
 <!-- embed-type: TableConfig -->
 ```typescript
-export interface TableConfig {
-  rowSelector?: Selector;
-  headerSelector?: Selector;
-  cellSelector?: Selector;
+/**
+ * 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;
+}
+
+/**
+ * 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.
+ */
+export interface TableConfig {
+  /** Selector for the table headers */
+  headerSelector?: string;
+  /** Selector for the table rows */
+  rowSelector?: string;
+  /** Selector for the cells within a row */
+  cellSelector?: string;
+  /** Number of pages to scan for verification */
   maxPages?: number;
-  /**
-   * Hook to rename columns dynamically.
-   * * @param args.text - The default innerText of the header.
-   * @param args.index - The column index.
-   * @param args.locator - The specific header cell locator.
-   */
+  /** Hook to rename columns dynamically */
   headerTransformer?: (args: { text: string, index: number, locator: Locator }) => string | Promise<string>;
+  /** Automatically scroll to table on init */
   autoScroll?: boolean;
-  /**
-   * Enable debug mode to log internal state to console.
-   */
+  /** Enable debug logs */
   debug?: boolean;
-  /**
-   * Strategy to reset the table to the initial page.
-   * Called when table.reset() is invoked.
-   */
+  /** Reset hook */
   onReset?: (context: TableContext) => Promise<void>;
+  /** All interaction strategies */
+  strategies?: TableStrategies;
 }
 ```
 <!-- /embed-type: TableConfig -->
@@ -616,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`)
@@ -630,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 -->
 
@@ -653,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

@@ -0,0 +1,52 @@
+import { StrategyContext } from '../types';
+/**
+ * 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 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.
+     * 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>;
+};