@rickcedwhat/playwright-smart-table 1.0.6 → 1.0.7

package/README.md

@@ -1,118 +1,152 @@
 Playwright Smart Table 🧠
+
 A production-ready, type-safe table wrapper for Playwright.
-It handles the hard stuff automatically:
-Pagination (Next buttons, Load More, Infinite Scroll)
-Complex Grids (MUI, AG-Grid, React Table)
-Strict Mode (Throws errors if your filters match multiple rows)
-🚀 Installation
-npm install playwright-smart-table
 
+This library abstracts away the complexity of testing dynamic web tables. It handles Pagination, Infinite Scroll, Virtualization, and Data Grids (MUI, AG-Grid) so your tests remain clean and readable.
 
-(Note: Requires @playwright/test as a peer dependency)
-🏁 Quick Start
-Standard HTML Table (No config needed)
-import { test, expect } from '@playwright/test';
-import { useTable } from 'playwright-smart-table';
+📦 Installation
 
-test('Verify User', async ({ page }) => {
-  await page.goto('/users');
+npm install @rickcedwhat/playwright-smart-table
 
-  // 1. Initialize (Defaults to <table>, <tr>, <td>)
-  const table = useTable(page.locator('#users-table'));
-  
-  // 2. Find row across pages automatically!
-  // This will search Page 1, then Page 2, etc.
-  const row = await table.getByRow({ Name: 'Alice', Role: 'Admin' });
-  
-  await expect(row).toBeVisible();
-});
 
+Requires @playwright/test as a peer dependency.
 
-🧩 Pagination Strategies
-This library doesn't guess how your table works. You tell it using a Strategy.
-1. Standard "Next" Button
-For tables like Datatables.net or simple paginated lists.
-import { TableStrategies } from 'playwright-smart-table';
-
-const table = useTable(locator, {
-  // Strategy: Find button -> Click -> Wait for first row to change
-  pagination: TableStrategies.clickNext('[aria-label="Next Page"]')
-});
+🚀 Quick Start
 
+1. The Standard HTML Table
 
-2. Infinite Scroll
-For grids that load more data as you scroll down (AG-Grid, Virtual Lists, HTMX).
-const table = useTable(locator, {
-  // Strategy: Aggressive scroll to bottom -> Wait for row count to increase
-  pagination: TableStrategies.infiniteScroll()
-});
+For standard tables (<table>, <tr>, <td>), no configuration is needed.
 
+import { test, expect } from '@playwright/test';
+import { useTable } from '@rickcedwhat/playwright-smart-table';
 
-3. Load More Button
-For lists with a "Load More Results" button at the bottom.
-const table = useTable(locator, {
-  // Strategy: Click button -> Wait for row count to increase
-  pagination: TableStrategies.clickLoadMore('button.load-more')
+test('Verify User Email', async ({ page }) => {
+  const table = useTable(page.locator('#users-table'));
+  
+  // 🪄 Magic: Finds the row with Name="Alice", then gets the Email cell
+  // If Alice is on Page 2, it handles pagination automatically.
+  await expect(
+    await table.getByCell({ Name: 'Alice' }, 'Email')
+  ).toHaveText('alice@example.com');
 });
 
 
-⚙️ Advanced Config (MUI / Grid / Divs)
-For complex div-based tables (like Material UI DataGrid), you can override the selectors.
+2. Complex Grids (Material UI / AG-Grid / Divs)
+
+For modern React grids that use <div> structures, simply override the selectors.
+
+import { useTable, TableStrategies } from '@rickcedwhat/playwright-smart-table';
+
 const table = useTable(page.locator('.MuiDataGrid-root'), {
   rowSelector: '.MuiDataGrid-row',
   headerSelector: '.MuiDataGrid-columnHeader',
   cellSelector: '.MuiDataGrid-cell',
-  pagination: TableStrategies.clickNext('[aria-label="Go to next page"]')
+  // Strategy: Tell it how to find the next page
+  pagination: TableStrategies.clickNext(
+    (root) => root.getByRole('button', { name: 'Go to next page' })
+  )
 });
 
 
+🧩 Pagination Strategies
+
+This library uses the Strategy Pattern to handle navigation. This ensures future stability: we can add new ways to paginate without breaking existing tests.
+
+clickNext(selector)
+
+Best for standard tables (Datatables, lists).
+
+Behavior: Clicks the button -> Waits for the first row of data to change.
+
+Selector: Can be a CSS string OR a Playwright locator function.
+
+// CSS String
+pagination: TableStrategies.clickNext('button.next-page')
+
+// Locator Function (More Robust)
+pagination: TableStrategies.clickNext((root) => root.getByRole('button', { name: 'Next' }))
+
+
+infiniteScroll()
+
+Best for Virtualized Grids (AG-Grid) or lazy-loading lists (HTMX).
+
+Behavior: Aggressively scrolls the container/window to the bottom -> Waits for row count to increase.
+
+pagination: TableStrategies.infiniteScroll()
+
+
+clickLoadMore(selector)
+
+Best for "Load More" buttons.
+
+Behavior: Clicks button -> Waits for row count to increase.
+
+pagination: TableStrategies.clickLoadMore('button.load-more')
+
+
 📖 API Reference
+
 getByRow(filters, options?)
-Finds a specific row matching the filters.
-filters: { "Column Name": "Value", "Age": "25" }
-options: { exact: true }
-Returns: Playwright Locator for that row.
-Throws error if multiple rows match.
-await table.getByRow({ Email: "alice@example.com" });
+
+Returns the Locator for a specific row.
+
+Strict Mode: Throws an error if filters match more than 1 row.
+
+Auto-Pagination: Will search up to maxPages to find the row.
+
+// Find a row where Name is "Alice" AND Role is "Admin"
+const row = await table.getByRow({ Name: "Alice", Role: "Admin" });
+await expect(row).toBeVisible();
 
 
 getByCell(filters, targetColumn)
-Finds a specific cell inside a filtered row. Useful for clicking action buttons.
-Returns: Playwright Locator for the cell.
-// Find the 'Edit' button for Alice
+
+Returns the Locator for a specific cell inside a matched row.
+
+Use this for interactions (clicking edit buttons, checking checkboxes).
+
+// Find Alice's row, then find the "Actions" column, then click the button inside it
 await table.getByCell({ Name: "Alice" }, "Actions").getByRole('button').click();
 
 
+getRowAsJSON(filters)
+
+Returns a POJO (Plain Old JavaScript Object) of the row data. Useful for debugging or strict data assertions.
+
+const data = await table.getRowAsJSON({ ID: "101" });
+console.log(data); 
+// Output: { ID: "101", Name: "Alice", Status: "Active" }
+
+
 getRows()
-Dumps all rows on the current page as an array of objects. Great for verifying sort order.
-const rows = await table.getRows();
-expect(rows[0].Name).toBe("Alice");
-expect(rows[1].Name).toBe("Bob");
 
+Returns an array of all rows on the current page.
 
-getRowAsJSON(filters)
-Returns a single row's data as a JSON object.
-const data = await table.getRowAsJSON({ ID: "123" });
-console.log(data); // { ID: "123", Name: "Alice", Status: "Active" }
+const allRows = await table.getRows();
+expect(allRows[0].Name).toBe("Alice"); // Verify sort order
 
 
-🛠️ Custom Strategies
-Need to handle a custom pagination logic? Write your own strategy!
-A strategy is just a function that returns Promise<boolean> (true if data loaded, false if done).
-const myCustomStrategy = async ({ root, page, resolve }) => {
-  // 1. Find your specific button
-  const btn = resolve('.my-weird-button', root);
-  
-  if (!await btn.isVisible()) return false; // Stop pagination
-  
-  // 2. Click and Wait
-  await btn.click();
-  await page.waitForResponse(resp => resp.url().includes('/api/users'));
-  
-  return true; // We loaded more!
-};
+🛠️ Developer Tools
+
+The library includes helper tools to generate configurations for you.
+
+// Print the HTML structure prompt to console
+// Copy-paste the output into ChatGPT/Gemini to get your config object
+await table.generateConfigPrompt();
+
+// Print a prompt to help write a custom Pagination Strategy
+await table.generateStrategyPrompt();
+
+
+🛡️ Stability & Versioning
+
+This package follows Semantic Versioning.
+
+1.x.x: No breaking changes to the useTable signature.
 
-// Usage
-useTable(locator, { pagination: myCustomStrategy });
+New strategies may be added, but existing ones will remain stable.
 
+To ensure stability in your projects, install with:
 
+"@rickcedwhat/playwright-smart-table": "^1.0.0"

package/dist/index.d.ts

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

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./useTable"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./strategies"), exports);
+__exportStar(require("./presets"), exports);

package/dist/presets.d.ts

@@ -0,0 +1,42 @@
+import { Locator } from '@playwright/test';
+import { TableConfig } from './types';
+/**
+ * Preset for Key-Value Forms.
+ * * Default Structure:
+ * - Row: div.form-group
+ * - Cell: Direct children (> *)
+ * - Columns: ['Label', 'Input']
+ */
+export declare const useForm: (rootLocator: Locator, options?: TableConfig) => {
+    getHeaders: () => Promise<string[]>;
+    getByRow: (filters: Record<string, string | RegExp | number>, options?: {
+        exact?: boolean;
+        maxPages?: number;
+    }) => Promise<Locator>;
+    getByCell: (rowFilters: Record<string, string | RegExp | number>, targetColumn: string) => Promise<Locator>;
+    getRows: () => Promise<Record<string, string>[]>;
+    getRowAsJSON: (filters: Record<string, string | RegExp | number>) => Promise<Record<string, string>>;
+    setColumnName: (colIndex: number, newNameOrFn: string | ((current: string) => string)) => Promise<void>;
+    generateConfigPrompt: () => Promise<void>;
+    generateStrategyPrompt: () => Promise<void>;
+};
+/**
+ * Preset for Navigation Menus.
+ * * Default Structure:
+ * - Row: li
+ * - Cell: null (The row IS the cell)
+ * - Columns: ['Item']
+ */
+export declare const useMenu: (menuLocator: Locator, options?: TableConfig) => {
+    getHeaders: () => Promise<string[]>;
+    getByRow: (filters: Record<string, string | RegExp | number>, options?: {
+        exact?: boolean;
+        maxPages?: number;
+    }) => Promise<Locator>;
+    getByCell: (rowFilters: Record<string, string | RegExp | number>, targetColumn: string) => Promise<Locator>;
+    getRows: () => Promise<Record<string, string>[]>;
+    getRowAsJSON: (filters: Record<string, string | RegExp | number>) => Promise<Record<string, string>>;
+    setColumnName: (colIndex: number, newNameOrFn: string | ((current: string) => string)) => Promise<void>;
+    generateConfigPrompt: () => Promise<void>;
+    generateStrategyPrompt: () => Promise<void>;
+};

package/dist/presets.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMenu = exports.useForm = void 0;
+const useTable_1 = require("./useTable");
+/**
+ * Preset for Key-Value Forms.
+ * * Default Structure:
+ * - Row: div.form-group
+ * - Cell: Direct children (> *)
+ * - Columns: ['Label', 'Input']
+ */
+const useForm = (rootLocator, options = {}) => {
+    return (0, useTable_1.useTable)(rootLocator, Object.assign({ 
+        // Defaults:
+        rowSelector: 'div.form-group', cellSelector: (row) => row.locator('> *'), headerSelector: null, columnNames: ['Label', 'Input'] }, options));
+};
+exports.useForm = useForm;
+/**
+ * Preset for Navigation Menus.
+ * * Default Structure:
+ * - Row: li
+ * - Cell: null (The row IS the cell)
+ * - Columns: ['Item']
+ */
+const useMenu = (menuLocator, options = {}) => {
+    return (0, useTable_1.useTable)(menuLocator, Object.assign({ 
+        // Defaults:
+        rowSelector: 'li', cellSelector: null, headerSelector: null, columnNames: ['Item'] }, options));
+};
+exports.useMenu = useMenu;

package/dist/types.d.ts

@@ -1,15 +1,21 @@
 import { Locator, Page } from '@playwright/test';
 /**
- * A selector can be a CSS string or a function.
- * We allow 'parent' to be Locator OR Page to match your working logic.
+ * A selector can be a CSS string, a function, or null (to disable/skip).
  */
-export type Selector = string | ((parent: Locator | Page) => Locator);
+export type Selector = string | ((parent: Locator | Page) => Locator) | null;
 export interface TableConfig {
     rowSelector?: Selector;
     headerSelector?: Selector;
     cellSelector?: Selector;
     pagination?: PaginationStrategy;
     maxPages?: number;
+    /**
+     * Statically override specific column names.
+     * Use 'undefined' to keep the detected name for that index.
+     * Use this to name columns for Menus or Forms that have no headers.
+     * Example: ['MenuItem'] or [undefined, "Actions"]
+     */
+    columnNames?: (string | undefined)[];
 }
 export interface TableContext {
     root: Locator;

package/dist/useTable.d.ts

@@ -9,9 +9,7 @@ export declare const useTable: (rootLocator: Locator, configOptions?: TableConfi
     getByCell: (rowFilters: Record<string, string | RegExp | number>, targetColumn: string) => Promise<Locator>;
     getRows: () => Promise<Record<string, string>[]>;
     getRowAsJSON: (filters: Record<string, string | RegExp | number>) => Promise<Record<string, string>>;
-    /**
-    * 🛠️ DEV TOOL: Prints a prompt to the console.
-    * Copy the output and paste it into Gemini/ChatGPT to generate your config.
-    */
+    setColumnName: (colIndex: number, newNameOrFn: string | ((current: string) => string)) => Promise<void>;
     generateConfigPrompt: () => Promise<void>;
+    generateStrategyPrompt: () => Promise<void>;
 };

package/dist/useTable.js

@@ -11,27 +11,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTable = void 0;
 const useTable = (rootLocator, configOptions = {}) => {
-    const config = Object.assign({ rowSelector: "tbody tr", headerSelector: "th", cellSelector: "td", pagination: undefined, maxPages: 1 }, configOptions);
-    // ✅ UPDATE: Accept Locator OR Page (to match your work logic)
+    const config = Object.assign({ rowSelector: "tbody tr", headerSelector: "th", cellSelector: "td", pagination: undefined, maxPages: 1, columnNames: [] }, configOptions);
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
         if (typeof item === 'function')
             return item(parent);
-        return item;
+        throw new Error("Cannot resolve a null selector. Ensure your config defines selectors correctly.");
     };
     let _headerMap = null;
     const _getMap = () => __awaiter(void 0, void 0, void 0, function* () {
         if (_headerMap)
             return _headerMap;
-        // Headers are still resolved relative to the table root (safer)
-        const headerLoc = resolve(config.headerSelector, rootLocator);
-        try {
-            yield headerLoc.first().waitFor({ state: 'visible', timeout: 3000 });
+        // 1. Scrape DOM (Only if headerSelector is NOT null)
+        let texts = [];
+        if (config.headerSelector) {
+            const headerLoc = resolve(config.headerSelector, rootLocator);
+            try {
+                yield headerLoc.first().waitFor({ state: 'visible', timeout: 3000 });
+                texts = yield headerLoc.allInnerTexts();
+            }
+            catch (e) { /* Ignore hydration/empty/timeout */ }
+        }
+        // 2. Merge Scraped Data with Config Overrides
+        _headerMap = new Map();
+        const overrides = config.columnNames || [];
+        const colCount = Math.max(texts.length, overrides.length);
+        for (let i = 0; i < colCount; i++) {
+            const scrapedText = (texts[i] || "").trim() || `__col_${i}`;
+            const overrideText = overrides[i];
+            const finalName = (overrideText !== undefined) ? overrideText : scrapedText;
+            _headerMap.set(finalName, i);
         }
-        catch (e) { /* Ignore hydration */ }
-        const texts = yield headerLoc.allInnerTexts();
-        _headerMap = new Map(texts.map((t, i) => [t.trim() || `__col_${i}`, i]));
         return _headerMap;
     });
     const _findRowLocator = (filters_1, ...args_1) => __awaiter(void 0, [filters_1, ...args_1], void 0, function* (filters, options = {}) {
@@ -41,38 +52,67 @@ const useTable = (rootLocator, configOptions = {}) => {
         const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
         let currentPage = 1;
         while (true) {
-            // 1. Row Locator uses ROOT (Matches your snippet)
+            if (!config.rowSelector)
+                throw new Error("rowSelector cannot be null");
             let rowLocator = resolve(config.rowSelector, rootLocator);
             for (const [colName, value] of Object.entries(filters)) {
                 const colIndex = map.get(colName);
                 if (colIndex === undefined)
-                    throw new Error(`Column '${colName}' not found.`);
+                    throw new Error(`Column '${colName}' not found. Available: ${Array.from(map.keys())}`);
                 const exact = options.exact || false;
                 const filterVal = typeof value === 'number' ? String(value) : value;
-                // ✅ MATCHING YOUR WORK LOGIC EXACTLY
-                // 2. Cell Template uses PAGE (Matches your snippet)
-                const cellTemplate = resolve(config.cellSelector, page);
-                // 3. Filter using .nth(colIndex)
-                rowLocator = rowLocator.filter({
-                    has: cellTemplate.nth(colIndex).getByText(filterVal, { exact }),
-                });
+                // Case 1: No Cell Selector (Menu) - Filter the Row Itself
+                if (!config.cellSelector) {
+                    if (exact) {
+                        rowLocator = rowLocator.filter({ hasText: new RegExp(`^${escapeRegExp(String(filterVal))}$`) });
+                    }
+                    else {
+                        rowLocator = rowLocator.filter({ hasText: filterVal });
+                    }
+                }
+                // Case 2: String Cell Selector - Standard Table Logic (Restored)
+                else if (typeof config.cellSelector === 'string') {
+                    // RESTORED: This logic worked for standard tables. 
+                    // We resolve against the PAGE to create a generic locator template.
+                    // Playwright handles the relative filtering correctly for standard tables.
+                    const cellTemplate = resolve(config.cellSelector, page);
+                    rowLocator = rowLocator.filter({
+                        has: cellTemplate.nth(colIndex).getByText(filterVal, { exact }),
+                    });
+                }
+                // Case 3: Function Cell Selector - Forms (Iterative Fallback)
+                else {
+                    const count = yield rowLocator.count();
+                    let matchFound = false;
+                    for (let i = 0; i < count; i++) {
+                        const specificRow = rowLocator.nth(i);
+                        // Resolve cell relative to this specific row
+                        const specificCell = config.cellSelector(specificRow).nth(colIndex);
+                        if ((yield specificCell.getByText(filterVal, { exact }).count()) > 0) {
+                            if (matchFound) {
+                                throw new Error(`Strict Mode Violation: Found multiple rows matching ${JSON.stringify(filters)}.`);
+                            }
+                            rowLocator = specificRow;
+                            matchFound = true;
+                            // Break inner loop to proceed to next filter or return
+                            break;
+                        }
+                    }
+                    if (!matchFound) {
+                        // Return empty locator to fail gracefully
+                        return resolve(config.rowSelector, rootLocator).filter({ hasText: "NON_EXISTENT_ROW_" + Date.now() });
+                    }
+                }
             }
             const count = yield rowLocator.count();
-            if (count > 1) {
+            if (count > 1)
                 throw new Error(`Strict Mode Violation: Found ${count} rows matching ${JSON.stringify(filters)}.`);
-            }
             if (count === 1)
                 return rowLocator.first();
-            // --- PAGINATION LOGIC ---
+            // --- PAGINATION ---
             if (config.pagination && currentPage < effectiveMaxPages) {
-                const context = {
-                    root: rootLocator,
-                    config: config,
-                    page: page,
-                    resolve: resolve
-                };
-                const didLoadMore = yield config.pagination(context);
-                if (didLoadMore) {
+                const context = { root: rootLocator, config: config, page: page, resolve: resolve };
+                if (yield config.pagination(context)) {
                     currentPage++;
                     continue;
                 }
@@ -92,12 +132,14 @@ const useTable = (rootLocator, configOptions = {}) => {
             const row = yield _findRowLocator(rowFilters);
             if (!row)
                 throw new Error(`Row not found: ${JSON.stringify(rowFilters)}`);
+            // Guard: getByCell makes no sense for Menus (no cells)
+            if (!config.cellSelector) {
+                throw new Error("getByCell is not supported when 'cellSelector' is null (e.g. Menus). Use getByRow instead.");
+            }
             const map = yield _getMap();
             const colIndex = map.get(targetColumn);
             if (colIndex === undefined)
                 throw new Error(`Column '${targetColumn}' not found.`);
-            // Return the specific cell
-            // We scope this to the found ROW to ensure we get the right cell
             if (typeof config.cellSelector === 'string') {
                 return row.locator(config.cellSelector).nth(colIndex);
             }
@@ -112,14 +154,18 @@ const useTable = (rootLocator, configOptions = {}) => {
             const results = [];
             for (let i = 0; i < rowCount; i++) {
                 const row = rowLocator.nth(i);
-                let cells;
-                if (typeof config.cellSelector === 'string') {
-                    cells = row.locator(config.cellSelector);
+                let cellTexts = [];
+                if (!config.cellSelector) {
+                    cellTexts = [yield row.innerText()];
+                }
+                else if (typeof config.cellSelector === 'string') {
+                    // For string selectors, we query all matching cells in the row
+                    cellTexts = yield row.locator(config.cellSelector).allInnerTexts();
                 }
                 else {
-                    cells = resolve(config.cellSelector, row);
+                    // For function selectors, we resolve against the row
+                    cellTexts = yield resolve(config.cellSelector, row).allInnerTexts();
                 }
-                const cellTexts = yield cells.allInnerTexts();
                 const rowData = {};
                 for (const [colName, colIdx] of map.entries()) {
                     rowData[colName] = (cellTexts[colIdx] || "").trim();
@@ -132,14 +178,16 @@ const useTable = (rootLocator, configOptions = {}) => {
             const row = yield _findRowLocator(filters);
             if (!row)
                 throw new Error(`Row not found: ${JSON.stringify(filters)}`);
-            let cells;
-            if (typeof config.cellSelector === 'string') {
-                cells = row.locator(config.cellSelector);
+            let cellTexts = [];
+            if (!config.cellSelector) {
+                cellTexts = [yield row.innerText()];
+            }
+            else if (typeof config.cellSelector === 'string') {
+                cellTexts = yield row.locator(config.cellSelector).allInnerTexts();
             }
             else {
-                cells = resolve(config.cellSelector, row);
+                cellTexts = yield resolve(config.cellSelector, row).allInnerTexts();
             }
-            const cellTexts = yield cells.allInnerTexts();
             const map = yield _getMap();
             const result = {};
             for (const [colName, colIndex] of map.entries()) {
@@ -147,80 +195,34 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return result;
         }),
-        /**
-        * 🛠️ DEV TOOL: Prints a prompt to the console.
-        * Copy the output and paste it into Gemini/ChatGPT to generate your config.
-        */
+        setColumnName: (colIndex, newNameOrFn) => __awaiter(void 0, void 0, void 0, function* () {
+            const map = yield _getMap();
+            let oldName = "";
+            for (const [name, idx] of map.entries()) {
+                if (idx === colIndex) {
+                    oldName = name;
+                    break;
+                }
+            }
+            if (!oldName)
+                oldName = `__col_${colIndex}`;
+            const newName = typeof newNameOrFn === 'function' ? newNameOrFn(oldName) : newNameOrFn;
+            if (map.has(oldName))
+                map.delete(oldName);
+            map.set(newName, colIndex);
+        }),
         generateConfigPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
             const html = yield rootLocator.evaluate((el) => el.outerHTML);
-            const separator = "=".repeat(50);
-            const prompt = `
-${separator}
-🤖 COPY THE TEXT BELOW INTO GEMINI/ChatGPT 🤖
-${separator}
-
-I am using a Playwright helper factory called 'useTable'. 
-I need you to generate the configuration object based on the HTML structure below.
-
-Here is the table HTML:
-\`\`\`html
-${html}
-\`\`\`
-
-Based on this HTML, generate the configuration object matching this signature:
-const table = useTable(page.locator('...'), {
-    // Find the rows (exclude headers and empty spacer rows if possible)
-    rowSelector: "...", // OR (root) => root.locator(...)
-    
-    // Find the column headers
-    headerSelector: "...", // OR (root) => root.locator(...)
-    
-    // Find the cell (relative to a specific row)
-    cellSelector: "...", // OR (row) => row.locator(...)
-    
-    // Find the "Next Page" button (if it exists in the HTML)
-    paginationNextSelector: (root) => root.locator(...)
-});
-
-**Requirements:**
-1. Prefer \`getByRole\` or \`getByTestId\` over CSS classes where possible.
-2. If the table uses \`div\` structures (like React Table), ensure the \`rowSelector\` does not accidentally select the header row.
-3. If there are "padding" or "loading" rows, use \`.filter()\` to exclude them.
-
-${separator}
-`;
-            console.log(prompt);
+            console.log(`\n=== CONFIG PROMPT ===\nI have this HTML:\n\`\`\`html\n${html}\n\`\`\`\nGenerate a 'useTable' config for it.`);
+        }),
+        generateStrategyPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
+            const container = rootLocator.locator('xpath=..');
+            const html = yield container.evaluate((el) => el.outerHTML);
+            console.log(`\n=== STRATEGY PROMPT ===\nI have this Container HTML:\n\`\`\`html\n${html.substring(0, 2000)}\n\`\`\`\nWrite a pagination strategy.`);
         })
     };
-    /**
-     * 🛠️ DEV TOOL: Prints a prompt to help write a custom Pagination Strategy.
-     * It snapshots the HTML *surrounding* the table to find buttons/scroll containers.
-     */
-    generateStrategyPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
-        // 1. Get the parent container (often holds the pagination controls)
-        const container = rootLocator.locator('xpath=..');
-        const html = yield container.evaluate((el) => el.outerHTML);
-        const prompt = `
-==================================================
-🤖 COPY INTO GEMINI/ChatGPT TO WRITE A STRATEGY 🤖
-==================================================
-
-I am using 'playwright-smart-table'. I need a custom Pagination Strategy.
-The table is inside this container HTML:
-
-\`\`\`html
-${html.substring(0, 5000)} ... (truncated)
-\`\`\`
-
-Write a strategy that implements this interface:
-type PaginationStrategy = (context: TableContext) => Promise<boolean>;
-
-Requirements:
-1. Identify the "Next" button OR the scroll container.
-2. Return 'true' if data loaded, 'false' if end of data.
-3. Use context.resolve() to find elements.
-`;
-        console.log(prompt);
-    });
 };
 exports.useTable = useTable;
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "1.0.6", 
+  "version": "1.0.7", 
   "description": "A smart table utility for Playwright with built-in pagination strategies.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",