@rickcedwhat/playwright-smart-table 6.11.0 → 6.13.0

package/dist/useTable.js

@@ -31,6 +31,20 @@ const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
 const elementTracker_1 = require("./utils/elementTracker");
 const navigationBarrier_1 = require("./utils/navigationBarrier");
+// 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.
  */
@@ -182,6 +196,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         if (pagesJumped > 0) {
             tableState.currentPageIndex += pagesJumped;
             log(`_advancePage: ${primitive} advanced ${pagesJumped} page(s) — now at page ${tableState.currentPageIndex}`);
+            await (0, debugUtils_1.debugDelay)(config, 'pagination');
         }
         else {
             log(`_advancePage: ${primitive} returned false — end of data`);
@@ -195,6 +210,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             var _a;
             if (tableMapper.isInitialized())
                 return result;
+            if (config.strategies.sorting)
+                (0, validation_1.validateSortingStrategy)(config.strategies.sorting);
+            if (config.strategies.fill)
+                (0, validation_1.validateFillStrategy)(config.strategies.fill);
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
             const map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
@@ -220,6 +239,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             return result;
         },
         scrollToColumn: async (columnName) => {
+            log(`scrollToColumn: column="${columnName}"`);
             const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
@@ -229,10 +249,12 @@ const useTable = (rootLocator, configOptions = {}) => {
             await headerCell.scrollIntoViewIfNeeded();
         },
         getHeaders: async () => {
+            log("getHeaders: fetching available columns");
             const map = await tableMapper.getMap();
             return Array.from(map.keys());
         },
         getHeaderCell: async (columnName) => {
+            log(`getHeaderCell: column="${columnName}"`);
             const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
@@ -241,10 +263,37 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         countRows: async () => {
             await _autoInit();
-            const allRows = resolve(config.rowSelector, rootLocator);
-            return allRows.count();
+            const pag = config.strategies.pagination;
+            const hasPagination = config.maxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
+            if (!hasPagination) {
+                log("countRows: counting rows in current viewport (no pagination)");
+                return resolve(config.rowSelector, rootLocator).count();
+            }
+            log(`countRows: paginating up to ${config.maxPages} page(s)`);
+            const tracker = new elementTracker_1.ElementTracker('countRows');
+            let total = 0;
+            let pagesScanned = 1;
+            try {
+                while (true) {
+                    const newIndices = await tracker.getUnseenIndices(resolve(config.rowSelector, rootLocator));
+                    total += newIndices.length;
+                    log(`countRows: page ${pagesScanned} — ${newIndices.length} row(s) (running total: ${total})`);
+                    if (pagesScanned >= config.maxPages)
+                        break;
+                    if (!await _advancePage(false))
+                        break;
+                    pagesScanned++;
+                }
+            }
+            finally {
+                await tracker.cleanup(rootLocator.page());
+            }
+            log(`countRows: ${total} total row(s) across ${pagesScanned} page(s) — resetting`);
+            await result.reset();
+            return total;
         },
         mapColumn: async (columnName, options = {}) => {
+            log(`mapColumn: column="${columnName}" options=${safeStringify(options)}`);
             await _autoInit();
             const map = await tableMapper.getMap();
             if (!map.has(columnName))
@@ -262,6 +311,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             }, options);
         },
         getColumnValues: async (columnName, options = {}) => {
+            log(`getColumnValues: column="${columnName}" options=${safeStringify(options)}`);
             const values = await result.mapColumn(columnName, options);
             return values.map(v => String(v));
         },
@@ -288,15 +338,17 @@ const useTable = (rootLocator, configOptions = {}) => {
             log("Table revalidated.");
         },
         getRow: (filters, options = { exact: false }) => {
+            log(`getRow: filters=${safeStringify(filters)} exact=${options.exact}`);
             const map = tableMapper.getMapSync();
             if (!map)
                 throw new Error('Initialization Error: You attempted to access a row before the table structure was mapped. Please call "await table.init()" once before using synchronous row access.');
             const allRows = resolve(config.rowSelector, rootLocator);
             const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page(), rootLocator);
             const rowLocator = matchedRows.first();
-            return _makeSmart(rowLocator, map, 0); // fallback index 0
+            return _makeSmart(rowLocator, map, undefined); // sync path cannot compute real index
         },
         getRowByIndex: (index) => {
+            log(`getRowByIndex: index=${index}`);
             const map = tableMapper.getMapSync();
             if (!map)
                 throw new Error('Initialization Error: You attempted to access a row before the table structure was mapped. Please call "await table.init()" once before using synchronous row access.');
@@ -304,13 +356,17 @@ const useTable = (rootLocator, configOptions = {}) => {
             return _makeSmart(rowLocator, map, index);
         },
         findRow: async (filters, options) => {
+            log(`findRow: filters=${safeStringify(filters)} options=${safeStringify(options)}`);
             return rowFinder.findRow(filters, options);
         },
         findRows: async (filters, options) => {
+            log(`findRows: filters=${safeStringify(filters !== null && filters !== void 0 ? filters : {})} options=${safeStringify(options)}`);
             return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
         },
         isInitialized: () => {
-            return tableMapper.isInitialized();
+            const initialized = tableMapper.isInitialized();
+            log(`isInitialized: ${initialized}`);
+            return initialized;
         },
         sorting: {
             apply: async (columnName, direction) => {
@@ -329,7 +385,10 @@ const useTable = (rootLocator, configOptions = {}) => {
                     }
                     await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        await config.strategies.loading.isTableLoading(context);
+                        const deadline = Date.now() + 10000;
+                        while (Date.now() < deadline && await config.strategies.loading.isTableLoading(context)) {
+                            await rootLocator.page().waitForTimeout(100);
+                        }
                     }
                     else {
                         await rootLocator.page().waitForTimeout(200);
@@ -344,6 +403,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${maxRetries} attempts.`);
             },
             getState: async (columnName) => {
+                log(`sorting.getState: column="${columnName}"`);
                 await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
@@ -359,6 +419,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 const effectiveMaxPages = config.maxPages;
                 const tracker = new elementTracker_1.ElementTracker('iterator');
                 const useBulk = false; // iterator has no options; default goNext
+                log(`iterator: starting (maxPages=${effectiveMaxPages})`);
                 try {
                     let rowIndex = 0;
                     let pagesScanned = 1;
@@ -368,7 +429,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                         const pageRows = yield __await(rowLocators.all());
                         const barrier = new navigationBarrier_1.NavigationBarrier(newIndices.length);
                         for (const idx of newIndices) {
-                            yield yield __await({ row: _makeSmart(pageRows[idx], map, rowIndex, pagesScanned - 1, barrier), index: rowIndex, rowIndex });
+                            yield yield __await({ row: _makeSmart(pageRows[idx], map, rowIndex, tableState.currentPageIndex, barrier), index: rowIndex, rowIndex, pageIndex: tableState.currentPageIndex });
                             rowIndex++;
                         }
                         if (pagesScanned >= effectiveMaxPages)
@@ -385,6 +446,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         // ─── Row iteration (delegated to engine/tableIteration) ──────────────────
         forEach: async (callback, options = {}) => {
+            log(`forEach: options=${safeStringify(options)}`);
             await _autoInit();
             await (0, tableIteration_1.runForEach)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
@@ -394,9 +456,11 @@ const useTable = (rootLocator, configOptions = {}) => {
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),
+                getCurrentPageIndex: () => tableState.currentPageIndex,
             }, callback, options);
         },
         map: async (callback, options = {}) => {
+            log(`map: options=${safeStringify(options)}`);
             await _autoInit();
             return (0, tableIteration_1.runMap)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
@@ -406,9 +470,11 @@ const useTable = (rootLocator, configOptions = {}) => {
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),
+                getCurrentPageIndex: () => tableState.currentPageIndex,
             }, callback, options);
         },
         filter: async (predicate, options = {}) => {
+            log(`filter: options=${safeStringify(options)}`);
             await _autoInit();
             return (0, tableIteration_1.runFilter)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
@@ -418,9 +484,11 @@ const useTable = (rootLocator, configOptions = {}) => {
                 createSmartRowArray: smartRowArray_1.createSmartRowArray,
                 config,
                 getPage: () => rootLocator.page(),
+                getCurrentPageIndex: () => tableState.currentPageIndex,
             }, predicate, options);
         },
         generateConfig: async () => {
+            log("Generating table config prompt...");
             const html = await _getCleanHtml(rootLocator);
             const separator = "=".repeat(50);
             const content = `\n${separator} \n🤖 COPY INTO GEMINI / ChatGPT 🤖\n${separator} \nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()} \nGenerate config for: \n\`\`\`html\n${html.substring(0, 10000)} ...\n\`\`\`\n${separator}\n`;

package/dist/utils/elementTracker.d.ts

@@ -2,6 +2,16 @@ import { Locator } from '@playwright/test';
 export declare class ElementTracker {
     readonly id: string;
     constructor(prefix?: string);
+    /**
+     * Returns indices of newly seen or recycled elements without marking them as seen.
+     * Call {@link commitIndices} to persist the subset you intend to process.
+     */
+    peekUnseenIndices(locators: Locator): Promise<number[]>;
+    /**
+     * Marks the given indices as seen. Only call this for the subset you intend to process;
+     * uncommitted indices will be returned again by the next peek/getUnseenIndices call.
+     */
+    commitIndices(locators: Locator, indices: number[]): Promise<void>;
     /**
      * Finds the indices of newly seen elements in the browser, storing their text signature
      * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and

package/dist/utils/elementTracker.js

@@ -6,11 +6,10 @@ class ElementTracker {
         this.id = `__smartTable_${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
     }
     /**
-     * Finds the indices of newly seen elements in the browser, storing their text signature
-     * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
-     * virtualized DOMs (by text signature if nodes are recycled).
+     * Returns indices of newly seen or recycled elements without marking them as seen.
+     * Call {@link commitIndices} to persist the subset you intend to process.
      */
-    async getUnseenIndices(locators) {
+    async peekUnseenIndices(locators) {
         return await locators.evaluateAll((elements, trackerId) => {
             const win = window;
             if (!win[trackerId]) {
@@ -19,17 +18,42 @@ class ElementTracker {
             const seenMap = win[trackerId];
             const newIndices = [];
             elements.forEach((el, index) => {
-                // Determine a lightweight signature for the row (textContent strips HTML, fast)
                 const signature = el.textContent || '';
-                // If it's a new element, OR a recycled element with new data
                 if (seenMap.get(el) !== signature) {
-                    seenMap.set(el, signature);
                     newIndices.push(index);
                 }
             });
             return newIndices;
         }, this.id);
     }
+    /**
+     * Marks the given indices as seen. Only call this for the subset you intend to process;
+     * uncommitted indices will be returned again by the next peek/getUnseenIndices call.
+     */
+    async commitIndices(locators, indices) {
+        await locators.evaluateAll((elements, [trackerId, indicesToCommit]) => {
+            const win = window;
+            if (!win[trackerId]) {
+                win[trackerId] = new WeakMap();
+            }
+            const seenMap = win[trackerId];
+            for (const index of indicesToCommit) {
+                const el = elements[index];
+                if (el)
+                    seenMap.set(el, el.textContent || '');
+            }
+        }, [this.id, indices]);
+    }
+    /**
+     * Finds the indices of newly seen elements in the browser, storing their text signature
+     * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
+     * virtualized DOMs (by text signature if nodes are recycled).
+     */
+    async getUnseenIndices(locators) {
+        const indices = await this.peekUnseenIndices(locators);
+        await this.commitIndices(locators, indices);
+        return indices;
+    }
     /**
      * Cleans up the tracking map from the browser window object.
      */

package/dist/utils/navigationBarrier.d.ts

@@ -7,6 +7,8 @@ export declare class NavigationBarrier {
     private finishedCount;
     private buckets;
     constructor(total: number);
+    /** True when more than one row shares this barrier (scrollToRow would evict peers). */
+    isParallel(): boolean;
     /**
      * Synchronize all active rows at a specific column index.
      * The last row to arrive will trigger the `moveAction`.

package/dist/utils/navigationBarrier.js

@@ -12,6 +12,10 @@ class NavigationBarrier {
         this.buckets = new Map();
         this.total = total;
     }
+    /** True when more than one row shares this barrier (scrollToRow would evict peers). */
+    isParallel() {
+        return this.total > 1;
+    }
     /**
      * Synchronize all active rows at a specific column index.
      * The last row to arrive will trigger the `moveAction`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.11.0",
+  "version": "6.13.0",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -28,19 +28,19 @@
     "docs:build:all": "vitepress build docs",
     "docs:verify-links": "node scripts/verify-vitepress-links.mjs",
     "embed-version": "node scripts/embed-version.mjs",
-    "build": "npm run embed-version && npm run generate-types && npm run generate-config-types && npm run generate-docs && npm run generate-all-api-docs && npm run update-all-api-signatures && tsc",
-    "prepublishOnly": "npm run build",
+    "build": "pnpm run embed-version && pnpm run generate-types && pnpm run generate-config-types && pnpm run generate-docs && pnpm run generate-all-api-docs && pnpm run update-all-api-signatures && tsc",
+    "prepublishOnly": "pnpm run build",
     "clean-port": "lsof -ti:3000 | xargs kill -9 || true",
-    "pretest": "npm run clean-port",
-    "posttest": "npm run clean-port",
-    "test": "npm run test:unit && npx playwright test",
+    "pretest": "pnpm run clean-port",
+    "posttest": "pnpm run clean-port",
+    "test": "pnpm run test:unit && pnpm exec playwright test",
     "test:unit": "vitest run --coverage --reporter=verbose --reporter=html",
     "test:unit:ui": "vitest --ui",
-    "test:mutate": "npx stryker run",
-    "pretest:e2e": "npm run clean-port",
-    "posttest:e2e": "npm run clean-port",
-    "test:e2e": "npx playwright test",
-    "test:playground": "npx playwright test --config tests-external/playground/playwright.config.ts 2>&1 | tee \"tests-external/playground/logs/run-$(date +%Y%m%d-%H%M%S).log\"",
+    "test:mutate": "pnpm exec stryker run",
+    "pretest:e2e": "pnpm run clean-port",
+    "posttest:e2e": "pnpm run clean-port",
+    "test:e2e": "pnpm exec playwright test",
+    "test:playground": "pnpm exec playwright test --config tests-external/playground/playwright.config.ts 2>&1 | tee \"tests-external/playground/logs/run-$(date +%Y%m%d-%H%M%S).log\"",
     "dev:playground": "cd playground && npm run dev",
     "dev:mui": "cd tests/apps/mui-datagrid && npm run dev",
     "prepare": "husky"
@@ -87,17 +87,15 @@
     "@stryker-mutator/core": "^9.6.0",
     "@stryker-mutator/vitest-runner": "^9.6.0",
     "@types/node": "^25.5.2",
-    "@vitest/coverage-v8": "^4.1.0",
-    "@vitest/ui": "^4.1.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
     "happy-dom": "^20.8.3",
-    "@commitlint/cli": "^19.7.1",
-    "@commitlint/config-conventional": "^19.7.1",
+    "@commitlint/cli": "^21.0.0",
+    "@commitlint/config-conventional": "^21.0.0",
     "husky": "^9.1.7",
     "typescript": "^6.0.2",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.0"
+    "vitest": "^3.2.4"
   },
-  "dependencies": {
-    "@scarf/scarf": "^1.4.0"
-  }
+  "packageManager": "pnpm@10.33.2"
 }

package/dist/presets/glide/columns.d.ts

@@ -1,14 +0,0 @@
-import { StrategyContext } from '../../types';
-/**
- * Primitive navigation functions for Glide Data Grid.
- * These define HOW to move, not WHEN to move.
- * The orchestration logic lives in _navigateToCell.
- */
-export declare const glideGoUp: (context: StrategyContext) => Promise<void>;
-export declare const glideGoDown: (context: StrategyContext) => Promise<void>;
-export declare const glideGoLeft: (context: StrategyContext) => Promise<void>;
-export declare const glideGoRight: (context: StrategyContext) => Promise<void>;
-/** Coarse `scrollLeft` toward `columnIndex`; `goLeft`/`goRight` correct the remainder. */
-export declare const glideSeekColumnIndex: (context: StrategyContext, columnIndex: number) => Promise<void>;
-/** `scrollLeft = 0` so low `aria-colindex` cells exist again (see smartRow for optional `Home`). */
-export declare const glideSnapFirstColumnIntoView: (context: StrategyContext) => Promise<void>;

package/dist/presets/glide/columns.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.glideSnapFirstColumnIntoView = exports.glideSeekColumnIndex = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
-/**
- * Primitive navigation functions for Glide Data Grid.
- * These define HOW to move, not WHEN to move.
- * The orchestration logic lives in _navigateToCell.
- */
-const glideGoUp = async (context) => {
-    await context.page.keyboard.press('ArrowUp');
-};
-exports.glideGoUp = glideGoUp;
-const glideGoDown = async (context) => {
-    await context.page.keyboard.press('ArrowDown');
-};
-exports.glideGoDown = glideGoDown;
-// Horizontal: use page `.dvn-scroller` (canvas root is not its ancestor). Virtualized rows expose
-// a small window of `td[aria-colindex]` that shifts with scrollLeft.
-const nudgePageScroller = async (page, delta) => {
-    const scroller = page.locator('.dvn-scroller').first();
-    await scroller.evaluate((el, d) => {
-        el.scrollLeft += d;
-    }, delta);
-};
-const glideGoLeft = async (context) => {
-    await nudgePageScroller(context.page, -400);
-};
-exports.glideGoLeft = glideGoLeft;
-const glideGoRight = async (context) => {
-    await nudgePageScroller(context.page, 400);
-};
-exports.glideGoRight = glideGoRight;
-/** Coarse `scrollLeft` toward `columnIndex`; `goLeft`/`goRight` correct the remainder. */
-const glideSeekColumnIndex = async (context, columnIndex) => {
-    const { page } = context;
-    const scroller = page.locator('.dvn-scroller').first();
-    await scroller.evaluate((el, colIdx) => {
-        const max = Math.max(0, el.scrollWidth - el.clientWidth);
-        const ratio = Math.min(1, Math.max(0, (colIdx + 0.5) / 64));
-        el.scrollLeft = Math.floor(ratio * max);
-    }, columnIndex);
-    await page.waitForTimeout(100);
-};
-exports.glideSeekColumnIndex = glideSeekColumnIndex;
-/** `scrollLeft = 0` so low `aria-colindex` cells exist again (see smartRow for optional `Home`). */
-const glideSnapFirstColumnIntoView = async (context) => {
-    const { page } = context;
-    await page.locator('.dvn-scroller').first().evaluate((el) => {
-        el.scrollLeft = 0;
-    });
-    await page.waitForTimeout(150);
-};
-exports.glideSnapFirstColumnIntoView = glideSnapFirstColumnIntoView;