@rickcedwhat/playwright-smart-table 6.8.2 → 6.10.0

package/dist/types.d.ts

@@ -28,10 +28,13 @@ export type FilterValue = string | RegExp | number | ((cell: Locator) => Locator
  */
 export type GetCellLocatorFn = (args: {
     row: Locator;
+    /** The root locator passed to useTable(). Useful for re-querying stale row locators. */
+    root: Locator;
     columnName: string;
     columnIndex: number;
     rowIndex?: number;
     page: Page;
+    config: FinalTableConfig<any>;
 }) => Locator;
 /**
  * Hook called before each cell value is read in toJSON (and columnOverrides.read).
@@ -68,6 +71,89 @@ export type GetActiveCellFn = (args: TableContext) => Promise<{
     columnName?: string;
     locator: Locator;
 } | null>;
+/**
+ * Viewport oracle strategies for virtualized tables.
+ *
+ * These tell the library *what is currently in the DOM* rather than *how to move*.
+ * When present, the cell-reading engine uses them to jump directly to a target
+ * row/column instead of stepping blindly with navigation primitives.
+ *
+ * This is the primary fix for the 2D scroll hazard: scrolling right to bring a
+ * column into view can knock rows out of the vertical viewport (and vice versa).
+ * With `getVisibleRowRange` the engine detects this and calls `scrollToRow` to
+ * restore the row before reading — eliminating the hazard without polling loops.
+ *
+ * All members are optional. Supply whichever the underlying grid exposes:
+ * - Range oracles alone enable hazard detection with graceful fallback to navigation primitives.
+ * - Scroll primitives alone enable direct jumps without range awareness.
+ * - Both together give the most reliable, fastest path.
+ *
+ * @example
+ * // MUI DataGrid via apiRef
+ * strategies: {
+ *   viewport: {
+ *     getVisibleRowRange: async ({ root }) =>
+ *       root.evaluate(el => {
+ *         const api = (el as any).__muiDataGrid__;
+ *         return { first: api.getFirstVisibleRow(), last: api.getLastVisibleRow() };
+ *       }),
+ *     scrollToRow: async ({ root }, rowIndex) =>
+ *       root.evaluate((el, idx) =>
+ *         (el as any).__muiDataGrid__.scrollToIndexes({ rowIndex: idx }), rowIndex),
+ *     scrollToColumn: async ({ root }, colIndex) =>
+ *       root.evaluate((el, idx) =>
+ *         (el as any).__muiDataGrid__.scrollToIndexes({ colIndex: idx }), colIndex),
+ *   }
+ * }
+ *
+ * @example
+ * // aria-rowindex / aria-colindex DOM fallback (works without internal API access)
+ * strategies: {
+ *   viewport: {
+ *     getVisibleRowRange: async ({ root }) =>
+ *       root.evaluate(el => {
+ *         const rows = [...el.querySelectorAll('[role="row"][aria-rowindex]')];
+ *         const idxs = rows.map(r => Number(r.getAttribute('aria-rowindex')) - 1);
+ *         return { first: Math.min(...idxs), last: Math.max(...idxs) };
+ *       }),
+ *   }
+ * }
+ */
+export interface ViewportStrategy {
+    /**
+     * Returns the 0-based index range of rows currently rendered in the DOM.
+     * Used to detect when a target row has been scrolled out of view and needs recovery.
+     */
+    getVisibleRowRange?: (context: TableContext) => Promise<{
+        first: number;
+        last: number;
+    }>;
+    /**
+     * Returns the 0-based index range of columns currently rendered in the DOM.
+     * Used to detect when a target column is not yet mounted before reading.
+     */
+    getVisibleColumnRange?: (context: TableContext) => Promise<{
+        first: number;
+        last: number;
+    }>;
+    /**
+     * Scrolls or jumps directly to make a row visible by 0-based index.
+     * Replaces blind goDown()/goUp() step loops for grids that expose a scroll API.
+     */
+    scrollToRow?: (context: TableContext, rowIndex: number) => Promise<void>;
+    /**
+     * Scrolls or jumps directly to make a column visible by 0-based index.
+     * Replaces blind goRight()/goLeft() step loops for grids that expose a scroll API.
+     */
+    scrollToColumn?: (context: TableContext, colIndex: number) => Promise<void>;
+    /**
+     * When true, disables the automatic memoization of getVisibleColumnRange and
+     * getVisibleRowRange results. By default the library caches each range value and
+     * invalidates it after the corresponding scroll call, eliminating redundant DOM
+     * evaluate() round-trips between scrolls.
+     */
+    disableCache?: boolean;
+}
 /**
  * SmartRow - A Playwright Locator with table-aware methods.
  *
@@ -319,6 +405,17 @@ export interface TableStrategies {
      * E.g. after sort/pagination, the engine uses loading.isTableLoading when present.
      */
     loading?: LoadingStrategy;
+    /**
+     * Viewport oracle strategies for 2D virtualized tables (e.g. MUI DataGrid, AG Grid,
+     * Braintrust-style grids where both rows and columns are virtualized simultaneously).
+     *
+     * When present, the cell-reading engine uses these to jump directly to the target
+     * row/column and to detect the 2D scroll hazard (scrolling to reveal a column can
+     * knock rows out of the vertical viewport, and vice versa).
+     *
+     * Completely optional and additive — existing `navigation` primitives remain the fallback.
+     */
+    viewport?: ViewportStrategy;
 }
 export interface TableConfig<T = any> {
     /** Selector for the table headers */
@@ -391,12 +488,6 @@ export type RowIterationMode = 'parallel' | 'sequential' | 'synchronized';
 export type RowIterationOptions = {
     /** Maximum number of pages to iterate. Defaults to config.maxPages. */
     maxPages?: number;
-    /**
-     * @deprecated Use 'concurrency' mode instead.
-     * - parallel: true -> concurrency: 'parallel'
-     * - parallel: false -> concurrency: 'sequential'
-     */
-    parallel?: boolean;
     /**
      * Concurrency strategy for iteration.
      * - 'parallel': Full parallel execution of both navigation and actions.
@@ -493,7 +584,7 @@ export interface TableResult<T = any> extends AsyncIterable<{
      * Call `stop()` in the callback to end iteration early.
      *
      * @param callback - Function receiving { row, rowIndex, stop }
-     * @param options - maxPages, concurrency, dedupe, useBulkPagination (`parallel` is deprecated; use `concurrency`)
+     * @param options - maxPages, concurrency, dedupe, useBulkPagination
      *
      * @example
      * await table.forEach(async ({ row, stop }) => {
@@ -512,7 +603,7 @@ export interface TableResult<T = any> extends AsyncIterable<{
      * > when navigation must stay lock-step) to avoid overlapping interactions.
      *
      * @param callback - Function receiving { row, rowIndex, stop }
-     * @param options - maxPages, concurrency, dedupe, useBulkPagination (`parallel` is deprecated; use `concurrency`)
+     * @param options - maxPages, concurrency, dedupe, useBulkPagination
      *
      * @example
      * // Data extraction — parallel is safe
@@ -534,7 +625,7 @@ export interface TableResult<T = any> extends AsyncIterable<{
      * Execution is sequential by default.
      *
      * @param predicate - Function receiving { row, rowIndex, stop }
-     * @param options - maxPages, concurrency, dedupe, useBulkPagination (`parallel` is deprecated; use `concurrency`)
+     * @param options - maxPages, concurrency, dedupe, useBulkPagination
      *
      * @example
      * const active = await table.filter(async ({ row }) =>

package/dist/useTable.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -56,7 +47,38 @@ const useTable = (rootLocator, configOptions = {}) => {
             isHeaderLoading: loading_1.LoadingStrategies.Headers.stable(200)
         }
     };
-    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: () => __awaiter(void 0, void 0, void 0, function* () { }) }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
+    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: async () => { } }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
+    // Automatically memoize viewport range oracles so user-provided functions are
+    // pure DOM queries with no cache bookkeeping. Invalidated after each scroll call.
+    if (config.strategies.viewport && !config.strategies.viewport.disableCache) {
+        const vp = config.strategies.viewport;
+        let colRangeCache = null;
+        let rowRangeCache = null;
+        config.strategies.viewport = Object.assign(Object.assign({}, vp), { getVisibleColumnRange: vp.getVisibleColumnRange
+                ? async (ctx) => {
+                    if (!colRangeCache)
+                        colRangeCache = await vp.getVisibleColumnRange(ctx);
+                    return colRangeCache;
+                }
+                : undefined, getVisibleRowRange: vp.getVisibleRowRange
+                ? async (ctx) => {
+                    if (!rowRangeCache)
+                        rowRangeCache = await vp.getVisibleRowRange(ctx);
+                    return rowRangeCache;
+                }
+                : undefined, scrollToColumn: vp.scrollToColumn
+                ? async (ctx, colIndex) => {
+                    colRangeCache = null;
+                    rowRangeCache = null;
+                    await vp.scrollToColumn(ctx, colIndex);
+                }
+                : undefined, scrollToRow: vp.scrollToRow
+                ? async (ctx, rowIndex) => {
+                    rowRangeCache = null;
+                    await vp.scrollToRow(ctx, rowIndex);
+                }
+                : undefined });
+    }
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -102,7 +124,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState);
     /** Builds a full TableContext/StrategyContext with getHeaderCell, getHeaders, scrollToColumn. Set after result is created. */
     let createStrategyContext = () => ({ root: rootLocator, config, page: rootLocator.page(), resolve });
-    const _getCleanHtml = (loc) => __awaiter(void 0, void 0, void 0, function* () {
+    const _getCleanHtml = async (loc) => {
         return loc.evaluate((el) => {
             const clone = el.cloneNode(true);
             const removeSelectors = 'script, style, svg, path, circle, rect, noscript, [hidden]';
@@ -123,33 +145,33 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return clone.outerHTML;
         });
-    });
-    const _handlePrompt = (promptName, content) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    const _handlePrompt = async (promptName, content) => {
         let finalPrompt = content;
         finalPrompt += `\n\n👇 Useful TypeScript Definitions 👇\n\`\`\`typescript\n${minimalConfigContext_1.MINIMAL_CONFIG_CONTEXT}\n\`\`\`\n`;
         console.log(`⚠️ Throwing error to display [${promptName}] cleanly...`);
         throw new Error(finalPrompt);
-    });
-    const _autoInit = () => __awaiter(void 0, void 0, void 0, function* () {
-        yield tableMapper.getMap();
-    });
+    };
+    const _autoInit = async () => {
+        await tableMapper.getMap();
+    };
     // Default: goNext (one page). Pass useBulk true to prefer goNextBulk. "How far" uses numeric return when strategy provides it.
-    const _advancePage = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (useBulk = false) {
+    const _advancePage = async (useBulk = false) => {
         const context = createStrategyContext();
         const pagination = config.strategies.pagination;
         let rawResult;
         let primitive;
         if (useBulk && (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk)) {
             primitive = 'goNextBulk';
-            rawResult = yield pagination.goNextBulk(context);
+            rawResult = await pagination.goNextBulk(context);
         }
         else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNext) {
             primitive = 'goNext';
-            rawResult = yield pagination.goNext(context);
+            rawResult = await pagination.goNext(context);
         }
         else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk) {
             primitive = 'goNextBulk (fallback)';
-            rawResult = yield pagination.goNextBulk(context);
+            rawResult = await pagination.goNextBulk(context);
         }
         else {
             log('_advancePage: no pagination primitive available — returning false');
@@ -165,47 +187,47 @@ const useTable = (rootLocator, configOptions = {}) => {
             log(`_advancePage: ${primitive} returned false — end of data`);
         }
         return didAdvance;
-    });
+    };
     const result = {
         get currentPageIndex() { return tableState.currentPageIndex; },
         set currentPageIndex(v) { tableState.currentPageIndex = v; },
-        init: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        init: async (options) => {
             if (tableMapper.isInitialized())
                 return result;
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
-            const map = yield tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
+            const map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
             (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${map.size} columns`, Array.from(map.keys()));
-            yield (0, debugUtils_1.debugDelay)(config, 'default');
+            await (0, debugUtils_1.debugDelay)(config, 'default');
             return result;
-        }),
-        scrollToColumn: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+        },
+        scrollToColumn: async (columnName) => {
+            const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map);
             // Use header cell for scrolling
             const headerCell = resolve(config.headerSelector, rootLocator).nth(idx);
-            yield headerCell.scrollIntoViewIfNeeded();
-        }),
-        getHeaders: () => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+            await headerCell.scrollIntoViewIfNeeded();
+        },
+        getHeaders: async () => {
+            const map = await tableMapper.getMap();
             return Array.from(map.keys());
-        }),
-        getHeaderCell: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+        },
+        getHeaderCell: async (columnName) => {
+            const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map, 'header cell');
             return resolve(config.headerSelector, rootLocator).nth(idx);
-        }),
-        reset: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        reset: async () => {
             var _a;
             log("Resetting table...");
-            yield config.onReset(createStrategyContext());
+            await config.onReset(createStrategyContext());
             if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goToFirst) {
                 log("Auto-navigating to first page...");
-                yield config.strategies.pagination.goToFirst(createStrategyContext());
+                await config.strategies.pagination.goToFirst(createStrategyContext());
             }
             else if (hasPaginationInConfig) {
                 log("No goToFirst strategy configured. Table may not be on page 1.");
@@ -214,13 +236,13 @@ const useTable = (rootLocator, configOptions = {}) => {
             tableState.currentPageIndex = 0;
             tableMapper.clear();
             log("Table reset complete. Calling autoInit to restore state.");
-            yield _autoInit();
-        }),
-        revalidate: () => __awaiter(void 0, void 0, void 0, function* () {
+            await _autoInit();
+        },
+        revalidate: async () => {
             log("Revalidating table structure...");
-            yield tableMapper.remapHeaders();
+            await tableMapper.remapHeaders();
             log("Table revalidated.");
-        }),
+        },
         getRow: (filters, options = { exact: false }) => {
             const map = tableMapper.getMapSync();
             if (!map)
@@ -237,53 +259,53 @@ const useTable = (rootLocator, configOptions = {}) => {
             const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
             return _makeSmart(rowLocator, map, index);
         },
-        findRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+        findRow: async (filters, options) => {
             return rowFinder.findRow(filters, options);
-        }),
-        findRows: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        findRows: async (filters, options) => {
             return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
-        }),
+        },
         isInitialized: () => {
             return tableMapper.isInitialized();
         },
         sorting: {
-            apply: (columnName, direction) => __awaiter(void 0, void 0, void 0, function* () {
+            apply: async (columnName, direction) => {
                 var _a;
-                yield _autoInit();
+                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 = yield config.strategies.sorting.getSortState({ columnName, context });
+                    const currentState = await config.strategies.sorting.getSortState({ columnName, context });
                     if (currentState === direction) {
                         log(`Sort for "${columnName}" is already "${direction}".`);
                         return;
                     }
-                    yield config.strategies.sorting.doSort({ columnName, direction, context });
+                    await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        yield config.strategies.loading.isTableLoading(context);
+                        await config.strategies.loading.isTableLoading(context);
                     }
                     else {
-                        yield rootLocator.page().waitForTimeout(200);
+                        await rootLocator.page().waitForTimeout(200);
                     }
-                    yield (0, debugUtils_1.debugDelay)(config, 'default');
-                    const newState = yield config.strategies.sorting.getSortState({ columnName, context });
+                    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.`);
-            }),
-            getState: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-                yield _autoInit();
+            },
+            getState: async (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 });
-            })
+            }
         },
         // ─── Shared async row iterator ───────────────────────────────────────────
         [Symbol.asyncIterator]() {
@@ -318,9 +340,9 @@ const useTable = (rootLocator, configOptions = {}) => {
             });
         },
         // ─── Row iteration (delegated to engine/tableIteration) ──────────────────
-        forEach: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            yield _autoInit();
-            yield (0, tableIteration_1.runForEach)({
+        forEach: async (callback, options = {}) => {
+            await _autoInit();
+            await (0, tableIteration_1.runForEach)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
                 advancePage: _advancePage,
@@ -329,9 +351,9 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, callback, options);
-        }),
-        map: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            yield _autoInit();
+        },
+        map: async (callback, options = {}) => {
+            await _autoInit();
             return (0, tableIteration_1.runMap)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
@@ -341,9 +363,9 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, callback, options);
-        }),
-        filter: (predicate_1, ...args_1) => __awaiter(void 0, [predicate_1, ...args_1], void 0, function* (predicate, options = {}) {
-            yield _autoInit();
+        },
+        filter: async (predicate, options = {}) => {
+            await _autoInit();
             return (0, tableIteration_1.runFilter)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
@@ -353,17 +375,17 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, predicate, options);
-        }),
-        generateConfig: () => __awaiter(void 0, void 0, void 0, function* () {
-            const html = yield _getCleanHtml(rootLocator);
+        },
+        generateConfig: async () => {
+            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`;
-            yield _handlePrompt('Smart Table Config', content);
-        }),
-        generateConfigPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
+            await _handlePrompt('Smart Table Config', content);
+        },
+        generateConfigPrompt: async () => {
             console.warn('⚠️ [playwright-smart-table] generateConfigPrompt() is deprecated and will be removed in v7.0.0. Please use generateConfig() instead.');
             return result.generateConfig();
-        }),
+        },
     };
     createStrategyContext = () => ({
         root: rootLocator,

package/dist/utils/debugUtils.js

@@ -1,13 +1,4 @@
 "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.getDebugDelay = getDebugDelay;
 exports.debugDelay = debugDelay;
@@ -28,13 +19,11 @@ function getDebugDelay(config, actionType) {
 /**
  * Add debug delay for specific action type
  */
-function debugDelay(config, actionType) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const delay = getDebugDelay(config, actionType);
-        if (delay > 0) {
-            yield new Promise(resolve => setTimeout(resolve, delay));
-        }
-    });
+async function debugDelay(config, actionType) {
+    const delay = getDebugDelay(config, actionType);
+    if (delay > 0) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
 }
 /**
  * Log debug message based on log level

package/dist/utils/elementTracker.js

@@ -1,13 +1,4 @@
 "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.ElementTracker = void 0;
 class ElementTracker {
@@ -19,42 +10,38 @@ class ElementTracker {
      * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
      * virtualized DOMs (by text signature if nodes are recycled).
      */
-    getUnseenIndices(locators) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield locators.evaluateAll((elements, trackerId) => {
-                const win = window;
-                if (!win[trackerId]) {
-                    win[trackerId] = new WeakMap();
+    async getUnseenIndices(locators) {
+        return await locators.evaluateAll((elements, trackerId) => {
+            const win = window;
+            if (!win[trackerId]) {
+                win[trackerId] = new WeakMap();
+            }
+            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);
                 }
-                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);
-        });
+            });
+            return newIndices;
+        }, this.id);
     }
     /**
      * Cleans up the tracking map from the browser window object.
      */
-    cleanup(page) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield page.evaluate((trackerId) => {
-                    delete window[trackerId];
-                }, this.id);
-            }
-            catch (e) {
-                // Ignore context destroyed errors during cleanup
-            }
-        });
+    async cleanup(page) {
+        try {
+            await page.evaluate((trackerId) => {
+                delete window[trackerId];
+            }, this.id);
+        }
+        catch (e) {
+            // Ignore context destroyed errors during cleanup
+        }
     }
 }
 exports.ElementTracker = ElementTracker;

package/dist/utils/mutex.js

@@ -1,13 +1,4 @@
 "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.Mutex = void 0;
 /**
@@ -18,14 +9,12 @@ class Mutex {
     constructor() {
         this.queue = Promise.resolve();
     }
-    run(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const next = this.queue.then(() => __awaiter(this, void 0, void 0, function* () {
-                return yield action();
-            }));
-            this.queue = next.catch(() => { }); // prevent chain breakage
-            return yield next;
+    async run(action) {
+        const next = this.queue.then(async () => {
+            return await action();
         });
+        this.queue = next.catch(() => { }); // prevent chain breakage
+        return await next;
     }
 }
 exports.Mutex = Mutex;