@rickcedwhat/playwright-smart-table 6.1.0 → 6.2.0

package/README.md

@@ -79,6 +79,8 @@ const allActive = await table.findRows({ Status: 'Active' });
 ## Key Features
 
 - 🎯 **Smart Locators** - Find rows by content, not position
+- 🧠 **Fuzzy Matching** - Smart suggestions for typos (e.g., incorrectly typed "Firstname" suggests "First Name" in error messages)
+- ⚡ **Smart Initialization** - Handles loading states and dynamic headers automatically
 - 📄 **Auto-Pagination** - Search across all pages automatically
 - 🔍 **Column-Aware Access** - Access cells by column name
 - 🛠️ **Debug Mode** - Visual debugging with slow motion and logging

package/dist/engine/rowFinder.d.ts

@@ -0,0 +1,26 @@
+import type { Locator, Page } from '@playwright/test';
+import { FinalTableConfig, Selector, SmartRow } from '../types';
+import { FilterEngine } from '../filterEngine';
+import { TableMapper } from './tableMapper';
+import { SmartRowArray } from '../utils/smartRowArray';
+export declare class RowFinder<T = any> {
+    private rootLocator;
+    private config;
+    private filterEngine;
+    private tableMapper;
+    private makeSmartRow;
+    private resolve;
+    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number) => SmartRow<T>);
+    private log;
+    findRow(filters: Record<string, string | RegExp | number>, options?: {
+        exact?: boolean;
+        maxPages?: number;
+    }): Promise<SmartRow<T>>;
+    findRows<R extends {
+        asJSON?: boolean;
+    }>(filters: Partial<T> | Record<string, string | RegExp | number>, options?: {
+        exact?: boolean;
+        maxPages?: number;
+    } & R): Promise<R['asJSON'] extends true ? Record<string, string>[] : SmartRowArray<T>>;
+    private findRowLocator;
+}

package/dist/engine/rowFinder.js

@@ -0,0 +1,161 @@
+"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.RowFinder = void 0;
+const debugUtils_1 = require("../utils/debugUtils");
+const smartRowArray_1 = require("../utils/smartRowArray");
+const validation_1 = require("../strategies/validation");
+class RowFinder {
+    constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow) {
+        this.rootLocator = rootLocator;
+        this.config = config;
+        this.filterEngine = filterEngine;
+        this.tableMapper = tableMapper;
+        this.makeSmartRow = makeSmartRow;
+        this.resolve = resolve;
+    }
+    log(msg) {
+        (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
+    }
+    findRow(filters_1) {
+        return __awaiter(this, arguments, void 0, function* (filters, options = {}) {
+            (0, debugUtils_1.logDebug)(this.config, 'info', 'Searching for row', filters);
+            yield this.tableMapper.getMap();
+            const rowLocator = yield this.findRowLocator(filters, options);
+            if (rowLocator) {
+                (0, debugUtils_1.logDebug)(this.config, 'info', 'Row found');
+                yield (0, debugUtils_1.debugDelay)(this.config, 'findRow');
+                return this.makeSmartRow(rowLocator, yield this.tableMapper.getMap(), 0);
+            }
+            (0, debugUtils_1.logDebug)(this.config, 'error', 'Row not found', filters);
+            yield (0, debugUtils_1.debugDelay)(this.config, 'findRow');
+            const sentinel = this.resolve(this.config.rowSelector, this.rootLocator)
+                .filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
+            return this.makeSmartRow(sentinel, yield this.tableMapper.getMap(), 0);
+        });
+    }
+    findRows(filters, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const map = yield this.tableMapper.getMap();
+            const allRows = [];
+            const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
+            let pageCount = 0;
+            const collectMatches = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
+                rowLocators = this.filterEngine.applyFilters(rowLocators, filters, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page());
+                const currentRows = yield rowLocators.all();
+                const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
+                for (let i = 0; i < currentRows.length; i++) {
+                    const smartRow = this.makeSmartRow(currentRows[i], map, i);
+                    if (isRowLoading && (yield isRowLoading(smartRow)))
+                        continue;
+                    allRows.push(smartRow);
+                }
+            });
+            // Scan first page
+            yield collectMatches();
+            // Pagination Loop
+            while (pageCount < effectiveMaxPages && this.config.strategies.pagination) {
+                // Check if pagination needed? findRows assumes we want ALL matches across maxPages.
+                // If explicit maxPages is set, we paginate. If global maxPages is 1 (default), we stop.
+                // Wait, loop condition `pageCount < effectiveMaxPages`. If maxPages=1, 0 < 1 is true.
+                // We paginate AFTER first scan.
+                // If maxPages=1, we should NOT paginate.
+                if (effectiveMaxPages <= 1)
+                    break;
+                const context = {
+                    root: this.rootLocator,
+                    config: this.config,
+                    resolve: this.resolve,
+                    page: this.rootLocator.page()
+                };
+                const paginationResult = yield this.config.strategies.pagination(context);
+                const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                if (!didPaginate)
+                    break;
+                pageCount++;
+                yield collectMatches();
+            }
+            if (options === null || options === void 0 ? void 0 : options.asJSON) {
+                return Promise.all(allRows.map(r => r.toJSON()));
+            }
+            return (0, smartRowArray_1.createSmartRowArray)(allRows);
+        });
+    }
+    findRowLocator(filters_1) {
+        return __awaiter(this, arguments, void 0, function* (filters, options = {}) {
+            var _a, _b;
+            const map = yield this.tableMapper.getMap();
+            const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
+            let currentPage = 1;
+            this.log(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
+            while (true) {
+                // Check Loading
+                if ((_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isTableLoading) {
+                    const isLoading = yield this.config.strategies.loading.isTableLoading({
+                        root: this.rootLocator,
+                        config: this.config,
+                        page: this.rootLocator.page(),
+                        resolve: this.resolve
+                    });
+                    if (isLoading) {
+                        this.log('Table is loading... waiting');
+                        yield this.rootLocator.page().waitForTimeout(200);
+                        continue;
+                    }
+                }
+                const allRows = this.resolve(this.config.rowSelector, this.rootLocator);
+                const matchedRows = this.filterEngine.applyFilters(allRows, filters, map, options.exact || false, this.rootLocator.page());
+                const count = yield matchedRows.count();
+                this.log(`Page ${currentPage}: Found ${count} matches.`);
+                if (count > 1) {
+                    const sampleData = [];
+                    try {
+                        const firstFewRows = yield matchedRows.all();
+                        const sampleCount = Math.min(firstFewRows.length, 3);
+                        for (let i = 0; i < sampleCount; i++) {
+                            const rowData = yield this.makeSmartRow(firstFewRows[i], map, 0).toJSON();
+                            sampleData.push(JSON.stringify(rowData));
+                        }
+                    }
+                    catch (e) { }
+                    const sampleMsg = sampleData.length > 0 ? `\nSample matching rows:\n${sampleData.map((d, i) => `  ${i + 1}. ${d}`).join('\n')}` : '';
+                    throw new Error(`Ambiguous Row: Found ${count} rows matching ${JSON.stringify(filters)} on page ${currentPage}. ` +
+                        `Expected exactly one match. Try adding more filters to make your query unique.${sampleMsg}`);
+                }
+                if (count === 1)
+                    return matchedRows.first();
+                if (currentPage < effectiveMaxPages) {
+                    this.log(`Page ${currentPage}: Not found. Attempting pagination...`);
+                    const context = {
+                        root: this.rootLocator,
+                        config: this.config,
+                        resolve: this.resolve,
+                        page: this.rootLocator.page()
+                    };
+                    const paginationResult = yield this.config.strategies.pagination(context);
+                    const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
+                    if (didLoadMore) {
+                        currentPage++;
+                        continue;
+                    }
+                    else {
+                        this.log(`Page ${currentPage}: Pagination failed (end of data).`);
+                    }
+                }
+                return null;
+            }
+        });
+    }
+}
+exports.RowFinder = RowFinder;

package/dist/engine/tableMapper.d.ts

@@ -0,0 +1,16 @@
+import type { Locator, Page } from '@playwright/test';
+import { FinalTableConfig, Selector } from '../types';
+export declare class TableMapper {
+    private _headerMap;
+    private config;
+    private rootLocator;
+    private resolve;
+    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator);
+    private log;
+    getMap(timeout?: number): Promise<Map<string, number>>;
+    remapHeaders(): Promise<void>;
+    getMapSync(): Map<string, number> | null;
+    isInitialized(): boolean;
+    clear(): void;
+    private processHeaders;
+}

package/dist/engine/tableMapper.js

@@ -0,0 +1,136 @@
+"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.TableMapper = void 0;
+const headers_1 = require("../strategies/headers");
+const debugUtils_1 = require("../utils/debugUtils");
+class TableMapper {
+    constructor(rootLocator, config, resolve) {
+        this._headerMap = null;
+        this.rootLocator = rootLocator;
+        this.config = config;
+        this.resolve = resolve;
+    }
+    log(msg) {
+        (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
+    }
+    getMap(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this._headerMap)
+                return this._headerMap;
+            this.log('Mapping headers...');
+            const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
+            const startTime = Date.now();
+            if (this.config.autoScroll) {
+                try {
+                    yield this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
+                }
+                catch (e) { }
+            }
+            const headerLoc = this.resolve(this.config.headerSelector, this.rootLocator);
+            const strategy = this.config.strategies.header || headers_1.HeaderStrategies.visible;
+            const context = {
+                root: this.rootLocator,
+                config: this.config,
+                page: this.rootLocator.page(),
+                resolve: this.resolve
+            };
+            let lastError = null;
+            while (Date.now() - startTime < headerTimeout) {
+                // 1. Wait for visibility
+                try {
+                    yield headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
+                }
+                catch (e) {
+                    // Continue to check existing/loading state even if not strictly "visible" yet
+                }
+                // 2. Check Smart Loading State
+                if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
+                    const isStable = !(yield this.config.strategies.loading.isHeaderLoading(context));
+                    if (!isStable) {
+                        this.log('Headers are loading/unstable... waiting');
+                        yield new Promise(r => setTimeout(r, 100));
+                        continue;
+                    }
+                }
+                // 3. Attempt Scan
+                try {
+                    const rawHeaders = yield strategy(context);
+                    const entries = yield this.processHeaders(rawHeaders);
+                    // Success
+                    this._headerMap = new Map(entries);
+                    this.log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
+                    return this._headerMap;
+                }
+                catch (e) {
+                    lastError = e;
+                    this.log(`Header mapping failed (retrying): ${e.message}`);
+                    yield new Promise(r => setTimeout(r, 100));
+                }
+            }
+            throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);
+        });
+    }
+    remapHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._headerMap = null;
+            yield this.getMap();
+        });
+    }
+    getMapSync() {
+        return this._headerMap;
+    }
+    isInitialized() {
+        return this._headerMap !== null;
+    }
+    clear() {
+        this._headerMap = null;
+    }
+    processHeaders(rawHeaders) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const seenHeaders = new Set();
+            const entries = [];
+            for (let i = 0; i < rawHeaders.length; i++) {
+                let text = rawHeaders[i].trim() || `__col_${i}`;
+                if (this.config.headerTransformer) {
+                    text = yield this.config.headerTransformer({
+                        text,
+                        index: i,
+                        locator: this.rootLocator.locator(this.config.headerSelector).nth(i),
+                        seenHeaders
+                    });
+                }
+                entries.push([text, i]);
+                seenHeaders.add(text);
+            }
+            // Validation: Check for empty table
+            if (entries.length === 0) {
+                throw new Error(`Initialization Error: No columns found using selector "${this.config.headerSelector}". Check your selector or ensure the table is visible.`);
+            }
+            // Validation: Check for duplicates
+            const seen = new Set();
+            const duplicates = new Set();
+            for (const [name] of entries) {
+                if (seen.has(name)) {
+                    duplicates.add(name);
+                }
+                seen.add(name);
+            }
+            if (duplicates.size > 0) {
+                const dupList = Array.from(duplicates).map(d => `"${d}"`).join(', ');
+                throw new Error(`Initialization Error: Duplicate column names found: ${dupList}. Use 'headerTransformer' to rename duplicate columns.`);
+            }
+            return entries;
+        });
+    }
+}
+exports.TableMapper = TableMapper;

package/dist/{examples/glide-strategies → strategies/glide}/columns.d.ts

@@ -1,4 +1,4 @@
-import { StrategyContext } from '../../src/types';
+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).

package/dist/{examples/glide-strategies → strategies/glide}/headers.d.ts

@@ -1,4 +1,4 @@
-import { StrategyContext } from '../../src/types';
+import { StrategyContext } from '../../types';
 /**
  * Scans for headers by finding a scrollable container and setting scrollLeft.
  */

package/dist/{src/strategies → strategies}/glide.js

@@ -10,8 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlideStrategies = exports.glideGetActiveCell = exports.glideGetCellLocator = exports.glidePaginationStrategy = exports.glideFillStrategy = void 0;
-const columns_1 = require("../../examples/glide-strategies/columns");
-const headers_1 = require("../../examples/glide-strategies/headers");
+const columns_1 = require("./glide/columns");
+const headers_1 = require("./glide/headers");
 const pagination_1 = require("./pagination");
 const stabilization_1 = require("./stabilization");
 const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {

package/dist/strategies/index.d.ts

@@ -4,10 +4,21 @@ export * from './columns';
 export * from './headers';
 export * from './fill';
 export * from './resolution';
+export * from './dedupe';
+export * from './loading';
 export declare const Strategies: {
     Pagination: {
-        clickNext: (nextButtonSelector: import("..").Selector, timeout?: number) => import("..").PaginationStrategy;
-        infiniteScroll: (timeout?: number) => import("..").PaginationStrategy;
+        clickNext: (nextButtonSelector: import("..").Selector, options?: {
+            stabilization?: import("./stabilization").StabilizationStrategy;
+            timeout?: number;
+        }) => import("..").PaginationStrategy;
+        infiniteScroll: (options?: {
+            action?: "scroll" | "js-scroll";
+            scrollTarget?: import("..").Selector;
+            scrollAmount?: number;
+            stabilization?: import("./stabilization").StabilizationStrategy;
+            timeout?: number;
+        }) => import("..").PaginationStrategy;
     };
     Sorting: {
         AriaSort: () => import("..").SortingStrategy;
@@ -24,4 +35,24 @@ export declare const Strategies: {
     Resolution: {
         default: import("./resolution").ColumnResolutionStrategy;
     };
+    Dedupe: {
+        byTopPosition: (tolerance?: number) => import("..").DedupeStrategy;
+    };
+    Loading: {
+        Table: {
+            hasSpinner: (selector?: string) => ({ root }: import("..").TableContext) => Promise<boolean>;
+            custom: (fn: (context: import("..").TableContext) => Promise<boolean>) => (context: import("..").TableContext) => Promise<boolean>;
+            never: () => Promise<boolean>;
+        };
+        Row: {
+            hasClass: (className?: string) => (row: import("..").SmartRow) => Promise<boolean>;
+            hasText: (text?: string | RegExp) => (row: import("..").SmartRow) => Promise<boolean>;
+            hasEmptyCells: () => (row: import("..").SmartRow) => Promise<boolean>;
+            never: () => Promise<boolean>;
+        };
+        Headers: {
+            stable: (duration?: number) => (context: import("..").TableContext) => Promise<boolean>;
+            never: () => Promise<boolean>;
+        };
+    };
 };

package/dist/strategies/index.js

@@ -21,12 +21,16 @@ const columns_1 = require("./columns");
 const headers_1 = require("./headers");
 const fill_1 = require("./fill");
 const resolution_1 = require("./resolution");
+const dedupe_1 = require("./dedupe");
+const loading_1 = require("./loading");
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./sorting"), exports);
 __exportStar(require("./columns"), exports);
 __exportStar(require("./headers"), exports);
 __exportStar(require("./fill"), exports);
 __exportStar(require("./resolution"), exports);
+__exportStar(require("./dedupe"), exports);
+__exportStar(require("./loading"), exports);
 exports.Strategies = {
     Pagination: pagination_1.PaginationStrategies,
     Sorting: sorting_1.SortingStrategies,
@@ -34,4 +38,6 @@ exports.Strategies = {
     Header: headers_1.HeaderStrategies,
     Fill: fill_1.FillStrategies,
     Resolution: resolution_1.ResolutionStrategies,
+    Dedupe: dedupe_1.DedupeStrategies,
+    Loading: loading_1.LoadingStrategies,
 };

package/dist/{src/strategies → strategies}/loading.d.ts

@@ -45,4 +45,18 @@ export declare const LoadingStrategies: {
          */
         never: () => Promise<boolean>;
     };
+    /**
+     * Strategies for detecting if headers are loading/stable.
+     */
+    Headers: {
+        /**
+         * Checks if the headers are stable (count and text) for a specified duration.
+         * @param duration Duration in ms for headers to remain unchanged to be considered stable (default: 200).
+         */
+        stable: (duration?: number) => (context: TableContext) => Promise<boolean>;
+        /**
+         * Assume headers are never loading (immediate snapshot).
+         */
+        never: () => Promise<boolean>;
+    };
 };

package/dist/{src/strategies → strategies}/loading.js

@@ -78,5 +78,36 @@ exports.LoadingStrategies = {
          * Assume row is never loading (default).
          */
         never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+    },
+    /**
+     * Strategies for detecting if headers are loading/stable.
+     */
+    Headers: {
+        /**
+         * Checks if the headers are stable (count and text) for a specified duration.
+         * @param duration Duration in ms for headers to remain unchanged to be considered stable (default: 200).
+         */
+        stable: (duration = 200) => (context) => __awaiter(void 0, void 0, void 0, function* () {
+            const { config, resolve, root } = context;
+            const getHeaderTexts = () => __awaiter(void 0, void 0, void 0, function* () {
+                const headers = yield resolve(config.headerSelector, root).all();
+                return Promise.all(headers.map(h => h.innerText()));
+            });
+            const initial = yield getHeaderTexts();
+            // Wait for duration
+            yield context.page.waitForTimeout(duration);
+            const current = yield getHeaderTexts();
+            if (initial.length !== current.length)
+                return true; // Count changed, still loading
+            for (let i = 0; i < initial.length; i++) {
+                if (initial[i] !== current[i])
+                    return true; // Content changed, still loading
+            }
+            return false; // Stable
+        }),
+        /**
+         * Assume headers are never loading (immediate snapshot).
+         */
+        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
     }
 };

package/dist/strategies/pagination.d.ts

@@ -1,11 +1,33 @@
 import type { PaginationStrategy, Selector } from '../types';
+import { StabilizationStrategy } from './stabilization';
 export declare const PaginationStrategies: {
     /**
-     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
+     * Strategy: Clicks a "Next" button and waits for stabilization.
+     * @param nextButtonSelector Selector for the next page button.
+     * @param options.stabilization Strategy to determine when the page has updated.
+     *        Defaults to `contentChanged({ scope: 'first' })`.
+     * @param options.timeout Timeout for the click action.
      */
-    clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
+    clickNext: (nextButtonSelector: Selector, options?: {
+        stabilization?: StabilizationStrategy;
+        timeout?: number;
+    }) => PaginationStrategy;
     /**
-     * Strategy: Scrolls to the bottom and waits for more rows to appear.
+     * Strategy: Infinite Scroll (generic).
+     * Supports both simple "Scroll to Bottom" and "Virtualized Scroll".
+     *
+     * @param options.action 'scroll' (mouse wheel) or 'js-scroll' (direct scrollTop).
+     * @param options.scrollTarget Selector for the scroll container (defaults to table root).
+     * @param options.scrollAmount Amount to scroll in pixels (default 500).
+     * @param options.stabilization Strategy to determine if new content loaded.
+     *        Defaults to `rowCountIncreased` (simple append).
+     *        Use `contentChanged` for virtualization.
      */
-    infiniteScroll: (timeout?: number) => PaginationStrategy;
+    infiniteScroll: (options?: {
+        action?: "scroll" | "js-scroll";
+        scrollTarget?: Selector;
+        scrollAmount?: number;
+        stabilization?: StabilizationStrategy;
+        timeout?: number;
+    }) => PaginationStrategy;
 };

package/dist/strategies/pagination.js

@@ -10,41 +10,70 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationStrategies = void 0;
-const utils_1 = require("../utils");
+const stabilization_1 = require("./stabilization");
 exports.PaginationStrategies = {
     /**
-     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
+     * Strategy: Clicks a "Next" button and waits for stabilization.
+     * @param nextButtonSelector Selector for the next page button.
+     * @param options.stabilization Strategy to determine when the page has updated.
+     *        Defaults to `contentChanged({ scope: 'first' })`.
+     * @param options.timeout Timeout for the click action.
      */
-    clickNext: (nextButtonSelector, timeout = 5000) => {
-        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
+    clickNext: (nextButtonSelector, options = {}) => {
+        return (context) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const { root, resolve, page } = context;
             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);
+            // Default stabilization: Wait for first row content to change
+            const stabilization = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.contentChanged({ scope: 'first', timeout: options.timeout });
+            // Stabilization: Wrap action
+            const success = yield stabilization(context, () => __awaiter(void 0, void 0, void 0, function* () {
+                yield nextBtn.click({ timeout: 2000 }).catch(() => { });
+            }));
             return success;
         });
     },
     /**
-     * Strategy: Scrolls to the bottom and waits for more rows to appear.
+     * Strategy: Infinite Scroll (generic).
+     * Supports both simple "Scroll to Bottom" and "Virtualized Scroll".
+     *
+     * @param options.action 'scroll' (mouse wheel) or 'js-scroll' (direct scrollTop).
+     * @param options.scrollTarget Selector for the scroll container (defaults to table root).
+     * @param options.scrollAmount Amount to scroll in pixels (default 500).
+     * @param options.stabilization Strategy to determine if new content loaded.
+     *        Defaults to `rowCountIncreased` (simple append).
+     *        Use `contentChanged` for virtualization.
      */
-    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);
+    infiniteScroll: (options = {}) => {
+        return (context) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            const { root, resolve, page } = context;
+            const scrollTarget = options.scrollTarget
+                ? resolve(options.scrollTarget, root)
+                : root;
+            // Default stabilization: Wait for row count to increase (Append mode)
+            const stabilization = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.rowCountIncreased({ timeout: options.timeout });
+            const amount = (_b = options.scrollAmount) !== null && _b !== void 0 ? _b : 500;
+            const doScroll = () => __awaiter(void 0, void 0, void 0, function* () {
+                const box = yield scrollTarget.boundingBox();
+                // Action: Scroll
+                if (options.action === 'js-scroll' || !box) {
+                    yield scrollTarget.evaluate((el, y) => {
+                        el.scrollTop += y;
+                    }, amount);
+                }
+                else {
+                    // Mouse Wheel
+                    yield page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                    yield page.mouse.wheel(0, amount);
+                }
+            });
+            // Stabilization: Wait
+            const success = yield stabilization(context, doScroll);
+            return success;
         });
     }
 };