@rickcedwhat/playwright-smart-table 6.3.0 → 6.3.1

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './useTable';
 export * from './types';
+export * from './plugins';

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./useTable"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./plugins"), exports);

package/dist/plugins.d.ts

@@ -16,11 +16,13 @@ export declare const Plugins: {
                 selector?: string;
                 scrollAmount?: number;
             }) => Promise<string[]>;
-            cellNavigation: (context: import("./types").StrategyContext & {
-                column: string;
-                index: number;
-                rowIndex?: number;
-            }) => Promise<void>;
+            navigation: {
+                goUp: (context: import("./types").StrategyContext) => Promise<void>;
+                goDown: (context: import("./types").StrategyContext) => Promise<void>;
+                goLeft: (context: import("./types").StrategyContext) => Promise<void>;
+                goRight: (context: import("./types").StrategyContext) => Promise<void>;
+                goHome: (context: import("./types").StrategyContext) => Promise<void>;
+            };
             getCellLocator: ({ row, columnIndex }: any) => any;
             getActiveCell: ({ page }: any) => Promise<{
                 rowIndex: number;

package/dist/smartRow.js

@@ -13,6 +13,99 @@ exports.createSmartRow = void 0;
 const fill_1 = require("./strategies/fill");
 const stringUtils_1 = require("./utils/stringUtils");
 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* () {
+    const { config, rootLocator, page, resolve, column, index, rowLocator, rowIndex } = params;
+    // Get active cell if strategy is available
+    let activeCell = null;
+    if (config.strategies.getActiveCell) {
+        activeCell = yield config.strategies.getActiveCell({
+            config,
+            root: rootLocator,
+            page,
+            resolve
+        });
+        // Optimization: Check if we are ALREADY at the target cell
+        if (activeCell && activeCell.rowIndex === rowIndex && activeCell.columnIndex === index) {
+            // Skip navigation - we're already there!
+            return activeCell.locator;
+        }
+    }
+    const context = { config, root: rootLocator, page, resolve };
+    // Use navigation primitives if available
+    if (config.strategies.navigation) {
+        const nav = config.strategies.navigation;
+        if (typeof rowIndex !== 'number') {
+            throw new Error('Row index is required for navigation');
+        }
+        // Determine starting position
+        let startRow = 0;
+        let startCol = 0;
+        if (activeCell && activeCell.rowIndex >= 0 && activeCell.columnIndex >= 0) {
+            // Use current position
+            startRow = activeCell.rowIndex;
+            startCol = activeCell.columnIndex;
+        }
+        else if (nav.goHome) {
+            // Reset to top-left
+            yield nav.goHome(context);
+        }
+        // Calculate movement needed
+        const rowDiff = rowIndex - startRow;
+        const colDiff = index - startCol;
+        // Navigate vertically
+        for (let i = 0; i < Math.abs(rowDiff); i++) {
+            if (rowDiff > 0 && nav.goDown) {
+                yield nav.goDown(context);
+            }
+            else if (rowDiff < 0 && nav.goUp) {
+                yield nav.goUp(context);
+            }
+        }
+        // Navigate horizontally
+        for (let i = 0; i < Math.abs(colDiff); i++) {
+            if (colDiff > 0 && nav.goRight) {
+                yield nav.goRight(context);
+            }
+            else if (colDiff < 0 && nav.goLeft) {
+                yield nav.goLeft(context);
+            }
+        }
+        yield page.waitForTimeout(50);
+    }
+    else if (config.strategies.cellNavigation) {
+        // Fallback to legacy cellNavigation strategy
+        yield config.strategies.cellNavigation({
+            config,
+            root: rootLocator,
+            page,
+            resolve,
+            column,
+            index,
+            rowLocator,
+            rowIndex,
+            activeCell
+        });
+    }
+    // Get the active cell locator after navigation (for virtualized tables)
+    if (config.strategies.getActiveCell) {
+        const updatedActiveCell = yield config.strategies.getActiveCell({
+            config,
+            root: rootLocator,
+            page,
+            resolve
+        });
+        if (updatedActiveCell) {
+            return updatedActiveCell.locator;
+        }
+    }
+    return null;
+});
 /**
  * Factory to create a SmartRow by extending a Playwright Locator.
  * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
@@ -68,55 +161,19 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             let targetCell = cell;
             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) {
-                        targetCell = active.locator;
-                        // Skip navigation
-                    }
-                    else {
-                        // Cell doesn't exist - navigate to it
-                        yield config.strategies.cellNavigation({
-                            config: config,
-                            root: rootLocator,
-                            page: page,
-                            resolve: resolve,
-                            column: col,
-                            index: idx,
-                            rowLocator: rowLocator,
-                            rowIndex: rowIndex
-                        });
-                        // Update targetCell after navigation if needed (e.g. active cell changed)
-                        if (config.strategies.getActiveCell) {
-                            const activeCell = yield config.strategies.getActiveCell({
-                                config,
-                                root: rootLocator,
-                                page,
-                                resolve
-                            });
-                            if (activeCell)
-                                targetCell = activeCell.locator;
-                        }
-                    }
-                }
-                else {
-                    // Fallback navigation without active cell check
-                    yield config.strategies.cellNavigation({
-                        config: config,
-                        root: rootLocator,
-                        page: page,
-                        resolve: resolve,
-                        column: col,
-                        index: idx,
-                        rowLocator: rowLocator,
-                        rowIndex: rowIndex
-                    });
+                // Cell not in DOM (virtualized) - navigate to it
+                const navigatedCell = yield _navigateToCell({
+                    config,
+                    rootLocator,
+                    page,
+                    resolve,
+                    column: col,
+                    index: idx,
+                    rowLocator,
+                    rowIndex
+                });
+                if (navigatedCell) {
+                    targetCell = navigatedCell;
                 }
             }
             // --- Navigation Logic End ---
@@ -142,15 +199,15 @@ const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve,
             if (colIdx === undefined) {
                 throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
             }
-            yield config.strategies.cellNavigation({
-                config: config,
-                root: rootLocator,
+            yield _navigateToCell({
+                config,
+                rootLocator,
                 page: rootLocator.page(),
-                resolve: resolve,
+                resolve,
                 column: colName,
                 index: colIdx,
-                rowLocator: rowLocator,
-                rowIndex: rowIndex
+                rowLocator,
+                rowIndex
             });
             const strategy = config.strategies.fill || fill_1.FillStrategies.default;
             (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);

package/dist/strategies/columns.d.ts

@@ -1,13 +1,29 @@
+import type { Locator } from '@playwright/test';
 import { StrategyContext } from '../types';
 /**
+ * Primitive navigation functions that define HOW to move within a table.
+ * The orchestration logic (WHEN to move) lives in _navigateToCell.
+ */
+export interface NavigationPrimitives {
+    goUp?: (context: StrategyContext) => Promise<void>;
+    goDown?: (context: StrategyContext) => Promise<void>;
+    goLeft?: (context: StrategyContext) => Promise<void>;
+    goRight?: (context: StrategyContext) => Promise<void>;
+    goHome?: (context: StrategyContext) => Promise<void>;
+}
+/**
+ * @deprecated Use NavigationPrimitives instead. This will be removed in a future version.
  * 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;
+    activeCell?: {
+        rowIndex: number;
+        columnIndex: number;
+        locator: Locator;
+    } | null;
 }) => Promise<void>;
 export declare const CellNavigationStrategies: {
     /**

package/dist/strategies/glide/columns.d.ts

@@ -1,13 +1,11 @@
 import { StrategyContext } from '../../types';
 /**
- * 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.
+ * Primitive navigation functions for Glide Data Grid.
+ * These define HOW to move, not WHEN to move.
+ * The orchestration logic lives in _navigateToCell.
  */
-export declare const keyboardCellNavigation: (context: StrategyContext & {
-    column: string;
-    index: number;
-    rowIndex?: number;
-}) => Promise<void>;
+export declare const glideGoUp: (context: StrategyContext) => Promise<void>;
+export declare const glideGoDown: (context: StrategyContext) => Promise<void>;
+export declare const glideGoLeft: (context: StrategyContext) => Promise<void>;
+export declare const glideGoRight: (context: StrategyContext) => Promise<void>;
+export declare const glideGoHome: (context: StrategyContext) => Promise<void>;

package/dist/strategies/glide/columns.js

@@ -9,35 +9,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keyboardCellNavigation = void 0;
+exports.glideGoHome = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
 /**
- * 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.
+ * Primitive navigation functions for Glide Data Grid.
+ * These define HOW to move, not WHEN to move.
+ * The orchestration logic lives in _navigateToCell.
  */
-const keyboardCellNavigation = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    const { root, page, index, rowIndex } = context;
-    if (typeof rowIndex !== 'number') {
-        throw new Error('Row index is required for keyboard navigation');
-    }
+const glideGoUp = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowUp');
+});
+exports.glideGoUp = glideGoUp;
+const glideGoDown = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowDown');
+});
+exports.glideGoDown = glideGoDown;
+const glideGoLeft = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowLeft');
+});
+exports.glideGoLeft = glideGoLeft;
+const glideGoRight = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowRight');
+});
+exports.glideGoRight = glideGoRight;
+const glideGoHome = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const { root, page } = context;
     yield root.focus();
     yield page.waitForTimeout(100);
-    // Robust Navigation:
-    // 1. Jump to Top-Left (Reset) - Sequence for Cross-OS (Mac/Windows)
+    // Reset to top-left - Cross-OS sequence (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(150);
-    // 2. Move Down to Target Row
-    for (let i = 0; i < rowIndex; i++) {
-        yield page.keyboard.press('ArrowDown');
-    }
-    // 3. Move Right to Target Column
-    for (let i = 0; i < index; i++) {
-        yield page.keyboard.press('ArrowRight');
-    }
-    yield page.waitForTimeout(50);
 });
-exports.keyboardCellNavigation = keyboardCellNavigation;
+exports.glideGoHome = glideGoHome;

package/dist/strategies/glide.d.ts

@@ -15,11 +15,13 @@ export declare const GlideStrategies: {
         selector?: string;
         scrollAmount?: number;
     }) => Promise<string[]>;
-    cellNavigation: (context: import("../types").StrategyContext & {
-        column: string;
-        index: number;
-        rowIndex?: number;
-    }) => Promise<void>;
+    navigation: {
+        goUp: (context: import("../types").StrategyContext) => Promise<void>;
+        goDown: (context: import("../types").StrategyContext) => Promise<void>;
+        goLeft: (context: import("../types").StrategyContext) => Promise<void>;
+        goRight: (context: import("../types").StrategyContext) => Promise<void>;
+        goHome: (context: import("../types").StrategyContext) => Promise<void>;
+    };
     getCellLocator: ({ row, columnIndex }: any) => any;
     getActiveCell: ({ page }: any) => Promise<{
         rowIndex: number;

package/dist/strategies/glide.js

@@ -92,7 +92,13 @@ exports.GlideStrategies = {
     fill: exports.glideFillStrategy,
     pagination: exports.glidePaginationStrategy,
     header: headers_1.scrollRightHeader,
-    cellNavigation: columns_1.keyboardCellNavigation,
+    navigation: {
+        goUp: columns_1.glideGoUp,
+        goDown: columns_1.glideGoDown,
+        goLeft: columns_1.glideGoLeft,
+        goRight: columns_1.glideGoRight,
+        goHome: columns_1.glideGoHome
+    },
     getCellLocator: exports.glideGetCellLocator,
     getActiveCell: exports.glideGetActiveCell
 };

package/dist/typeContext.d.ts

@@ -3,4 +3,4 @@
  * This file is generated by scripts/embed-types.js
  * It contains the raw text of types.ts to provide context for LLM prompts.
  */
-export declare const TYPE_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string, function returning a Locator, or Locator itself.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * rowSelector: (root) => root.locator('[role=\"row\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator);\n\n/**\n * Value used to filter rows.\n * - string/number/RegExp: filter by text content of the cell.\n * - function: filter by custom locator logic within the cell.\n * @example\n * // Text filter\n * { Name: 'John' }\n * \n * // Custom locator filter (e.g. checkbox is checked)\n * { Status: (cell) => cell.locator('input:checked') }\n */\nexport type FilterValue = string | RegExp | number | ((cell: Locator) => Locator);\n\n/**\n * Function to get a cell locator given row, column info.\n * Replaces the old cellResolver.\n */\nexport type GetCellLocatorFn = (args: {\n  row: Locator;\n  columnName: string;\n  columnIndex: number;\n  rowIndex?: number;\n  page: Page;\n}) => Locator;\n\n/**\n * Function to get the currently active/focused cell.\n * Returns null if no cell is active.\n */\nexport type GetActiveCellFn = (args: TableContext) => Promise<{\n  rowIndex: number;\n  columnIndex: number;\n  columnName?: string;\n  locator: Locator;\n} | null>;\n\n\n/**\n * SmartRow - A Playwright Locator with table-aware methods.\n * \n * Extends all standard Locator methods (click, isVisible, etc.) with table-specific functionality.\n * \n * @example\n * const row = table.getRow({ Name: 'John Doe' });\n * await row.click(); // Standard Locator method\n * const email = row.getCell('Email'); // Table-aware method\n * const data = await row.toJSON(); // Extract all row data\n * await row.smartFill({ Name: 'Jane', Status: 'Active' }); // Fill form fields\n */\nexport type SmartRow<T = any> = Locator & {\n  /** Optional row index (0-based) if known */\n  rowIndex?: number;\n\n  /**\n   * Get a cell locator by column name.\n   * @param column - Column name (case-sensitive)\n   * @returns Locator for the cell\n   * @example\n   * const emailCell = row.getCell('Email');\n   * await expect(emailCell).toHaveText('john@example.com');\n   */\n  getCell(column: string): Locator;\n\n  /**\n   * Extract all cell data as a key-value object.\n   * @param options - Optional configuration\n   * @param options.columns - Specific columns to extract (extracts all if not specified)\n   * @returns Promise resolving to row data\n   * @example\n   * const data = await row.toJSON();\n   * // { Name: 'John', Email: 'john@example.com', ... }\n   * \n   * const partial = await row.toJSON({ columns: ['Name', 'Email'] });\n   * // { Name: 'John', Email: 'john@example.com' }\n   */\n  toJSON(options?: { columns?: string[] }): Promise<T>;\n\n  /**\n   * Scrolls/paginates to bring this row into view.\n   * Only works if rowIndex is known (e.g., from getRowByIndex).\n   * @throws Error if rowIndex is unknown\n   */\n  bringIntoView(): Promise<void>;\n\n  /**\n   * Intelligently fills form fields in the row.\n   * Automatically detects input types (text, select, checkbox, contenteditable).\n   * \n   * @param data - Column-value pairs to fill\n   * @param options - Optional configuration\n   * @param options.inputMappers - Custom input selectors per column\n   * @example\n   * // Auto-detection\n   * await row.smartFill({ Name: 'John', Status: 'Active', Subscribe: true });\n   * \n   * // Custom input mappers\n   * await row.smartFill(\n   *   { Name: 'John' },\n   *   { inputMappers: { Name: (cell) => cell.locator('.custom-input') } }\n   * );\n   */\n  smartFill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;\n};\n\nexport type StrategyContext = TableContext & { rowLocator?: Locator; rowIndex?: number };\n\n/**\n * Defines the contract for a sorting strategy.\n */\nexport interface SortingStrategy {\n  /**\n   * Performs the sort action on a column.\n   */\n  doSort(options: {\n    columnName: string;\n    direction: 'asc' | 'desc';\n    context: StrategyContext;\n  }): Promise<void>;\n\n  /**\n   * Retrieves the current sort state of a column.\n   */\n  getSortState(options: {\n    columnName: string;\n    context: StrategyContext;\n  }): Promise<'asc' | 'desc' | 'none'>;\n}\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  /**\n   * Slow down operations for debugging\n   * - number: Apply same delay to all operations (ms)\n   * - object: Granular delays per operation type\n   */\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  /**\n   * Log level for debug output\n   * - 'verbose': All logs (verbose, info, error)\n   * - 'info': Info and error logs only\n   * - 'error': Error logs only\n   * - 'none': No logs\n   */\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\nexport interface TableContext<T = any> {\n  root: Locator;\n  config: FinalTableConfig<T>;\n  page: Page;\n  resolve: (selector: Selector, parent: Locator | Page) => Locator;\n}\n\nexport type PaginationStrategy = (context: TableContext) => Promise<boolean>;\n\nexport type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;\n\nexport interface PromptOptions {\n  /**\n   * Output Strategy:\n   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).\n   * - 'console': Standard console logs (Default).\n   */\n  output?: 'console' | 'error';\n  includeTypes?: boolean;\n}\n\nexport type FillStrategy = (options: {\n  row: SmartRow;\n  columnName: string;\n  value: any;\n  index: number;\n  page: Page;\n  rootLocator: Locator;\n  table: TableResult; // The parent table instance\n  fillOptions?: FillOptions;\n}) => Promise<void>;\n\nexport type { HeaderStrategy } from './strategies/headers';\nexport type { CellNavigationStrategy } from './strategies/columns';\n\n/**\n * Strategy to resolve column names (string or regex) to their index.\n */\nexport type { ColumnResolutionStrategy } from './strategies/resolution';\n\n/**\n * Strategy to filter rows based on criteria.\n */\nexport interface FilterStrategy {\n  apply(options: {\n    rows: Locator;\n    filter: { column: string, value: FilterValue };\n    colIndex: number;\n    tableContext: TableContext;\n  }): Locator;\n}\n\n/**\n * Strategy to check if the table or rows are loading.\n */\nexport interface LoadingStrategy {\n  isTableLoading?: (context: TableContext) => Promise<boolean>;\n  isRowLoading?: (row: SmartRow) => Promise<boolean>;\n  isHeaderLoading?: (context: TableContext) => Promise<boolean>;\n}\n\n/**\n * Organized container for all table interaction strategies.\n */\nexport interface TableStrategies {\n  /** Strategy for discovering/scanning headers */\n  header?: HeaderStrategy;\n  /** Strategy for navigating to specific cells (row + column) */\n  cellNavigation?: CellNavigationStrategy;\n  /** Strategy for filling form inputs */\n  fill?: FillStrategy;\n  /** Strategy for paginating through data */\n  pagination?: PaginationStrategy;\n  /** Strategy for sorting columns */\n  sorting?: SortingStrategy;\n  /** Strategy for deduplicating rows during iteration/scrolling */\n  dedupe?: DedupeStrategy;\n  /** Function to get a cell locator */\n  getCellLocator?: GetCellLocatorFn;\n  /** Function to get the currently active/focused cell */\n  getActiveCell?: GetActiveCellFn;\n  /** Custom helper to check if a table is fully loaded/ready */\n  isTableLoaded?: (args: TableContext) => Promise<boolean>;\n  /** Custom helper to check if a row is fully loaded/ready */\n  isRowLoaded?: (args: { row: Locator, index: number }) => Promise<boolean>;\n  /** Custom helper to check if a cell is fully loaded/ready (e.g. for editing) */\n  isCellLoaded?: (args: { cell: Locator, column: string, row: Locator }) => Promise<boolean>;\n  /** Strategy for detecting loading states */\n  loading?: LoadingStrategy;\n}\n\n/**\n * Configuration options for useTable.\n */\n/**\n * Configuration options for useTable.\n */\nexport interface TableConfig<T = any> {\n  /** Selector for the table headers */\n  headerSelector?: string;\n  /** Selector for the table rows */\n  rowSelector?: string;\n  /** Selector for the cells within a row */\n  cellSelector?: string;\n  /** Number of pages to scan for verification */\n  maxPages?: number;\n  /** Hook to rename columns dynamically */\n  headerTransformer?: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  /** Automatically scroll to table on init */\n  autoScroll?: boolean;\n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  /** Reset hook */\n  onReset?: (context: TableContext) => Promise<void>;\n  /** All interaction strategies */\n  strategies?: TableStrategies;\n  /**\n   * Custom data mappers for specific columns.\n   * Allows extracting complex data types (boolean, number) instead of just string.\n   */\n  dataMapper?: Partial<Record<keyof T, (cell: Locator) => Promise<T[keyof T]> | T[keyof T]>>;\n}\n\nexport interface FinalTableConfigLike<T = any> extends TableConfig<T> {\n  headerSelector: string;\n  rowSelector: string;\n  cellSelector: string;\n  maxPages: number;\n  autoScroll: boolean;\n  debug?: TableConfig['debug'];\n  headerTransformer: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  onReset: (context: TableContext) => Promise<void>;\n  strategies: TableStrategies;\n}\n// Alias for backward compatibility if needed, or update usages\nexport type FinalTableConfig<T = any> = FinalTableConfigLike<T>;\n\n\nexport interface FillOptions {\n  /**\n   * Custom input mappers for specific columns.\n   * Maps column names to functions that return the input locator for that cell.\n   */\n  inputMappers?: Record<string, (cell: Locator) => Locator>;\n}\n\n/**\n * Options for generateConfigPrompt\n */\nexport interface PromptOptions {\n  /**\n   * Output Strategy:\n   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).\n   * - 'console': Standard console logs (Default).\n   */\n  output?: 'console' | 'error';\n  /**\n   * Include TypeScript type definitions in the prompt\n   * @default true\n   */\n  includeTypes?: boolean;\n}\n\nexport interface TableResult<T = any> {\n  /**\n   * Initializes the table by resolving headers. Must be called before using sync methods.\n   * @param options Optional timeout for header resolution (default: 3000ms)\n   */\n  init(options?: { timeout?: number }): Promise<TableResult>;\n\n  /**\n   * SYNC: Checks if the table has been initialized.\n   * @returns true if init() has been called and completed, false otherwise\n   */\n  isInitialized(): boolean;\n\n  getHeaders: () => Promise<string[]>;\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n\n  /**\n   * Finds a row by filters on the current page only. Returns immediately (sync).\n   * Throws error if table is not initialized.\n   */\n  getRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean }\n  ) => SmartRow;\n\n  /**\n   * Gets a row by 1-based index on the current page.\n   * Throws error if table is not initialized.\n   * @param index 1-based row index\n   * @param options Optional settings including bringIntoView\n   */\n  getRowByIndex: (\n    index: number,\n    options?: { bringIntoView?: boolean }\n  ) => SmartRow;\n\n  /**\n   * ASYNC: Searches for a single row across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRow>;\n\n  /**\n   * ASYNC: Searches for all matching rows across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRows: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRowArray<T>>;\n\n  /**\n   * Navigates to a specific column using the configured CellNavigationStrategy.\n   */\n  scrollToColumn: (columnName: string) => Promise<void>;\n\n  /**\n   * Gets all rows on the current page only (does not paginate).\n   * Auto-initializes the table if not already initialized.\n   * Returns a SmartRowArray which extends Array with a toJSON() helper method.\n   * @param options - Filter options\n   */\n  getRows: (options?: { filter?: Record<string, any>, exact?: boolean }) => Promise<SmartRowArray>;\n\n  /**\n   * Resets the table state (clears cache, flags) and invokes the onReset strategy.\n   */\n  reset: () => Promise<void>;\n\n  /**\n   * Revalidates the table's structure (headers, columns) without resetting pagination or state.\n   * Useful when columns change visibility or order dynamically.\n   */\n  revalidate: () => Promise<void>;\n\n  /**\n   * Scans a specific column across all pages and returns the values.\n   */\n  getColumnValues: <V = string>(column: string, options?: { mapper?: (cell: Locator) => Promise<V> | V, maxPages?: number }) => Promise<V[]>;\n\n  /**\n   * Provides access to sorting actions and assertions.\n   */\n  sorting: {\n    /**\n     * Applies the configured sorting strategy to the specified column.\n     * @param columnName The name of the column to sort.\n     * @param direction The direction to sort ('asc' or 'desc').\n     */\n    apply(columnName: string, direction: 'asc' | 'desc'): Promise<void>;\n    /**\n     * Gets the current sort state of a column using the configured sorting strategy.\n     * @param columnName The name of the column to check.\n     * @returns A promise that resolves to 'asc', 'desc', or 'none'.\n     */\n    getState(columnName: string): Promise<'asc' | 'desc' | 'none'>;\n  };\n\n  /**\n   * Iterates through paginated table data, calling the callback for each iteration.\n   * Callback return values are automatically appended to allData, which is returned.\n   */\n  iterateThroughTable: <T = any>(\n    callback: (context: {\n      index: number;\n      isFirst: boolean;\n      isLast: boolean;\n      rows: SmartRowArray;\n      allData: T[];\n      table: RestrictedTableResult;\n      batchInfo?: {\n        startIndex: number;\n        endIndex: number;\n        size: number;\n      };\n\n    }) => T | T[] | Promise<T | T[]>,\n    options?: {\n      pagination?: PaginationStrategy;\n      dedupeStrategy?: DedupeStrategy;\n      maxIterations?: number;\n      batchSize?: number;\n      getIsFirst?: (context: { index: number }) => boolean;\n      getIsLast?: (context: { index: number, paginationResult: boolean }) => boolean;\n      beforeFirst?: (context: { index: number, rows: SmartRowArray, allData: any[] }) => void | Promise<void>;\n      afterLast?: (context: { index: number, rows: SmartRowArray, allData: any[] }) => void | Promise<void>;\n      /**\n       * If true, flattens array results from callback into the main data array.\n       * If false (default), pushes the return value as-is (preserves batching/arrays).\n       */\n      autoFlatten?: boolean;\n    }\n  ) => Promise<T[]>;\n\n  /**\n   * Generate an AI-friendly configuration prompt for debugging.\n   * Outputs table HTML and TypeScript definitions to help AI assistants generate config.\n   */\n  generateConfigPrompt: (options?: PromptOptions) => Promise<void>;\n}\n\n/**\n * Restricted table result that excludes methods that shouldn't be called during iteration.\n */\nexport type RestrictedTableResult<T = any> = Omit<TableResult<T>, 'searchForRow' | 'iterateThroughTable' | 'reset'>;\n";
+export declare const TYPE_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string, function returning a Locator, or Locator itself.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * rowSelector: (root) => root.locator('[role=\"row\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator);\n\n/**\n * Value used to filter rows.\n * - string/number/RegExp: filter by text content of the cell.\n * - function: filter by custom locator logic within the cell.\n * @example\n * // Text filter\n * { Name: 'John' }\n * \n * // Custom locator filter (e.g. checkbox is checked)\n * { Status: (cell) => cell.locator('input:checked') }\n */\nexport type FilterValue = string | RegExp | number | ((cell: Locator) => Locator);\n\n/**\n * Function to get a cell locator given row, column info.\n * Replaces the old cellResolver.\n */\nexport type GetCellLocatorFn = (args: {\n  row: Locator;\n  columnName: string;\n  columnIndex: number;\n  rowIndex?: number;\n  page: Page;\n}) => Locator;\n\n/**\n * Function to get the currently active/focused cell.\n * Returns null if no cell is active.\n */\nexport type GetActiveCellFn = (args: TableContext) => Promise<{\n  rowIndex: number;\n  columnIndex: number;\n  columnName?: string;\n  locator: Locator;\n} | null>;\n\n\n/**\n * SmartRow - A Playwright Locator with table-aware methods.\n * \n * Extends all standard Locator methods (click, isVisible, etc.) with table-specific functionality.\n * \n * @example\n * const row = table.getRow({ Name: 'John Doe' });\n * await row.click(); // Standard Locator method\n * const email = row.getCell('Email'); // Table-aware method\n * const data = await row.toJSON(); // Extract all row data\n * await row.smartFill({ Name: 'Jane', Status: 'Active' }); // Fill form fields\n */\nexport type SmartRow<T = any> = Locator & {\n  /** Optional row index (0-based) if known */\n  rowIndex?: number;\n\n  /**\n   * Get a cell locator by column name.\n   * @param column - Column name (case-sensitive)\n   * @returns Locator for the cell\n   * @example\n   * const emailCell = row.getCell('Email');\n   * await expect(emailCell).toHaveText('john@example.com');\n   */\n  getCell(column: string): Locator;\n\n  /**\n   * Extract all cell data as a key-value object.\n   * @param options - Optional configuration\n   * @param options.columns - Specific columns to extract (extracts all if not specified)\n   * @returns Promise resolving to row data\n   * @example\n   * const data = await row.toJSON();\n   * // { Name: 'John', Email: 'john@example.com', ... }\n   * \n   * const partial = await row.toJSON({ columns: ['Name', 'Email'] });\n   * // { Name: 'John', Email: 'john@example.com' }\n   */\n  toJSON(options?: { columns?: string[] }): Promise<T>;\n\n  /**\n   * Scrolls/paginates to bring this row into view.\n   * Only works if rowIndex is known (e.g., from getRowByIndex).\n   * @throws Error if rowIndex is unknown\n   */\n  bringIntoView(): Promise<void>;\n\n  /**\n   * Intelligently fills form fields in the row.\n   * Automatically detects input types (text, select, checkbox, contenteditable).\n   * \n   * @param data - Column-value pairs to fill\n   * @param options - Optional configuration\n   * @param options.inputMappers - Custom input selectors per column\n   * @example\n   * // Auto-detection\n   * await row.smartFill({ Name: 'John', Status: 'Active', Subscribe: true });\n   * \n   * // Custom input mappers\n   * await row.smartFill(\n   *   { Name: 'John' },\n   *   { inputMappers: { Name: (cell) => cell.locator('.custom-input') } }\n   * );\n   */\n  smartFill: (data: Partial<T> | Record<string, any>, options?: FillOptions) => Promise<void>;\n};\n\nexport type StrategyContext = TableContext & { rowLocator?: Locator; rowIndex?: number };\n\n/**\n * Defines the contract for a sorting strategy.\n */\nexport interface SortingStrategy {\n  /**\n   * Performs the sort action on a column.\n   */\n  doSort(options: {\n    columnName: string;\n    direction: 'asc' | 'desc';\n    context: StrategyContext;\n  }): Promise<void>;\n\n  /**\n   * Retrieves the current sort state of a column.\n   */\n  getSortState(options: {\n    columnName: string;\n    context: StrategyContext;\n  }): Promise<'asc' | 'desc' | 'none'>;\n}\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  /**\n   * Slow down operations for debugging\n   * - number: Apply same delay to all operations (ms)\n   * - object: Granular delays per operation type\n   */\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  /**\n   * Log level for debug output\n   * - 'verbose': All logs (verbose, info, error)\n   * - 'info': Info and error logs only\n   * - 'error': Error logs only\n   * - 'none': No logs\n   */\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\nexport interface TableContext<T = any> {\n  root: Locator;\n  config: FinalTableConfig<T>;\n  page: Page;\n  resolve: (selector: Selector, parent: Locator | Page) => Locator;\n}\n\nexport type PaginationStrategy = (context: TableContext) => Promise<boolean>;\n\nexport type DedupeStrategy = (row: SmartRow) => string | number | Promise<string | number>;\n\nexport interface PromptOptions {\n  /**\n   * Output Strategy:\n   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).\n   * - 'console': Standard console logs (Default).\n   */\n  output?: 'console' | 'error';\n  includeTypes?: boolean;\n}\n\nexport type FillStrategy = (options: {\n  row: SmartRow;\n  columnName: string;\n  value: any;\n  index: number;\n  page: Page;\n  rootLocator: Locator;\n  table: TableResult; // The parent table instance\n  fillOptions?: FillOptions;\n}) => Promise<void>;\n\nexport type { HeaderStrategy } from './strategies/headers';\nexport type { CellNavigationStrategy, NavigationPrimitives } from './strategies/columns';\n\n/**\n * Strategy to resolve column names (string or regex) to their index.\n */\nexport type { ColumnResolutionStrategy } from './strategies/resolution';\n\n/**\n * Strategy to filter rows based on criteria.\n */\nexport interface FilterStrategy {\n  apply(options: {\n    rows: Locator;\n    filter: { column: string, value: FilterValue };\n    colIndex: number;\n    tableContext: TableContext;\n  }): Locator;\n}\n\n/**\n * Strategy to check if the table or rows are loading.\n */\nexport interface LoadingStrategy {\n  isTableLoading?: (context: TableContext) => Promise<boolean>;\n  isRowLoading?: (row: SmartRow) => Promise<boolean>;\n  isHeaderLoading?: (context: TableContext) => Promise<boolean>;\n}\n\n/**\n * Organized container for all table interaction strategies.\n */\nexport interface TableStrategies {\n  /** Strategy for discovering/scanning headers */\n  header?: HeaderStrategy;\n  /** Primitive navigation functions (goUp, goDown, goLeft, goRight, goHome) */\n  navigation?: NavigationPrimitives;\n  /** @deprecated Use navigation primitives instead. Strategy for navigating to specific cells (row + column) */\n  cellNavigation?: CellNavigationStrategy;\n  /** Strategy for filling form inputs */\n  fill?: FillStrategy;\n  /** Strategy for paginating through data */\n  pagination?: PaginationStrategy;\n  /** Strategy for sorting columns */\n  sorting?: SortingStrategy;\n  /** Strategy for deduplicating rows during iteration/scrolling */\n  dedupe?: DedupeStrategy;\n  /** Function to get a cell locator */\n  getCellLocator?: GetCellLocatorFn;\n  /** Function to get the currently active/focused cell */\n  getActiveCell?: GetActiveCellFn;\n  /** Custom helper to check if a table is fully loaded/ready */\n  isTableLoaded?: (args: TableContext) => Promise<boolean>;\n  /** Custom helper to check if a row is fully loaded/ready */\n  isRowLoaded?: (args: { row: Locator, index: number }) => Promise<boolean>;\n  /** Custom helper to check if a cell is fully loaded/ready (e.g. for editing) */\n  isCellLoaded?: (args: { cell: Locator, column: string, row: Locator }) => Promise<boolean>;\n  /** Strategy for detecting loading states */\n  loading?: LoadingStrategy;\n}\n\n/**\n * Configuration options for useTable.\n */\n/**\n * Configuration options for useTable.\n */\nexport interface TableConfig<T = any> {\n  /** Selector for the table headers */\n  headerSelector?: string;\n  /** Selector for the table rows */\n  rowSelector?: string;\n  /** Selector for the cells within a row */\n  cellSelector?: string;\n  /** Number of pages to scan for verification */\n  maxPages?: number;\n  /** Hook to rename columns dynamically */\n  headerTransformer?: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  /** Automatically scroll to table on init */\n  autoScroll?: boolean;\n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  /** Reset hook */\n  onReset?: (context: TableContext) => Promise<void>;\n  /** All interaction strategies */\n  strategies?: TableStrategies;\n  /**\n   * Custom data mappers for specific columns.\n   * Allows extracting complex data types (boolean, number) instead of just string.\n   */\n  dataMapper?: Partial<Record<keyof T, (cell: Locator) => Promise<T[keyof T]> | T[keyof T]>>;\n}\n\nexport interface FinalTableConfigLike<T = any> extends TableConfig<T> {\n  headerSelector: string;\n  rowSelector: string;\n  cellSelector: string;\n  maxPages: number;\n  autoScroll: boolean;\n  debug?: TableConfig['debug'];\n  headerTransformer: (args: { text: string, index: number, locator: Locator, seenHeaders: Set<string> }) => string | Promise<string>;\n  onReset: (context: TableContext) => Promise<void>;\n  strategies: TableStrategies;\n}\n// Alias for backward compatibility if needed, or update usages\nexport type FinalTableConfig<T = any> = FinalTableConfigLike<T>;\n\n\nexport interface FillOptions {\n  /**\n   * Custom input mappers for specific columns.\n   * Maps column names to functions that return the input locator for that cell.\n   */\n  inputMappers?: Record<string, (cell: Locator) => Locator>;\n}\n\n/**\n * Options for generateConfigPrompt\n */\nexport interface PromptOptions {\n  /**\n   * Output Strategy:\n   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).\n   * - 'console': Standard console logs (Default).\n   */\n  output?: 'console' | 'error';\n  /**\n   * Include TypeScript type definitions in the prompt\n   * @default true\n   */\n  includeTypes?: boolean;\n}\n\nexport interface TableResult<T = any> {\n  /**\n   * Initializes the table by resolving headers. Must be called before using sync methods.\n   * @param options Optional timeout for header resolution (default: 3000ms)\n   */\n  init(options?: { timeout?: number }): Promise<TableResult>;\n\n  /**\n   * SYNC: Checks if the table has been initialized.\n   * @returns true if init() has been called and completed, false otherwise\n   */\n  isInitialized(): boolean;\n\n  getHeaders: () => Promise<string[]>;\n  getHeaderCell: (columnName: string) => Promise<Locator>;\n\n  /**\n   * Finds a row by filters on the current page only. Returns immediately (sync).\n   * Throws error if table is not initialized.\n   */\n  getRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean }\n  ) => SmartRow;\n\n  /**\n   * Gets a row by 1-based index on the current page.\n   * Throws error if table is not initialized.\n   * @param index 1-based row index\n   * @param options Optional settings including bringIntoView\n   */\n  getRowByIndex: (\n    index: number,\n    options?: { bringIntoView?: boolean }\n  ) => SmartRow;\n\n  /**\n   * ASYNC: Searches for a single row across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRow: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRow>;\n\n  /**\n   * ASYNC: Searches for all matching rows across pages using pagination.\n   * Auto-initializes the table if not already initialized.\n   * @param filters - The filter criteria to match\n   * @param options - Search options including exact match and max pages\n   */\n  findRows: (\n    filters: Record<string, FilterValue>,\n    options?: { exact?: boolean, maxPages?: number }\n  ) => Promise<SmartRowArray<T>>;\n\n  /**\n   * Navigates to a specific column using the configured CellNavigationStrategy.\n   */\n  scrollToColumn: (columnName: string) => Promise<void>;\n\n  /**\n   * Gets all rows on the current page only (does not paginate).\n   * Auto-initializes the table if not already initialized.\n   * Returns a SmartRowArray which extends Array with a toJSON() helper method.\n   * @param options - Filter options\n   */\n  getRows: (options?: { filter?: Record<string, any>, exact?: boolean }) => Promise<SmartRowArray>;\n\n  /**\n   * Resets the table state (clears cache, flags) and invokes the onReset strategy.\n   */\n  reset: () => Promise<void>;\n\n  /**\n   * Revalidates the table's structure (headers, columns) without resetting pagination or state.\n   * Useful when columns change visibility or order dynamically.\n   */\n  revalidate: () => Promise<void>;\n\n  /**\n   * Scans a specific column across all pages and returns the values.\n   */\n  getColumnValues: <V = string>(column: string, options?: { mapper?: (cell: Locator) => Promise<V> | V, maxPages?: number }) => Promise<V[]>;\n\n  /**\n   * Provides access to sorting actions and assertions.\n   */\n  sorting: {\n    /**\n     * Applies the configured sorting strategy to the specified column.\n     * @param columnName The name of the column to sort.\n     * @param direction The direction to sort ('asc' or 'desc').\n     */\n    apply(columnName: string, direction: 'asc' | 'desc'): Promise<void>;\n    /**\n     * Gets the current sort state of a column using the configured sorting strategy.\n     * @param columnName The name of the column to check.\n     * @returns A promise that resolves to 'asc', 'desc', or 'none'.\n     */\n    getState(columnName: string): Promise<'asc' | 'desc' | 'none'>;\n  };\n\n  /**\n   * Iterates through paginated table data, calling the callback for each iteration.\n   * Callback return values are automatically appended to allData, which is returned.\n   */\n  iterateThroughTable: <T = any>(\n    callback: (context: {\n      index: number;\n      isFirst: boolean;\n      isLast: boolean;\n      rows: SmartRowArray;\n      allData: T[];\n      table: RestrictedTableResult;\n      batchInfo?: {\n        startIndex: number;\n        endIndex: number;\n        size: number;\n      };\n\n    }) => T | T[] | Promise<T | T[]>,\n    options?: {\n      pagination?: PaginationStrategy;\n      dedupeStrategy?: DedupeStrategy;\n      maxIterations?: number;\n      batchSize?: number;\n      getIsFirst?: (context: { index: number }) => boolean;\n      getIsLast?: (context: { index: number, paginationResult: boolean }) => boolean;\n      beforeFirst?: (context: { index: number, rows: SmartRowArray, allData: any[] }) => void | Promise<void>;\n      afterLast?: (context: { index: number, rows: SmartRowArray, allData: any[] }) => void | Promise<void>;\n      /**\n       * If true, flattens array results from callback into the main data array.\n       * If false (default), pushes the return value as-is (preserves batching/arrays).\n       */\n      autoFlatten?: boolean;\n    }\n  ) => Promise<T[]>;\n\n  /**\n   * Generate an AI-friendly configuration prompt for debugging.\n   * Outputs table HTML and TypeScript definitions to help AI assistants generate config.\n   */\n  generateConfigPrompt: (options?: PromptOptions) => Promise<void>;\n}\n\n/**\n * Restricted table result that excludes methods that shouldn't be called during iteration.\n */\nexport type RestrictedTableResult<T = any> = Omit<TableResult<T>, 'searchForRow' | 'iterateThroughTable' | 'reset'>;\n";

package/dist/typeContext.js

@@ -204,7 +204,7 @@ export type FillStrategy = (options: {
 }) => Promise<void>;
 
 export type { HeaderStrategy } from './strategies/headers';
-export type { CellNavigationStrategy } from './strategies/columns';
+export type { CellNavigationStrategy, NavigationPrimitives } from './strategies/columns';
 
 /**
  * Strategy to resolve column names (string or regex) to their index.
@@ -238,7 +238,9 @@ export interface LoadingStrategy {
 export interface TableStrategies {
   /** Strategy for discovering/scanning headers */
   header?: HeaderStrategy;
-  /** Strategy for navigating to specific cells (row + column) */
+  /** Primitive navigation functions (goUp, goDown, goLeft, goRight, goHome) */
+  navigation?: NavigationPrimitives;
+  /** @deprecated Use navigation primitives instead. Strategy for navigating to specific cells (row + column) */
   cellNavigation?: CellNavigationStrategy;
   /** Strategy for filling form inputs */
   fill?: FillStrategy;

package/dist/types.d.ts

@@ -183,9 +183,9 @@ export type FillStrategy = (options: {
     fillOptions?: FillOptions;
 }) => Promise<void>;
 export type { HeaderStrategy } from './strategies/headers';
-export type { CellNavigationStrategy } from './strategies/columns';
+export type { CellNavigationStrategy, NavigationPrimitives } from './strategies/columns';
 import { HeaderStrategy } from './strategies/headers';
-import { CellNavigationStrategy } from './strategies/columns';
+import { CellNavigationStrategy, NavigationPrimitives } from './strategies/columns';
 /**
  * Strategy to resolve column names (string or regex) to their index.
  */
@@ -218,7 +218,9 @@ export interface LoadingStrategy {
 export interface TableStrategies {
     /** Strategy for discovering/scanning headers */
     header?: HeaderStrategy;
-    /** Strategy for navigating to specific cells (row + column) */
+    /** Primitive navigation functions (goUp, goDown, goLeft, goRight, goHome) */
+    navigation?: NavigationPrimitives;
+    /** @deprecated Use navigation primitives instead. Strategy for navigating to specific cells (row + column) */
     cellNavigation?: CellNavigationStrategy;
     /** Strategy for filling form inputs */
     fill?: FillStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.3.0",
+  "version": "6.3.1",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",