@rickcedwhat/playwright-smart-table 2.0.8 → 2.0.9

package/dist/strategies/index.d.ts

@@ -1,6 +1,15 @@
 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;
 };

package/dist/strategies/index.js

@@ -11,92 +11,87 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableStrategies = void 0;
 /**
- * Helper to get 'expect' safely in ANY environment.
- * 1. Tries global scope (QA Wolf / Cloud Runners).
- * 2. Tries local require (Standard Playwright).
+ * 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 getExpect = () => {
-    // 1. Priority: Global (Environment injected)
-    const globalExpect = globalThis.expect;
-    if (globalExpect)
-        return globalExpect;
-    // 2. Fallback: Module Import (Local development)
-    // We use a try-catch with require to safely attempt loading the module
-    // without crashing environments where the module doesn't exist.
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { expect } = require('@playwright/test');
-        if (expect)
-            return expect;
+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)));
     }
-    catch (e) {
-        // Module not found or require not available.
-    }
-    // 3. Fatal Error
-    throw new Error("@rickcedwhat/playwright-smart-table: 'expect' not found. Ensure you are running in a Playwright test.");
-};
+    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 }) {
-            // ✅ LAZY LOAD: Safe for both Local & Cloud
-            const expect = getExpect();
+        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
             const nextBtn = resolve(nextButtonSelector, root).first();
+            // Check if button exists/enabled before clicking
             if (!(yield nextBtn.isVisible()) || !(yield nextBtn.isEnabled())) {
                 return false;
             }
+            // 1. Snapshot current state
             const firstRow = resolve(config.rowSelector, root).first();
             const oldText = yield firstRow.innerText().catch(() => "");
+            // 2. Click
             yield nextBtn.click();
-            try {
-                yield expect(firstRow).not.toHaveText(oldText, { timeout });
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
+            // 3. Smart Wait (Polling) - No 'expect' needed
+            return yield waitForCondition(() => __awaiter(void 0, void 0, void 0, function* () {
+                const newText = yield firstRow.innerText().catch(() => "");
+                return newText !== oldText;
+            }), timeout, page);
         });
     },
+    /**
+     * 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 }) {
-            const expect = getExpect(); // ✅ LAZY LOAD
+        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();
-            try {
-                yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
-                    const newCount = yield rows.count();
-                    expect(newCount).toBeGreaterThan(oldCount);
-                })).toPass({ timeout });
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
+            // 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 expect = getExpect(); // ✅ LAZY LOAD
             const rows = resolve(config.rowSelector, root);
             const oldCount = yield rows.count();
             if (oldCount === 0)
                 return false;
+            // 1. Trigger Scroll
             yield rows.last().scrollIntoViewIfNeeded();
-            yield page.keyboard.press('End');
+            // Optional: Keyboard press for robust grid handling
             try {
-                yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
-                    const newCount = yield rows.count();
-                    expect(newCount).toBeGreaterThan(oldCount);
-                })).toPass({ timeout });
-                return true;
-            }
-            catch (e) {
-                return false;
+                yield page.keyboard.press('End');
             }
+            catch (e) { }
+            // 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);
         });
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "A smart table utility for Playwright with built-in pagination strategies that are fully extensible.",
   "repository": {
     "type": "git",