@rickcedwhat/playwright-smart-table 2.1.3 → 2.3.0

package/README.md

@@ -20,12 +20,12 @@ For standard HTML tables (`<table>`, `<tr>`, `<td>`), the library works out of t
 
 <!-- embed: quick-start -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 const table = useTable(page.locator('#example'), {
   headerSelector: 'thead th' // Override for this specific site
 });
 
-// 🪄 Finds the row with Name="Airi Satou", then gets the Position cell.
-// If Airi is on Page 2, it handles pagination automatically.
+// Find the row with Name="Airi Satou", then get the Position cell
 const row = await table.getByRow({ Name: 'Airi Satou' });
 
 await expect(row.getCell('Position')).toHaveText('Accountant');
@@ -43,14 +43,15 @@ The `SmartRow` is the core power of this library. Unlike a standard Playwright `
 
 <!-- embed: smart-row -->
 ```typescript
-// 1. Get SmartRow via getByRow
+// Example from: https://datatables.net/examples/data_sources/dom
+
+// Get SmartRow via getByRow
 const row = await table.getByRow({ Name: 'Airi Satou' });
 
-// 2. Interact with cell
-// ✅ Good: Resilient to column reordering
+// Interact with cell using column name (resilient to column reordering)
 await row.getCell('Position').click();
 
-// 3. Dump data from row
+// Extract row data as JSON
 const data = await row.toJSON();
 console.log(data);
 // { Name: "Airi Satou", Position: "Accountant", ... }
@@ -72,6 +73,7 @@ For tables that span multiple pages, configure a pagination strategy:
 
 <!-- embed: pagination -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 const table = useTable(page.locator('#example'), {
   rowSelector: 'tbody tr',
   headerSelector: 'thead th',
@@ -97,6 +99,7 @@ Enable debug logging to see exactly what the library is doing:
 
 <!-- embed: advanced-debug -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 const table = useTable(page.locator('#example'), {
   headerSelector: 'thead th',
   debug: true // Enables verbose logging of internal operations
@@ -115,6 +118,7 @@ If your tests navigate deep into a paginated table, use `.reset()` to return to
 
 <!-- embed: advanced-reset -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 // Navigate deep into the table by searching for a row on a later page
 try {
   await table.getByRow({ Name: 'Angelica Ramos' });
@@ -135,6 +139,7 @@ Efficiently extract all values from a specific column:
 
 <!-- embed: advanced-column-scan -->
 ```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'); 
 expect(offices).toContain('Tokyo');
@@ -142,6 +147,63 @@ expect(offices.length).toBeGreaterThan(0);
 ```
 <!-- /embed: advanced-column-scan -->
 
+### Filling Row Data
+
+Use `fill()` to intelligently populate form fields in a table row. The method automatically detects input types (text inputs, selects, checkboxes, contenteditable divs) and fills them appropriately.
+
+<!-- embed: fill-basic -->
+```typescript
+// Find a row and fill it with new data
+const row = await table.getByRow({ ID: '1' });
+
+await row.fill({
+  Name: 'John Updated',
+  Status: 'Inactive',
+  Active: false,
+  Notes: 'Updated notes here'
+});
+
+// Verify the values were filled correctly
+await expect(row.getCell('Name').locator('input')).toHaveValue('John Updated');
+await expect(row.getCell('Status').locator('select')).toHaveValue('Inactive');
+await expect(row.getCell('Active').locator('input[type="checkbox"]')).not.toBeChecked();
+await expect(row.getCell('Notes').locator('textarea')).toHaveValue('Updated notes here');
+```
+<!-- /embed: fill-basic -->
+
+**Auto-detection supports:**
+- Text inputs (`input[type="text"]`, `textarea`)
+- Select dropdowns (`select`)
+- Checkboxes/radios (`input[type="checkbox"]`, `input[type="radio"]`, `[role="checkbox"]`)
+- Contenteditable divs (`[contenteditable="true"]`)
+
+**Custom input mappers:**
+
+For edge cases where auto-detection doesn't work (e.g., custom components, multiple inputs in a cell), use per-column mappers:
+
+<!-- embed: fill-custom-mappers -->
+```typescript
+const row = await table.getByRow({ ID: '1' });
+
+// Use custom input mappers for specific columns
+await row.fill({
+  Name: 'John Updated',
+  Status: 'Inactive'
+}, {
+  inputMappers: {
+    // Name column has multiple inputs - target the primary one
+    Name: (cell) => cell.locator('.primary-input'),
+    // Status uses standard select, but we could customize if needed
+    Status: (cell) => cell.locator('select')
+  }
+});
+
+// Verify the values
+await expect(row.getCell('Name').locator('.primary-input')).toHaveValue('John Updated');
+await expect(row.getCell('Status').locator('select')).toHaveValue('Inactive');
+```
+<!-- /embed: fill-custom-mappers -->
+
 ### Transforming Column Headers
 
 Use `headerTransformer` to normalize or rename column headers. This is especially useful for tables with empty headers, inconsistent formatting, or when you want to use cleaner names in your tests.
@@ -152,6 +214,7 @@ Tables with empty header cells (like Material UI DataGrids) get auto-assigned na
 
 <!-- embed: header-transformer -->
 ```typescript
+// Example from: https://mui.com/material-ui/react-table/
 const table = useTable(page.locator('.MuiDataGrid-root').first(), {
   rowSelector: '.MuiDataGrid-row',
   headerSelector: '.MuiDataGrid-columnHeader',
@@ -186,6 +249,7 @@ Clean up inconsistent column names (extra spaces, inconsistent casing):
 
 <!-- embed: header-transformer-normalize -->
 ```typescript
+// Example from: https://the-internet.herokuapp.com/tables
 const table = useTable(page.locator('#table1'), {
   // Normalize column names: remove extra spaces, handle inconsistent casing
   headerTransformer: ({ text }) => {
@@ -215,10 +279,19 @@ await expect(row.getCell("Email")).toHaveText("jdoe@hotmail.com");
 - ✅ Returns `SmartRow` if exactly one match
 - ❌ Throws error if multiple matches (ambiguous query)
 - 👻 Returns sentinel locator if no match (allows `.not.toBeVisible()` assertions)
-- 🔄 Auto-paginates if row isn't on current page
+- 🔄 Auto-paginates if row isn't on current page (when `maxPages > 1` and pagination strategy is configured)
+
+**Type Signature:**
+```typescript
+getByRow: <T extends { asJSON?: boolean }>(
+  filters: Record<string, string | RegExp | number>, 
+  options?: { exact?: boolean, maxPages?: number } & T
+) => Promise<T['asJSON'] extends true ? Record<string, string> : SmartRow>;
+```
 
 <!-- embed: get-by-row -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 // Find a row where Name is "Airi Satou" AND Office is "Tokyo"
 const row = await table.getByRow({ Name: "Airi Satou", Office: "Tokyo" });
 await expect(row).toBeVisible();
@@ -228,37 +301,17 @@ await expect(await table.getByRow({ Name: "Ghost User" })).not.toBeVisible();
 ```
 <!-- /embed: get-by-row -->
 
-**Type Signature:**
-<!-- embed-type: TableResult -->
+Get row data as JSON:
+<!-- embed: get-by-row-json -->
 ```typescript
-export interface TableResult {
-  getHeaders: () => Promise<string[]>;
-  getHeaderCell: (columnName: string) => Promise<Locator>;
-
-  getByRow: <T extends { asJSON?: boolean }>(
-    filters: Record<string, string | RegExp | number>, 
-    options?: { exact?: boolean, maxPages?: number } & T
-  ) => Promise<T['asJSON'] extends true ? Record<string, string> : SmartRow>;
-
-  getAllRows: <T extends { asJSON?: boolean }>(
-    options?: { filter?: Record<string, any>, exact?: boolean } & T
-  ) => Promise<T['asJSON'] extends true ? Record<string, string>[] : SmartRow[]>;
-
-  generateConfigPrompt: (options?: PromptOptions) => Promise<void>;
-  generateStrategyPrompt: (options?: PromptOptions) => Promise<void>;
-
-  /**
-   * Resets the table state (clears cache, flags) and invokes the onReset strategy.
-   */
-  reset: () => Promise<void>;
+// Get row data directly as JSON object
+const data = await table.getByRow({ Name: 'Airi Satou' }, { asJSON: true });
+// Returns: { Name: "Airi Satou", Position: "Accountant", Office: "Tokyo", ... }
 
-  /**
-   * Scans a specific column across all pages and returns the values.
-   */
-  getColumnValues: <V = string>(column: string, options?: { mapper?: (cell: Locator) => Promise<V> | V, maxPages?: number }) => Promise<V[]>;
-}
+expect(data).toHaveProperty('Name', 'Airi Satou');
+expect(data).toHaveProperty('Position');
 ```
-<!-- /embed-type: TableResult -->
+<!-- /embed: get-by-row-json -->
 
 #### <a name="getallrows"></a>`getAllRows(options?)`
 
@@ -266,8 +319,16 @@ export interface TableResult {
 
 **Best for:** Checking existence, validating sort order, bulk data extraction.
 
+**Type Signature:**
+```typescript
+getAllRows: <T extends { asJSON?: boolean }>(
+  options?: { filter?: Record<string, any>, exact?: boolean } & T
+) => Promise<T['asJSON'] extends true ? Record<string, string>[] : SmartRow[]>;
+```
+
 <!-- embed: get-all-rows -->
 ```typescript
+// Example from: https://datatables.net/examples/data_sources/dom
 // 1. Get ALL rows on the current page
 const allRows = await table.getAllRows();
 expect(allRows.length).toBeGreaterThan(0);
@@ -286,24 +347,6 @@ expect(data[0]).toHaveProperty('Name');
 ```
 <!-- /embed: get-all-rows -->
 
-#### <a name="getcolumnvalues"></a>`getColumnValues(column, options?)`
-
-Scans a specific column across all pages and returns values. Supports custom mappers for extracting non-text data.
-
-**Additional Examples:**
-
-Get row data as JSON:
-<!-- embed: get-by-row-json -->
-```typescript
-// Get row data directly as JSON object
-const data = await table.getByRow({ Name: 'Airi Satou' }, { asJSON: true });
-// Returns: { Name: "Airi Satou", Position: "Accountant", Office: "Tokyo", ... }
-
-expect(data).toHaveProperty('Name', 'Airi Satou');
-expect(data).toHaveProperty('Position');
-```
-<!-- /embed: get-by-row-json -->
-
 Filter rows with exact match:
 <!-- embed: get-all-rows-exact -->
 ```typescript
@@ -317,7 +360,33 @@ expect(exactMatches.length).toBeGreaterThan(0);
 ```
 <!-- /embed: get-all-rows-exact -->
 
-Column scanning with custom mapper:
+#### <a name="getcolumnvalues"></a>`getColumnValues(column, options?)`
+
+Scans a specific column across all pages and returns values. Supports custom mappers for extracting non-text data.
+
+**Type Signature:**
+```typescript
+getColumnValues: <V = string>(
+  column: string, 
+  options?: { 
+    mapper?: (cell: Locator) => Promise<V> | V, 
+    maxPages?: number 
+  }
+) => Promise<V[]>;
+```
+
+Basic usage:
+<!-- embed: advanced-column-scan -->
+```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'); 
+expect(offices).toContain('Tokyo');
+expect(offices.length).toBeGreaterThan(0);
+```
+<!-- /embed: advanced-column-scan -->
+
+With custom mapper:
 <!-- embed: advanced-column-scan-mapper -->
 ```typescript
 // Extract numeric values from a column
@@ -334,18 +403,33 @@ expect(ages.length).toBeGreaterThan(0);
 ```
 <!-- /embed: advanced-column-scan-mapper -->
 
-#### <a name="reset"></a>`reset()`
-
-Resets table state (clears cache, pagination flags) and invokes the `onReset` strategy to return to the first page.
-
 #### <a name="getheaders"></a>`getHeaders()`
 
 Returns an array of all column names in the table.
 
+**Type Signature:**
+```typescript
+getHeaders: () => Promise<string[]>;
+```
+
 #### <a name="getheadercell"></a>`getHeaderCell(columnName)`
 
 Returns a Playwright `Locator` for the specified header cell.
 
+**Type Signature:**
+```typescript
+getHeaderCell: (columnName: string) => Promise<Locator>;
+```
+
+#### <a name="reset"></a>`reset()`
+
+Resets table state (clears cache, pagination flags) and invokes the `onReset` strategy to return to the first page.
+
+**Type Signature:**
+```typescript
+reset: () => Promise<void>;
+```
+
 ---
 
 ## 🧩 Pagination Strategies
@@ -396,7 +480,7 @@ export type PaginationStrategy = (context: TableContext) => Promise<boolean>;
 ```typescript
 export interface TableContext {
   root: Locator;
-  config: Required<TableConfig>;
+  config: FinalTableConfig;
   page: Page;
   resolve: (selector: Selector, parent: Locator | Page) => Locator;
 }
@@ -429,7 +513,7 @@ await table.generateStrategyPrompt({ output: 'console' });
 export interface PromptOptions {
   /**
    * Output Strategy:
-   * - 'error': Throws an error with the prompt (Best for Cloud/QA Wolf to get clean text).
+   * - 'error': Throws an error with the prompt (useful for platforms that capture error output cleanly).
    * - 'console': Standard console logs (Default).
    */
   output?: 'console' | 'error';
@@ -450,9 +534,13 @@ A `SmartRow` extends Playwright's `Locator` with table-aware methods.
 
 <!-- embed-type: SmartRow -->
 ```typescript
-export type SmartRow = Locator & {
+export type SmartRow = Omit<Locator, 'fill'> & {
   getCell(column: string): Locator;
   toJSON(): Promise<Record<string, string>>;
+  /**
+   * Fills the row with data. Automatically detects input types (text input, select, checkbox, etc.).
+   */
+  fill: (data: Record<string, any>, options?: FillOptions) => Promise<void>;
 };
 ```
 <!-- /embed-type: SmartRow -->
@@ -460,6 +548,7 @@ export type SmartRow = Locator & {
 **Methods:**
 - `getCell(column: string)`: Returns a `Locator` for the specified cell in this row
 - `toJSON()`: Extracts all cell data as a key-value object
+- `fill(data, options?)`: Intelligently fills form fields in the row. Automatically detects input types or use `inputMappers` for custom control
 
 All standard Playwright `Locator` methods (`.click()`, `.isVisible()`, `.textContent()`, etc.) are also available.
 
@@ -474,6 +563,7 @@ export interface TableConfig {
   headerSelector?: Selector;
   cellSelector?: Selector;
   pagination?: PaginationStrategy;
+  sorting?: SortingStrategy;
   maxPages?: number;
   /**
    * Hook to rename columns dynamically.

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/strategies/index.d.ts

@@ -1,15 +1,2 @@
-import { PaginationStrategy, Selector } from '../types';
-export declare const TableStrategies: {
-    /**
-     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
-     */
-    clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
-    /**
-     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
-     */
-    clickLoadMore: (buttonSelector: Selector, timeout?: number) => PaginationStrategy;
-    /**
-     * Strategy: Scrolls to the bottom and waits for more rows to appear.
-     */
-    infiniteScroll: (timeout?: number) => PaginationStrategy;
-};
+export * from './pagination';
+export * from './sorting';

package/dist/strategies/index.js

@@ -1,112 +1,19 @@
 "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.TableStrategies = void 0;
-/**
- * Internal helper to wait for a condition to be met.
- * Replaces the dependency on 'expect(...).toPass()' to ensure compatibility
- * with environments like QA Wolf where 'expect' is not globally available.
- */
-const waitForCondition = (predicate, timeout, page // Context page for pauses
-) => __awaiter(void 0, void 0, void 0, function* () {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        if (yield predicate()) {
-            return true;
-        }
-        // Wait 100ms before next check (Standard Polling)
-        yield page.waitForTimeout(100).catch(() => new Promise(r => setTimeout(r, 100)));
-    }
-    return false;
-});
-exports.TableStrategies = {
-    /**
-     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
-     */
-    clickNext: (nextButtonSelector, timeout = 5000) => {
-        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
-            const nextBtn = resolve(nextButtonSelector, root).first();
-            // Debug log (can be verbose, maybe useful for debugging only)
-            // console.log(`[Strategy: clickNext] Checking button...`);
-            // Check if button exists/enabled before clicking.
-            // We do NOT wait here because if the button isn't visible/enabled, 
-            // we assume we reached the last page.
-            if (!(yield nextBtn.isVisible())) {
-                console.log(`[Strategy: clickNext] Button not visible. Stopping pagination.`);
-                return false;
-            }
-            if (!(yield nextBtn.isEnabled())) {
-                console.log(`[Strategy: clickNext] Button disabled. Stopping pagination.`);
-                return false;
-            }
-            // 1. Snapshot current state
-            const firstRow = resolve(config.rowSelector, root).first();
-            const oldText = yield firstRow.innerText().catch(() => "");
-            // 2. Click
-            console.log(`[Strategy: clickNext] Clicking next button...`);
-            try {
-                yield nextBtn.click({ timeout: 2000 });
-            }
-            catch (e) {
-                console.warn(`[Strategy: clickNext] Click failed (blocked or detached): ${e}`);
-                return false;
-            }
-            // 3. Smart Wait (Polling)
-            const success = yield waitForCondition(() => __awaiter(void 0, void 0, void 0, function* () {
-                const newText = yield firstRow.innerText().catch(() => "");
-                return newText !== oldText;
-            }), timeout, page);
-            if (!success) {
-                console.warn(`[Strategy: clickNext] Warning: Table content did not change after clicking Next.`);
-            }
-            return success;
-        });
-    },
-    /**
-     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
-     */
-    clickLoadMore: (buttonSelector, timeout = 5000) => {
-        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
-            const loadMoreBtn = resolve(buttonSelector, root).first();
-            if (!(yield loadMoreBtn.isVisible()) || !(yield loadMoreBtn.isEnabled())) {
-                return false;
-            }
-            // 1. Snapshot count
-            const rows = resolve(config.rowSelector, root);
-            const oldCount = yield rows.count();
-            // 2. Click
-            yield loadMoreBtn.click();
-            // 3. Smart Wait (Polling)
-            return yield waitForCondition(() => __awaiter(void 0, void 0, void 0, function* () {
-                const newCount = yield rows.count();
-                return newCount > oldCount;
-            }), timeout, page);
-        });
-    },
-    /**
-     * Strategy: Scrolls to the bottom and waits for more rows to appear.
-     */
-    infiniteScroll: (timeout = 5000) => {
-        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
-            const rows = resolve(config.rowSelector, root);
-            const oldCount = yield rows.count();
-            if (oldCount === 0)
-                return false;
-            // 1. Trigger Scroll
-            yield rows.last().scrollIntoViewIfNeeded();
-            // 2. Smart Wait (Polling)
-            return yield waitForCondition(() => __awaiter(void 0, void 0, void 0, function* () {
-                const newCount = yield rows.count();
-                return newCount > oldCount;
-            }), timeout, page);
-        });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/strategies/index.ts
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./sorting"), exports);

package/dist/strategies/pagination.d.ts

@@ -0,0 +1,32 @@
+import type { PaginationStrategy, Selector } from '../types';
+export declare const PaginationStrategies: {
+    /**
+     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
+     */
+    clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
+    /**
+     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
+     */
+    clickLoadMore: (buttonSelector: Selector, timeout?: number) => PaginationStrategy;
+    /**
+     * Strategy: Scrolls to the bottom and waits for more rows to appear.
+     */
+    infiniteScroll: (timeout?: number) => PaginationStrategy;
+};
+/**
+ * @deprecated Use `PaginationStrategies` instead. This alias will be removed in a future major version.
+ */
+export declare const TableStrategies: {
+    /**
+     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
+     */
+    clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
+    /**
+     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
+     */
+    clickLoadMore: (buttonSelector: Selector, timeout?: number) => PaginationStrategy;
+    /**
+     * Strategy: Scrolls to the bottom and waits for more rows to appear.
+     */
+    infiniteScroll: (timeout?: number) => PaginationStrategy;
+};

package/dist/strategies/pagination.js

@@ -0,0 +1,72 @@
+"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.TableStrategies = exports.PaginationStrategies = void 0;
+const utils_1 = require("../utils");
+exports.PaginationStrategies = {
+    /**
+     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
+     */
+    clickNext: (nextButtonSelector, timeout = 5000) => {
+        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
+            const nextBtn = resolve(nextButtonSelector, root).first();
+            if (!(yield nextBtn.isVisible()) || !(yield nextBtn.isEnabled())) {
+                return false;
+            }
+            const firstRow = resolve(config.rowSelector, root).first();
+            const oldText = yield firstRow.innerText().catch(() => "");
+            yield nextBtn.click({ timeout: 2000 }).catch(() => { });
+            const success = yield (0, utils_1.waitForCondition)(() => __awaiter(void 0, void 0, void 0, function* () {
+                const newText = yield firstRow.innerText().catch(() => "");
+                return newText !== oldText;
+            }), timeout, page);
+            return success;
+        });
+    },
+    /**
+     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
+     */
+    clickLoadMore: (buttonSelector, timeout = 5000) => {
+        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
+            const loadMoreBtn = resolve(buttonSelector, root).first();
+            if (!(yield loadMoreBtn.isVisible()) || !(yield loadMoreBtn.isEnabled())) {
+                return false;
+            }
+            const rows = resolve(config.rowSelector, root);
+            const oldCount = yield rows.count();
+            yield loadMoreBtn.click();
+            return yield (0, utils_1.waitForCondition)(() => __awaiter(void 0, void 0, void 0, function* () {
+                const newCount = yield rows.count();
+                return newCount > oldCount;
+            }), timeout, page);
+        });
+    },
+    /**
+     * Strategy: Scrolls to the bottom and waits for more rows to appear.
+     */
+    infiniteScroll: (timeout = 5000) => {
+        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
+            const rows = resolve(config.rowSelector, root);
+            const oldCount = yield rows.count();
+            if (oldCount === 0)
+                return false;
+            yield rows.last().scrollIntoViewIfNeeded();
+            return yield (0, utils_1.waitForCondition)(() => __awaiter(void 0, void 0, void 0, function* () {
+                const newCount = yield rows.count();
+                return newCount > oldCount;
+            }), timeout, page);
+        });
+    }
+};
+/**
+ * @deprecated Use `PaginationStrategies` instead. This alias will be removed in a future major version.
+ */
+exports.TableStrategies = exports.PaginationStrategies;

package/dist/strategies/sorting.d.ts

@@ -0,0 +1,12 @@
+import type { SortingStrategy } from '../types';
+/**
+ * A collection of pre-built sorting strategies.
+ */
+export declare const SortingStrategies: {
+    /**
+     * A sorting strategy that interacts with column headers based on ARIA attributes.
+     * - `doSort`: Clicks the header repeatedly until the desired `aria-sort` state is achieved.
+     * - `getSortState`: Reads the `aria-sort` attribute from the header.
+     */
+    AriaSort: () => SortingStrategy;
+};