@rickcedwhat/playwright-smart-table 1.0.6 → 2.0.0

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/presets.d.ts

@@ -0,0 +1,18 @@
+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) => import("./types").TableResult;
+/**
+ * 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) => import("./types").TableResult;

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,20 +1,56 @@
 import { Locator, Page } from '@playwright/test';
+export type Selector = string | ((root: Locator | Page) => Locator);
+export type SmartRow = Locator & {
+    getCell(column: string): Locator;
+    toJSON(): Promise<Record<string, string>>;
+};
+export interface TableContext {
+    root: Locator;
+    config: Required<TableConfig>;
+    page: Page;
+    resolve: (selector: Selector, parent: Locator | Page) => Locator;
+}
 /**
- * A selector can be a CSS string or a function.
- * We allow 'parent' to be Locator OR Page to match your working logic.
+ * A function that handles pagination logic.
+ * Returns true if more data was loaded (navigation occurred), false if end of data.
  */
-export type Selector = string | ((parent: Locator | Page) => Locator);
+export type PaginationStrategy = (context: TableContext) => Promise<boolean>;
 export interface TableConfig {
     rowSelector?: Selector;
     headerSelector?: Selector;
     cellSelector?: Selector;
+    /**
+     * Strategy for handling pagination.
+     * Use presets from TableStrategies or write your own.
+     */
     pagination?: PaginationStrategy;
     maxPages?: number;
+    /**
+     * Optional hook to rename columns dynamically.
+     * Useful for naming empty columns (like '__col_0') to something semantic like 'Actions'.
+     */
+    headerTransformer?: (text: string, index: number) => string;
 }
-export interface TableContext {
-    root: Locator;
-    config: Required<TableConfig>;
-    page: Page;
-    resolve: (item: Selector, parent: Locator | Page) => Locator;
+export interface TableResult {
+    getHeaders: () => Promise<string[]>;
+    getHeaderCell: (columnName: string) => Promise<Locator>;
+    /** * Find a specific row by its content.
+     * Default: Returns SmartRow (Locator).
+     * Option { asJSON: true }: Returns Record<string, string> (Data).
+     */
+    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>;
+    /** * Get all rows on the current page.
+     * Default: Returns SmartRow[] (Locators).
+     * Option { asJSON: true }: Returns Record<string, string>[] (Data).
+     */
+    getAllRows: <T extends {
+        asJSON?: boolean;
+    }>(options?: T) => Promise<T['asJSON'] extends true ? Record<string, string>[] : SmartRow[]>;
+    generateConfigPrompt: () => Promise<void>;
+    generateStrategyPrompt: () => Promise<void>;
 }
-export type PaginationStrategy = (context: TableContext) => Promise<boolean>;

package/dist/useTable.d.ts

@@ -1,17 +1,3 @@
 import { Locator } from '@playwright/test';
-import { TableConfig } from './types';
-export declare const useTable: (rootLocator: Locator, configOptions?: 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>>;
-    /**
-    * 🛠️ DEV TOOL: Prints a prompt to the console.
-    * Copy the output and paste it into Gemini/ChatGPT to generate your config.
-    */
-    generateConfigPrompt: () => Promise<void>;
-};
+import { TableConfig, TableResult } from './types';
+export declare const useTable: (rootLocator: Locator, configOptions?: TableConfig) => TableResult;

package/dist/useTable.js

@@ -11,8 +11,7 @@ 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, headerTransformer: undefined }, configOptions);
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -24,16 +23,46 @@ const useTable = (rootLocator, configOptions = {}) => {
     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 });
         }
         catch (e) { /* Ignore hydration */ }
         const texts = yield headerLoc.allInnerTexts();
-        _headerMap = new Map(texts.map((t, i) => [t.trim() || `__col_${i}`, i]));
+        _headerMap = new Map(texts.map((t, i) => {
+            let text = t.trim() || `__col_${i}`;
+            if (config.headerTransformer)
+                text = config.headerTransformer(text, i);
+            return [text, i];
+        }));
         return _headerMap;
     });
+    const _makeSmart = (rowLocator, map) => {
+        const smart = rowLocator;
+        smart.getCell = (colName) => {
+            const idx = map.get(colName);
+            if (idx === undefined)
+                throw new Error(`Column '${colName}' not found.`);
+            if (typeof config.cellSelector === 'string') {
+                return rowLocator.locator(config.cellSelector).nth(idx);
+            }
+            else {
+                return resolve(config.cellSelector, rowLocator).nth(idx);
+            }
+        };
+        smart.toJSON = () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = {};
+            const cells = typeof config.cellSelector === 'string'
+                ? rowLocator.locator(config.cellSelector)
+                : resolve(config.cellSelector, rowLocator);
+            const texts = yield cells.allInnerTexts();
+            for (const [col, idx] of map.entries()) {
+                result[col] = (texts[idx] || '').trim();
+            }
+            return result;
+        });
+        return smart;
+    };
     const _findRowLocator = (filters_1, ...args_1) => __awaiter(void 0, [filters_1, ...args_1], void 0, function* (filters, options = {}) {
         var _a;
         const map = yield _getMap();
@@ -41,29 +70,23 @@ 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)
             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: ${[...map.keys()].join(', ')}`);
                 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 }),
                 });
             }
             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 ---
             if (config.pagination && currentPage < effectiveMaxPages) {
                 const context = {
                     root: rootLocator,
@@ -82,145 +105,48 @@ const useTable = (rootLocator, configOptions = {}) => {
     });
     return {
         getHeaders: () => __awaiter(void 0, void 0, void 0, function* () { return Array.from((yield _getMap()).keys()); }),
-        getByRow: (filters_1, ...args_1) => __awaiter(void 0, [filters_1, ...args_1], void 0, function* (filters, options = {}) {
-            const row = yield _findRowLocator(filters, options);
-            if (!row)
-                return resolve(config.rowSelector, rootLocator).filter({ hasText: "NON_EXISTENT_ROW_SENTINEL_" + Date.now() });
-            return row;
-        }),
-        getByCell: (rowFilters, targetColumn) => __awaiter(void 0, void 0, void 0, function* () {
-            const row = yield _findRowLocator(rowFilters);
-            if (!row)
-                throw new Error(`Row not found: ${JSON.stringify(rowFilters)}`);
-            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);
-            }
-            else {
-                return resolve(config.cellSelector, row).nth(colIndex);
-            }
-        }),
-        getRows: () => __awaiter(void 0, void 0, void 0, function* () {
+        getHeaderCell: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
             const map = yield _getMap();
-            const rowLocator = resolve(config.rowSelector, rootLocator);
-            const rowCount = yield rowLocator.count();
-            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);
-                }
-                else {
-                    cells = resolve(config.cellSelector, row);
-                }
-                const cellTexts = yield cells.allInnerTexts();
-                const rowData = {};
-                for (const [colName, colIdx] of map.entries()) {
-                    rowData[colName] = (cellTexts[colIdx] || "").trim();
-                }
-                results.push(rowData);
-            }
-            return results;
+            const idx = map.get(columnName);
+            if (idx === undefined)
+                throw new Error(`Column '${columnName}' not found.`);
+            return resolve(config.headerSelector, rootLocator).nth(idx);
         }),
-        getRowAsJSON: (filters) => __awaiter(void 0, void 0, void 0, function* () {
-            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);
+        getByRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+            let row = yield _findRowLocator(filters, options);
+            // ✅ FIX: Sentinel Logic for negative assertions (expect(row).not.toBeVisible())
+            if (!row) {
+                row = resolve(config.rowSelector, rootLocator).filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
             }
-            else {
-                cells = resolve(config.cellSelector, row);
+            const smartRow = _makeSmart(row, yield _getMap());
+            if (options === null || options === void 0 ? void 0 : options.asJSON) {
+                // If row doesn't exist, toJSON() returns empty object or throws? 
+                // For safety, let's let it run naturally (it will likely return empty strings)
+                return smartRow.toJSON();
             }
-            const cellTexts = yield cells.allInnerTexts();
+            return smartRow;
+        }),
+        getAllRows: (options) => __awaiter(void 0, void 0, void 0, function* () {
             const map = yield _getMap();
-            const result = {};
-            for (const [colName, colIndex] of map.entries()) {
-                result[colName] = (cellTexts[colIndex] || "").trim();
+            const rowLocators = yield resolve(config.rowSelector, rootLocator).all();
+            const smartRows = rowLocators.map(loc => _makeSmart(loc, map));
+            if (options === null || options === void 0 ? void 0 : options.asJSON) {
+                return Promise.all(smartRows.map(r => r.toJSON()));
             }
-            return result;
+            return smartRows;
         }),
-        /**
-        * 🛠️ DEV TOOL: Prints a prompt to the console.
-        * Copy the output and paste it into Gemini/ChatGPT to generate your config.
-        */
         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}
-`;
+            const prompt = `\n${separator}\n🤖 COPY INTO GEMINI/ChatGPT 🤖\n${separator}\nI am using 'playwright-smart-table'. Generate config for:\n\`\`\`html\n${html.substring(0, 5000)} ...\n\`\`\`\n${separator}\n`;
+            console.log(prompt);
+        }),
+        generateStrategyPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
+            const container = rootLocator.locator('xpath=..');
+            const html = yield container.evaluate((el) => el.outerHTML);
+            const prompt = `\n==================================================\n🤖 COPY INTO GEMINI/ChatGPT TO WRITE A STRATEGY 🤖\n==================================================\nI need a custom Pagination Strategy for 'playwright-smart-table'.\nContainer HTML:\n\`\`\`html\n${html.substring(0, 5000)} ...\n\`\`\`\n`;
             console.log(prompt);
         })
     };
-    /**
-     * 🛠️ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "1.0.6", 
+  "version": "2.0.0",
   "description": "A smart table utility for Playwright with built-in pagination strategies.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,14 +10,19 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "publish": "npm publish --access public",
+    "publish-public": "npm publish --access public",
     "test": "npx playwright test"
   },
-  "keywords": ["playwright", "testing", "table", "automation"],
+  "keywords": [
+    "playwright",
+    "testing",
+    "table",
+    "automation"
+  ],
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@playwright/test": "*" 
+    "@playwright/test": "*"
   },
   "peerDependenciesMeta": {
     "@playwright/test": {