@rickcedwhat/playwright-smart-table 6.25.0-next.3dfcc94 → 6.25.0-next.49ce2de

package/dist/engine/countRows.d.ts

@@ -0,0 +1,27 @@
+import type { Locator } from '@playwright/test';
+import type { FilterValue, FinalTableConfig, TableContext } from '../types';
+import type { FilterEngine } from '../filterEngine';
+import type { TableMapper } from './tableMapper';
+import type { RowFinder } from './rowFinder';
+export interface CountRowsEnv<T = any> {
+    config: FinalTableConfig<T>;
+    rootLocator: Locator;
+    getRowLocators: () => Locator;
+    tableMapper: TableMapper;
+    filterEngine: FilterEngine;
+    rowFinder: RowFinder<T>;
+    advancePage: (useBulk: boolean) => Promise<boolean>;
+    getCurrentPageIndex: () => number;
+    getContext: () => TableContext;
+    /** Restores page 1 after a paginated count. */
+    reset: () => Promise<void>;
+}
+/**
+ * Counts matching rows on the current page, or across pages when pagination and
+ * `maxPages > 1` allow it. A paginated count always resets to page 1 afterwards (#348).
+ * Callers must have initialized the table.
+ */
+export declare function countRows<T>(env: CountRowsEnv<T>, filters?: Record<string, FilterValue>, options?: {
+    exact?: boolean;
+    maxPages?: number;
+}): Promise<number>;

package/dist/engine/countRows.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countRows = countRows;
+const scanPages_1 = require("./scanPages");
+const elementTracker_1 = require("../utils/elementTracker");
+const debugUtils_1 = require("../utils/debugUtils");
+const loadingWait_1 = require("../utils/loadingWait");
+const safeStringify_1 = require("../utils/safeStringify");
+function log(config, msg) {
+    (0, debugUtils_1.logDebug)(config, 'verbose', msg);
+}
+/** Splits filters by how they're evaluated: DOM text, `columnOverrides.read`, or synthetic columns. */
+function partitionFilters(config, filters) {
+    var _a, _b, _c;
+    const domFilters = {};
+    const overrideFilters = {};
+    const syntheticFilters = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[key]) {
+            syntheticFilters[key] = value;
+        }
+        else if ((_c = (_b = config.columnOverrides) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.read) {
+            overrideFilters[key] = value;
+        }
+        else {
+            domFilters[key] = value;
+        }
+    }
+    return { domFilters, overrideFilters, syntheticFilters };
+}
+function requireMap(tableMapper) {
+    const map = tableMapper.getMapSync();
+    if (!map)
+        throw new Error('Initialization Error: Table map not available. Call "await table.init()" first.');
+    return map;
+}
+/**
+ * Counts matching rows on the current page, or across pages when pagination and
+ * `maxPages > 1` allow it. A paginated count always resets to page 1 afterwards (#348).
+ * Callers must have initialized the table.
+ */
+async function countRows(env, filters, options) {
+    var _a;
+    var _b, _c;
+    const { config, rootLocator, tableMapper, rowFinder } = env;
+    const filtersRecord = filters !== null && filters !== void 0 ? filters : {};
+    const hasFilters = Object.keys(filtersRecord).length > 0;
+    const effectiveMaxPages = (_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages;
+    const pag = config.strategies.pagination;
+    const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
+    const exact = (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false;
+    const { domFilters, overrideFilters, syntheticFilters } = partitionFilters(config, filtersRecord);
+    const hasOverrides = Object.keys(overrideFilters).length > 0;
+    const hasSynthetics = Object.keys(syntheticFilters).length > 0;
+    const hasPostFilters = hasOverrides || hasSynthetics;
+    const resolveRows = () => {
+        const rows = env.getRowLocators();
+        if (Object.keys(domFilters).length === 0)
+            return rows;
+        return env.filterEngine.applyFilters(rows, domFilters, requireMap(tableMapper), exact, rootLocator.page(), rootLocator);
+    };
+    const countPostFilterMatches = async (candidates, indices) => {
+        if (!hasPostFilters)
+            return indices.length;
+        const map = requireMap(tableMapper);
+        let count = 0;
+        for (const idx of indices) {
+            const row = candidates[idx];
+            if (hasOverrides && !await rowFinder.matchesOverrideFilters(row, overrideFilters, map, exact))
+                continue;
+            if (hasSynthetics && !await rowFinder.matchesSyntheticFilters(row, syntheticFilters, map, exact))
+                continue;
+            count++;
+        }
+        return count;
+    };
+    const isTableLoading = (_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading;
+    const waitForReady = async () => {
+        if (!isTableLoading)
+            return;
+        await (0, loadingWait_1.waitWhileTableLoading)(config, env.getContext(), rootLocator.page(), 'countRows');
+    };
+    await waitForReady();
+    const filterSuffix = hasFilters ? ` filters=${(0, safeStringify_1.safeStringify)(filtersRecord)}` : '';
+    if (!hasPagination) {
+        log(config, `countRows: counting rows in current viewport (no pagination)${filterSuffix}`);
+        if (!hasPostFilters)
+            return resolveRows().count();
+        const all = await resolveRows().all();
+        return countPostFilterMatches(all, all.map((_, i) => i));
+    }
+    log(config, `countRows: paginating up to ${effectiveMaxPages} page(s)${filterSuffix}`);
+    const tracker = new elementTracker_1.ElementTracker('countRows');
+    let total = 0;
+    let pagesScanned = 1;
+    let paginationError;
+    try {
+        const scanned = await (0, scanPages_1.scanPages)({
+            advancePage: env.advancePage,
+            getCurrentPageIndex: env.getCurrentPageIndex,
+            config,
+            waitForReady,
+        }, async ({ pagesScanned: pageNum }) => {
+            const rowLocators = resolveRows();
+            const newIndices = await tracker.getUnseenIndices(rowLocators);
+            const candidates = await rowLocators.all();
+            const matched = await countPostFilterMatches(candidates, newIndices);
+            total += matched;
+            log(config, `countRows: page ${pageNum} — ${matched} row(s) (running total: ${total})`);
+            return 'continue';
+        }, {
+            maxPages: effectiveMaxPages,
+            useBulk: false,
+            label: 'countRows',
+            finalScanOnEof: true,
+        });
+        pagesScanned = scanned.pagesScanned;
+    }
+    catch (e) {
+        paginationError = e;
+        throw e;
+    }
+    finally {
+        await tracker.cleanup(rootLocator.page());
+        // Always restore page 1, even if pagination threw mid-count (#348), so the table
+        // stays usable for callers that catch the error. If reset() itself fails, only let
+        // it surface when pagination succeeded — otherwise preserve the original error.
+        log(config, `countRows: ${total} total row(s) across ${pagesScanned} page(s) — resetting`);
+        try {
+            await env.reset();
+        }
+        catch (resetError) {
+            if (paginationError === undefined)
+                throw resetError;
+            (0, debugUtils_1.logDebug)(config, 'error', 'countRows: reset() failed after pagination error', resetError);
+        }
+    }
+    return total;
+}

package/dist/engine/rowByIndex.d.ts

@@ -0,0 +1,19 @@
+import type { Locator } from '@playwright/test';
+import type { FinalTableConfig, SmartRow, TableContext } from '../types';
+export interface RowByIndexEnv<T = any> {
+    config: FinalTableConfig<T>;
+    getRowLocators: () => Locator;
+    getMap: () => Map<string, number>;
+    advancePage: (useBulk: boolean) => Promise<boolean>;
+    getCurrentPageIndex: () => number;
+    getContext: () => TableContext;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex: number, healSelector?: string) => SmartRow<T>;
+}
+/**
+ * Finds the row whose logical index (per `strategies.resolveRowIndex`) is `index`:
+ * already mounted, else via `viewport.scrollToRow`, else by advancing pages until it
+ * mounts (bounded by `maxPages`). Callers must have initialized the table.
+ */
+export declare function findRowByIndex<T>(env: RowByIndexEnv<T>, index: number, options?: {
+    maxPages?: number;
+}): Promise<SmartRow<T>>;

package/dist/engine/rowByIndex.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRowByIndex = findRowByIndex;
+const rowResolution_1 = require("./rowResolution");
+const scanPages_1 = require("./scanPages");
+const debugUtils_1 = require("../utils/debugUtils");
+const safeStringify_1 = require("../utils/safeStringify");
+/**
+ * Finds the row whose logical index (per `strategies.resolveRowIndex`) is `index`:
+ * already mounted, else via `viewport.scrollToRow`, else by advancing pages until it
+ * mounts (bounded by `maxPages`). Callers must have initialized the table.
+ */
+async function findRowByIndex(env, index, options) {
+    var _a;
+    const { config } = env;
+    (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: index=${index} options=${(0, safeStringify_1.safeStringify)(options)}`);
+    const resolveRI = config.strategies.resolveRowIndex;
+    const viewport = config.strategies.viewport;
+    // Identifying a row by its logical index requires a resolveRowIndex strategy. Without one
+    // the library can only offer render-window-relative getRowByIndex, or filter-based findRow.
+    if (!resolveRI) {
+        throw new Error(`findRowByIndex(${index}) requires a strategies.resolveRowIndex to identify rows by their logical index. ` +
+            `Configure one (e.g. read the grid's row-index attribute), or use getRowByIndex() (current render window) / findRow(filters).`);
+    }
+    let foundSelector;
+    // The currently-mounted row whose logical index === index, if any.
+    const findMounted = async () => {
+        const rows = await env.getRowLocators().all();
+        for (const r of rows) {
+            const result = await resolveRI(r);
+            if (result === undefined)
+                continue;
+            const normalized = (0, rowResolution_1.normalizeRowIndexResult)(result);
+            if (normalized.index === index) {
+                foundSelector = normalized.selector;
+                return r;
+            }
+        }
+        return null;
+    };
+    // 1. Already mounted (no navigation needed)?
+    let loc = await findMounted();
+    // 2. Fast path: jump straight to it via the viewport's random-access scroll.
+    if (!loc && (viewport === null || viewport === void 0 ? void 0 : viewport.scrollToRow)) {
+        (0, debugUtils_1.logDebug)(config, 'verbose', `findRowByIndex: scrolling to row ${index}`);
+        await viewport.scrollToRow(env.getContext(), index);
+        loc = await findMounted();
+    }
+    // 3. Fallback: advance pages (on infinite-scroll tables, a "page" is a scroll step) until
+    //    the row is mounted. Page 1 was already searched above.
+    const maxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
+    const scanForMounted = async () => {
+        let hit = null;
+        await (0, scanPages_1.scanPages)({ advancePage: env.advancePage, getCurrentPageIndex: env.getCurrentPageIndex, config }, async ({ pagesScanned }) => {
+            if (pagesScanned > 1)
+                hit = await findMounted();
+            return hit ? 'stop' : 'continue';
+        }, { maxPages, useBulk: false, label: 'findRowByIndex', finalScanOnEof: false });
+        return hit;
+    };
+    if (!loc && config.strategies.pagination) {
+        loc = await scanForMounted();
+    }
+    if (!loc) {
+        throw new Error(`findRowByIndex(${index}): could not reach row ${index}. ` +
+            `Ensure a viewport.scrollToRow or pagination can bring it into view (searched up to maxPages=${maxPages}).`);
+    }
+    await (0, debugUtils_1.debugDelay)(config, 'findRow');
+    return env.makeSmartRow(loc, env.getMap(), index, env.getCurrentPageIndex(), foundSelector);
+}

package/dist/engine/scanPages.d.ts

@@ -21,10 +21,10 @@ import type { FinalTableConfig } from '../types';
  * | findRow | yes | options.useBulkPagination | yes | DOM/post filters only |
  * | countRows | yes | no (single-step) | yes | count-only / post filters |
  * | async iterator | yes | no | via runMap path | same as map |
- * | findRowByIndex | no* | no | n/a | scroll/search, not a full scan |
+ * | findRowByIndex | no | no | no | stops once the target index is mounted* |
  * | bringIntoView | n/a | path planner | n/a | not a page scan |
  *
- * \* findRowByIndex stops when the target index is mounted; it does not collect rows.
+ * \* findRowByIndex only falls back to scanPages after the mounted / viewport.scrollToRow paths miss.
  */
 export type ScanDecision = 'continue' | 'stop';
 export interface ScanPageContext {

package/dist/engine/sorting.d.ts

@@ -0,0 +1,11 @@
+import type { Page } from '@playwright/test';
+import type { FinalTableConfig, StrategyContext } from '../types';
+export interface SortingEnv<T = any> {
+    config: FinalTableConfig<T>;
+    getPage: () => Page;
+    /** Strategy context including `getHeaderCell`. */
+    getContext: () => StrategyContext;
+}
+/** Drives the sorting strategy until `columnName` reports `direction`, retrying up to 3 times. */
+export declare function applySort<T>(env: SortingEnv<T>, columnName: string, direction: 'asc' | 'desc'): Promise<void>;
+export declare function getSortState<T>(env: SortingEnv<T>, columnName: string): Promise<'asc' | 'desc' | 'none'>;

package/dist/engine/sorting.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySort = applySort;
+exports.getSortState = getSortState;
+const debugUtils_1 = require("../utils/debugUtils");
+const loadingWait_1 = require("../utils/loadingWait");
+const MAX_SORT_ATTEMPTS = 3;
+function requireSorting(config) {
+    if (!config.strategies.sorting)
+        throw new Error('No sorting strategy has been configured.');
+    return config.strategies.sorting;
+}
+/** Waits for the table to settle after `doSort`: `isTableLoading` when configured, otherwise a fixed delay. */
+async function waitForSortToSettle(env, context) {
+    var _a, _b, _c, _d;
+    const loading = env.config.strategies.loading;
+    if (loading === null || loading === void 0 ? void 0 : loading.isTableLoading) {
+        const timeout = (_b = (_a = loading.sortStabilizationTimeout) !== null && _a !== void 0 ? _a : loading.loadingTimeout) !== null && _b !== void 0 ? _b : 10000;
+        const pollInterval = (_c = loading.sortStabilizationPollInterval) !== null && _c !== void 0 ? _c : 100;
+        await (0, loadingWait_1.waitWhileTableLoading)(env.config, context, env.getPage(), 'sorting.apply', { timeout, pollInterval });
+    }
+    else {
+        await env.getPage().waitForTimeout((_d = loading === null || loading === void 0 ? void 0 : loading.sortStabilizationFallbackDelay) !== null && _d !== void 0 ? _d : 200);
+    }
+}
+/** Drives the sorting strategy until `columnName` reports `direction`, retrying up to 3 times. */
+async function applySort(env, columnName, direction) {
+    const sorting = requireSorting(env.config);
+    (0, debugUtils_1.logDebug)(env.config, 'verbose', `Applying sort for column "${columnName}" (${direction})`);
+    const context = env.getContext();
+    for (let i = 0; i < MAX_SORT_ATTEMPTS; i++) {
+        const currentState = await sorting.getSortState({ columnName, context });
+        if (currentState === direction) {
+            (0, debugUtils_1.logDebug)(env.config, 'verbose', `Sort for "${columnName}" is already "${direction}".`);
+            return;
+        }
+        await sorting.doSort({ columnName, direction, context });
+        await waitForSortToSettle(env, context);
+        await (0, debugUtils_1.debugDelay)(env.config, 'default');
+        const newState = await sorting.getSortState({ columnName, context });
+        if (newState === direction) {
+            (0, debugUtils_1.logDebug)(env.config, 'verbose', `Successfully sorted "${columnName}" to "${direction}".`);
+            return;
+        }
+    }
+    throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${MAX_SORT_ATTEMPTS} attempts.`);
+}
+async function getSortState(env, columnName) {
+    const sorting = requireSorting(env.config);
+    return sorting.getSortState({ columnName, context: env.getContext() });
+}

package/dist/packageVersion.d.ts

@@ -3,4 +3,4 @@
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.3dfcc94";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.49ce2de";

package/dist/packageVersion.js

@@ -6,4 +6,4 @@ exports.PLAYWRIGHT_SMART_TABLE_VERSION = void 0;
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.3dfcc94";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.49ce2de";

package/dist/useTable.js

@@ -27,29 +27,15 @@ const filterEngine_1 = require("./filterEngine");
 const tableMapper_1 = require("./engine/tableMapper");
 const rowFinder_1 = require("./engine/rowFinder");
 const tableIteration_1 = require("./engine/tableIteration");
-const rowResolution_1 = require("./engine/rowResolution");
-const scanPages_1 = require("./engine/scanPages");
+const countRows_1 = require("./engine/countRows");
+const sorting_1 = require("./engine/sorting");
+const rowByIndex_1 = require("./engine/rowByIndex");
+const safeStringify_1 = require("./utils/safeStringify");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
-const elementTracker_1 = require("./utils/elementTracker");
-const loadingWait_1 = require("./utils/loadingWait");
 const pageIndex_1 = require("./utils/pageIndex");
 const smartRowInternals_1 = require("./utils/smartRowInternals");
 const locatorDescription_1 = require("./utils/locatorDescription");
-// Helper to safely serialize objects containing functions for logging
-const safeStringify = (obj) => {
-    try {
-        return JSON.stringify(obj, (_key, value) => {
-            if (typeof value === 'function') {
-                return '[Function]';
-            }
-            return value;
-        });
-    }
-    catch (e) {
-        return '[unserializable]';
-    }
-};
 /**
  * Main hook to interact with a table.
  */
@@ -238,6 +224,11 @@ const useTable = (rootLocator, configOptions = {}) => {
         }
         return didAdvance;
     };
+    const sortingEnv = () => ({
+        config,
+        getPage: () => rootLocator.page(),
+        getContext: () => (Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell })),
+    });
     const result = {
         get currentPageIndex() { return tableState.currentPageIndex; },
         set currentPageIndex(v) {
@@ -326,133 +317,24 @@ const useTable = (rootLocator, configOptions = {}) => {
             return resolve(config.headerSelector, rootLocator).nth(idx);
         },
         countRows: async (filters, options) => {
-            var _a, _b, _c, _d;
-            var _e;
             if (tableState.empty)
                 return 0;
             await _autoInit();
-            const filtersRecord = (filters !== null && filters !== void 0 ? filters : {});
-            const hasFilters = Object.keys(filtersRecord).length > 0;
-            const effectiveMaxPages = (_e = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _e !== void 0 ? _e : config.maxPages;
-            const pag = config.strategies.pagination;
-            const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
-            const domFilters = {};
-            const overrideFilters = {};
-            const syntheticFilters = {};
-            if (hasFilters) {
-                for (const [key, value] of Object.entries(filtersRecord)) {
-                    if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[key]) {
-                        syntheticFilters[key] = value;
-                    }
-                    else if ((_c = (_b = config.columnOverrides) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.read) {
-                        overrideFilters[key] = value;
-                    }
-                    else {
-                        domFilters[key] = value;
-                    }
-                }
-            }
-            const hasPostFilters = Object.keys(overrideFilters).length > 0 || Object.keys(syntheticFilters).length > 0;
-            const resolveRows = () => {
-                var _a;
-                let rows = resolve(config.rowSelector, rootLocator);
-                if (Object.keys(domFilters).length > 0) {
-                    const map = tableMapper.getMapSync();
-                    if (!map)
-                        throw new Error('Initialization Error: Table map not available. Call "await table.init()" first.');
-                    rows = filterEngine.applyFilters(rows, domFilters, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, rootLocator.page(), rootLocator);
-                }
-                return rows;
-            };
-            const countPostFilterMatches = async (candidates, indices) => {
-                var _a;
-                if (!hasPostFilters)
-                    return indices.length;
-                const map = tableMapper.getMapSync();
-                if (!map)
-                    throw new Error('Initialization Error: Table map not available. Call "await table.init()" first.');
-                const exact = (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false;
-                const hasOverrides = Object.keys(overrideFilters).length > 0;
-                const hasSynthetics = Object.keys(syntheticFilters).length > 0;
-                let count = 0;
-                for (const idx of indices) {
-                    const row = candidates[idx];
-                    if (hasOverrides && !await rowFinder.matchesOverrideFilters(row, overrideFilters, map, exact))
-                        continue;
-                    if (hasSynthetics && !await rowFinder.matchesSyntheticFilters(row, syntheticFilters, map, exact))
-                        continue;
-                    count++;
-                }
-                return count;
-            };
-            // Wait for table to finish loading before counting
-            const isTableLoading = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.isTableLoading;
-            if (isTableLoading) {
-                const ctx = createStrategyContext();
-                await (0, loadingWait_1.waitWhileTableLoading)(config, ctx, rootLocator.page(), 'countRows');
-            }
-            if (!hasPagination) {
-                log(`countRows: counting rows in current viewport (no pagination)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
-                if (!hasPostFilters)
-                    return resolveRows().count();
-                const all = await resolveRows().all();
-                return countPostFilterMatches(all, all.map((_, i) => i));
-            }
-            log(`countRows: paginating up to ${effectiveMaxPages} page(s)${hasFilters ? ` filters=${safeStringify(filtersRecord)}` : ''}`);
-            const tracker = new elementTracker_1.ElementTracker('countRows');
-            let total = 0;
-            let pagesScanned = 1;
-            let paginationError;
-            try {
-                const scanned = await (0, scanPages_1.scanPages)({
-                    advancePage: _advancePage,
-                    getCurrentPageIndex: () => tableState.currentPageIndex,
-                    config,
-                    waitForReady: async () => {
-                        if (!isTableLoading)
-                            return;
-                        const ctx = createStrategyContext();
-                        await (0, loadingWait_1.waitWhileTableLoading)(config, ctx, rootLocator.page(), 'countRows');
-                    },
-                }, async ({ pagesScanned: pageNum }) => {
-                    const rowLocators = resolveRows();
-                    const newIndices = await tracker.getUnseenIndices(rowLocators);
-                    const candidates = await rowLocators.all();
-                    const matched = await countPostFilterMatches(candidates, newIndices);
-                    total += matched;
-                    log(`countRows: page ${pageNum} — ${matched} row(s) (running total: ${total})`);
-                    return 'continue';
-                }, {
-                    maxPages: effectiveMaxPages,
-                    useBulk: false,
-                    label: 'countRows',
-                    finalScanOnEof: true,
-                });
-                pagesScanned = scanned.pagesScanned;
-            }
-            catch (e) {
-                paginationError = e;
-                throw e;
-            }
-            finally {
-                await tracker.cleanup(rootLocator.page());
-                // Always restore page 1, even if pagination threw mid-count (#348), so the table
-                // stays usable for callers that catch the error. If reset() itself fails, only let
-                // it surface when pagination succeeded — otherwise preserve the original error.
-                log(`countRows: ${total} total row(s) across ${pagesScanned} page(s) — resetting`);
-                try {
-                    await result.reset();
-                }
-                catch (resetError) {
-                    if (paginationError === undefined)
-                        throw resetError;
-                    (0, debugUtils_1.logDebug)(config, 'error', 'countRows: reset() failed after pagination error', resetError);
-                }
-            }
-            return total;
+            return (0, countRows_1.countRows)({
+                config,
+                rootLocator,
+                getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                tableMapper,
+                filterEngine,
+                rowFinder,
+                advancePage: _advancePage,
+                getCurrentPageIndex: () => tableState.currentPageIndex,
+                getContext: () => createStrategyContext(),
+                reset: () => result.reset(),
+            }, filters, options);
         },
         mapColumn: async (columnName, options = {}) => {
-            log(`mapColumn: column="${columnName}" options=${safeStringify(options)}`);
+            log(`mapColumn: column="${columnName}" options=${(0, safeStringify_1.safeStringify)(options)}`);
             await _autoInit();
             const map = await tableMapper.getMap();
             if (!map.has(columnName))
@@ -477,7 +359,7 @@ const useTable = (rootLocator, configOptions = {}) => {
          * Iterates over rows and extracts the value of a single column as strings.
          */
         getColumnValues: async (columnName, options = {}) => {
-            log(`getColumnValues: column="${columnName}" options=${safeStringify(options)}`);
+            log(`getColumnValues: column="${columnName}" options=${(0, safeStringify_1.safeStringify)(options)}`);
             const values = await result.mapColumn(columnName, options);
             return values.map(v => String(v));
         },
@@ -505,7 +387,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             log("Table revalidated.");
         },
         getRow: (filters, options = { exact: false }) => {
-            log(`getRow: filters=${safeStringify(filters)} exact=${options.exact}`);
+            log(`getRow: filters=${(0, safeStringify_1.safeStringify)(filters)} exact=${options.exact}`);
             const syntheticKeys = Object.keys(filters).filter(k => { var _a; return (_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[k]; });
             if (syntheticKeys.length > 0) {
                 throw new Error(`getRow() cannot filter by synthetic column(s): ${syntheticKeys.join(', ')}. ` +
@@ -533,67 +415,23 @@ const useTable = (rootLocator, configOptions = {}) => {
             return _makeSmart(rowLocator, map, index, undefined, undefined, undefined, true);
         },
         findRowByIndex: async (index, options) => {
-            var _a, _b;
-            log(`findRowByIndex: index=${index} options=${safeStringify(options)}`);
             await _autoInit();
-            const map = tableMapper.getMapSync();
-            const resolveRI = config.strategies.resolveRowIndex;
-            const viewport = config.strategies.viewport;
-            // Identifying a row by its logical index requires a resolveRowIndex strategy. Without one
-            // the library can only offer render-window-relative getRowByIndex, or filter-based findRow.
-            if (!resolveRI) {
-                throw new Error(`findRowByIndex(${index}) requires a strategies.resolveRowIndex to identify rows by their logical index. ` +
-                    `Configure one (e.g. read the grid's row-index attribute), or use getRowByIndex() (current render window) / findRow(filters).`);
-            }
-            let foundSelector;
-            // The currently-mounted row whose logical index === index, if any.
-            const findMounted = async () => {
-                const rows = await resolve(config.rowSelector, rootLocator).all();
-                for (const r of rows) {
-                    const result = await resolveRI(r);
-                    if (result === undefined)
-                        continue;
-                    const normalized = (0, rowResolution_1.normalizeRowIndexResult)(result);
-                    if (normalized.index === index) {
-                        foundSelector = normalized.selector;
-                        return r;
-                    }
-                }
-                return null;
-            };
-            // 1. Already mounted (no navigation needed)?
-            let loc = await findMounted();
-            // 2. Fast path: jump straight to it via the viewport's random-access scroll.
-            if (!loc && (viewport === null || viewport === void 0 ? void 0 : viewport.scrollToRow)) {
-                log(`findRowByIndex: scrolling to row ${index}`);
-                await viewport.scrollToRow(createStrategyContext(), index);
-                loc = await findMounted();
-            }
-            // 3. Fallback: advance pages (on infinite-scroll tables, a "page" is a scroll step) until
-            //    the row is reached. Bounded by maxPages so an unreachable index can't loop forever.
-            if (!loc && config.strategies.pagination) {
-                const effectiveMaxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
-                let pagesScanned = 1;
-                while (!loc && pagesScanned < effectiveMaxPages) {
-                    if (!await _advancePage(false))
-                        break;
-                    pagesScanned++;
-                    loc = await findMounted();
-                }
-            }
-            if (!loc) {
-                throw new Error(`findRowByIndex(${index}): could not reach row ${index}. ` +
-                    `Ensure a viewport.scrollToRow or pagination can bring it into view (searched up to maxPages=${(_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages}).`);
-            }
-            await (0, debugUtils_1.debugDelay)(config, 'findRow');
-            return _makeSmart(loc, map, index, tableState.currentPageIndex, undefined, foundSelector);
+            return (0, rowByIndex_1.findRowByIndex)({
+                config,
+                getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                getMap: () => tableMapper.getMapSync(),
+                advancePage: _advancePage,
+                getCurrentPageIndex: () => tableState.currentPageIndex,
+                getContext: () => createStrategyContext(),
+                makeSmartRow: (loc, map, idx, pageIdx, sel) => _makeSmart(loc, map, idx, pageIdx, undefined, sel),
+            }, index, options);
         },
         findRow: async (filters, options) => {
-            log(`findRow: filters=${safeStringify(filters)} options=${safeStringify(options)}`);
+            log(`findRow: filters=${(0, safeStringify_1.safeStringify)(filters)} options=${(0, safeStringify_1.safeStringify)(options)}`);
             return rowFinder.findRow(filters, options);
         },
         findRows: async (filters, options) => {
-            log(`findRows: filters=${safeStringify(filters !== null && filters !== void 0 ? filters : {})} options=${safeStringify(options)}`);
+            log(`findRows: filters=${(0, safeStringify_1.safeStringify)(filters !== null && filters !== void 0 ? filters : {})} options=${(0, safeStringify_1.safeStringify)(options)}`);
             return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
         },
         isInitialized: () => {
@@ -606,49 +444,13 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         sorting: {
             apply: async (columnName, direction) => {
-                var _a, _b;
-                var _c, _d, _e, _f;
                 await _autoInit();
-                if (!config.strategies.sorting)
-                    throw new Error('No sorting strategy has been configured.');
-                log(`Applying sort for column "${columnName}" (${direction})`);
-                const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
-                const maxRetries = 3;
-                for (let i = 0; i < maxRetries; i++) {
-                    const currentState = await config.strategies.sorting.getSortState({ columnName, context });
-                    if (currentState === direction) {
-                        log(`Sort for "${columnName}" is already "${direction}".`);
-                        return;
-                    }
-                    await config.strategies.sorting.doSort({ columnName, direction, context });
-                    if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        const timeout = (_d = (_c = config.strategies.loading.sortStabilizationTimeout) !== null && _c !== void 0 ? _c : config.strategies.loading.loadingTimeout) !== null && _d !== void 0 ? _d : 10000;
-                        const poll = (_e = config.strategies.loading.sortStabilizationPollInterval) !== null && _e !== void 0 ? _e : 100;
-                        await (0, loadingWait_1.waitWhileTableLoading)(config, context, rootLocator.page(), 'sorting.apply', {
-                            timeout,
-                            pollInterval: poll,
-                        });
-                    }
-                    else {
-                        const fallback = (_f = (_b = config.strategies.loading) === null || _b === void 0 ? void 0 : _b.sortStabilizationFallbackDelay) !== null && _f !== void 0 ? _f : 200;
-                        await rootLocator.page().waitForTimeout(fallback);
-                    }
-                    await (0, debugUtils_1.debugDelay)(config, 'default');
-                    const newState = await config.strategies.sorting.getSortState({ columnName, context });
-                    if (newState === direction) {
-                        log(`Successfully sorted "${columnName}" to "${direction}".`);
-                        return;
-                    }
-                }
-                throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${maxRetries} attempts.`);
+                return (0, sorting_1.applySort)(sortingEnv(), columnName, direction);
             },
             getState: async (columnName) => {
                 log(`sorting.getState: column="${columnName}"`);
                 await _autoInit();
-                if (!config.strategies.sorting)
-                    throw new Error('No sorting strategy has been configured.');
-                const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
-                return config.strategies.sorting.getSortState({ columnName, context });
+                return (0, sorting_1.getSortState)(sortingEnv(), columnName);
             }
         },
         // ─── Shared async row iterator ───────────────────────────────────────────
@@ -716,7 +518,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         // ─── Row iteration (delegated to engine/tableIteration) ──────────────────
         forEach: async (callback, options = {}) => {
-            log(`forEach: options=${safeStringify(options)}`);
+            log(`forEach: options=${(0, safeStringify_1.safeStringify)(options)}`);
             await _autoInit();
             await (0, tableIteration_1.runForEach)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
@@ -731,7 +533,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             }, callback, options);
         },
         map: async (callback, options = {}) => {
-            log(`map: options=${safeStringify(options)}`);
+            log(`map: options=${(0, safeStringify_1.safeStringify)(options)}`);
             await _autoInit();
             return (0, tableIteration_1.runMap)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
@@ -746,7 +548,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             }, callback, options);
         },
         toArray: async (callback, options = {}) => {
-            log(`toArray: options=${safeStringify(options)}`);
+            log(`toArray: options=${(0, safeStringify_1.safeStringify)(options)}`);
             const cb = callback !== null && callback !== void 0 ? callback : (({ row }) => row.toJSON());
             try {
                 return await result.map(cb, options);
@@ -756,7 +558,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
         },
         filter: async (predicate, options = {}) => {
-            log(`filter: options=${safeStringify(options)}`);
+            log(`filter: options=${(0, safeStringify_1.safeStringify)(options)}`);
             await _autoInit();
             return (0, tableIteration_1.runFilter)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),

package/dist/utils/safeStringify.d.ts

@@ -0,0 +1,2 @@
+/** JSON.stringify for debug logs: functions become "[Function]" and cycles don't throw. */
+export declare const safeStringify: (obj: any) => string;

package/dist/utils/safeStringify.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStringify = void 0;
+/** JSON.stringify for debug logs: functions become "[Function]" and cycles don't throw. */
+const safeStringify = (obj) => {
+    try {
+        return JSON.stringify(obj, (_key, value) => {
+            if (typeof value === 'function') {
+                return '[Function]';
+            }
+            return value;
+        });
+    }
+    catch (e) {
+        return '[unserializable]';
+    }
+};
+exports.safeStringify = safeStringify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.25.0-next.3dfcc94",
+  "version": "6.25.0-next.49ce2de",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",