@rickcedwhat/playwright-smart-table 6.9.0 → 6.10.0

package/dist/presets/mui.js

@@ -1,60 +1,47 @@
 "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.muiDataGrid = exports.muiTable = void 0;
 /**
  * Safely wait for MUI pagination to stabilize.
  * Polls for displayed row text changes and waits for loading overlays to disappear.
  */
-function waitForMuiPaginationStabilization(context, displayedRows, oldText) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        let retries = 50; // 5 second timeout for client-side render
-        while (oldText && retries-- > 0 && (yield displayedRows.innerText().catch(() => '')) === oldText) {
-            yield context.page.waitForTimeout(100);
-        }
-        // Standard MUI loading strategy check
-        if ((_a = context.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-            let loadingRetries = 30;
-            while (loadingRetries-- > 0 && (yield context.config.strategies.loading.isTableLoading(context))) {
-                yield context.page.waitForTimeout(100);
-            }
+async function waitForMuiPaginationStabilization(context, displayedRows, oldText) {
+    var _a;
+    let retries = 50; // 5 second timeout for client-side render
+    while (oldText && retries-- > 0 && await displayedRows.innerText().catch(() => '') === oldText) {
+        await context.page.waitForTimeout(100);
+    }
+    // Standard MUI loading strategy check
+    if ((_a = context.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
+        let loadingRetries = 30;
+        while (loadingRetries-- > 0 && await context.config.strategies.loading.isTableLoading(context)) {
+            await context.page.waitForTimeout(100);
         }
-        // DataGrid specific fallback (if not using loading strategy)
-        const overlay = context.root.locator('.MuiDataGrid-overlay');
-        if ((yield overlay.count()) > 0) {
-            let loadingRetries = 30;
-            while (loadingRetries-- > 0 && (yield overlay.isVisible().catch(() => false))) {
-                yield context.page.waitForTimeout(100);
-            }
+    }
+    // DataGrid specific fallback (if not using loading strategy)
+    const overlay = context.root.locator('.MuiDataGrid-overlay');
+    if (await overlay.count() > 0) {
+        let loadingRetries = 30;
+        while (loadingRetries-- > 0 && await overlay.isVisible().catch(() => false)) {
+            await context.page.waitForTimeout(100);
         }
-    });
+    }
 }
 /** safely locate the pagination container related to our table context */
-function getPaginationRoot(context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // 1. If the user initialized useTable on the layout wrapper itself
-        const inside = context.root.locator('.MuiTablePagination-root').first();
-        if ((yield inside.count()) > 0)
-            return inside;
-        // 2. If the user initialized on the Table, look up to the closest Paper wrapper
-        const paper = context.root.locator('xpath=ancestor::*[contains(@class, "MuiPaper-root")][1]').first();
-        if ((yield paper.count()) > 0) {
-            const inPaper = paper.locator('.MuiTablePagination-root').first();
-            if ((yield inPaper.count()) > 0)
-                return inPaper;
-        }
-        // 3. Fallback: find the first pagination footer that follows this context in the DOM
-        return context.root.locator('xpath=following::div[contains(@class, "MuiTablePagination-root")][1]').first();
-    });
+async function getPaginationRoot(context) {
+    // 1. If the user initialized useTable on the layout wrapper itself
+    const inside = context.root.locator('.MuiTablePagination-root').first();
+    if (await inside.count() > 0)
+        return inside;
+    // 2. If the user initialized on the Table, look up to the closest Paper wrapper
+    const paper = context.root.locator('xpath=ancestor::*[contains(@class, "MuiPaper-root")][1]').first();
+    if (await paper.count() > 0) {
+        const inPaper = paper.locator('.MuiTablePagination-root').first();
+        if (await inPaper.count() > 0)
+            return inPaper;
+    }
+    // 3. Fallback: find the first pagination footer that follows this context in the DOM
+    return context.root.locator('xpath=following::div[contains(@class, "MuiTablePagination-root")][1]').first();
 }
 /**
  * Preset configuration for the standard Material UI `<Table />` component.
@@ -69,56 +56,56 @@ exports.muiTable = {
     rowSelector: 'tbody tr, tbody .MuiTableRow-root',
     cellSelector: 'td, th, .MuiTableCell-body',
     headerSelector: 'thead th, .MuiTableCell-head',
-    headerTransformer: ({ text }) => text.replace(/\s*sorted\s+(a|de)scending/i, '').trim(),
+    headerTransformer: ({ text }) => text.replace(/\bsorted\s+(?:ascending|descending)\b/i, '').trim(),
     strategies: {
         pagination: {
-            goNext: (context) => __awaiter(void 0, void 0, void 0, function* () {
-                const root = yield getPaginationRoot(context);
+            goNext: async (context) => {
+                const root = await getPaginationRoot(context);
                 const nextBtn = root.locator('button[aria-label="Go to next page"]');
-                if ((yield nextBtn.count()) === 0 || (yield nextBtn.isDisabled()))
+                if (await nextBtn.count() === 0 || await nextBtn.isDisabled())
                     return false;
                 const displayedRows = root.locator('.MuiTablePagination-displayedRows');
-                const oldText = yield displayedRows.innerText().catch(() => '');
+                const oldText = await displayedRows.innerText().catch(() => '');
                 // Force click ignores cookie banners obscuring the footer
-                yield nextBtn.click({ force: true });
-                yield waitForMuiPaginationStabilization(context, displayedRows, oldText);
+                await nextBtn.click({ force: true });
+                await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                 return true;
-            }),
-            goPrevious: (context) => __awaiter(void 0, void 0, void 0, function* () {
-                const root = yield getPaginationRoot(context);
+            },
+            goPrevious: async (context) => {
+                const root = await getPaginationRoot(context);
                 const prevBtn = root.locator('button[aria-label="Go to previous page"]');
-                if ((yield prevBtn.count()) === 0 || (yield prevBtn.isDisabled()))
+                if (await prevBtn.count() === 0 || await prevBtn.isDisabled())
                     return false;
                 const displayedRows = root.locator('.MuiTablePagination-displayedRows');
-                const oldText = yield displayedRows.innerText().catch(() => '');
-                yield prevBtn.click({ force: true });
-                yield waitForMuiPaginationStabilization(context, displayedRows, oldText);
+                const oldText = await displayedRows.innerText().catch(() => '');
+                await prevBtn.click({ force: true });
+                await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                 return true;
-            }),
-            goToFirst: (context) => __awaiter(void 0, void 0, void 0, function* () {
-                const root = yield getPaginationRoot(context);
+            },
+            goToFirst: async (context) => {
+                const root = await getPaginationRoot(context);
                 const prevBtn = root.locator('button[aria-label="Go to previous page"]');
                 const displayedRows = root.locator('.MuiTablePagination-displayedRows');
                 let maxRetries = 50;
                 let clicked = false;
-                while (maxRetries-- > 0 && (yield prevBtn.count()) > 0 && !(yield prevBtn.isDisabled())) {
-                    const oldText = yield displayedRows.innerText().catch(() => '');
-                    yield prevBtn.click();
-                    yield waitForMuiPaginationStabilization(context, displayedRows, oldText);
+                while (maxRetries-- > 0 && await prevBtn.count() > 0 && !(await prevBtn.isDisabled())) {
+                    const oldText = await displayedRows.innerText().catch(() => '');
+                    await prevBtn.click();
+                    await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                     clicked = true;
                 }
                 return clicked;
-            })
+            }
         },
         sorting: {
-            getSortState: (_a) => __awaiter(void 0, [_a], void 0, function* ({ columnName, context }) {
+            getSortState: async ({ columnName, context }) => {
                 if (!context.getHeaderCell)
                     return 'none';
-                const header = yield context.getHeaderCell(columnName);
+                const header = await context.getHeaderCell(columnName);
                 const sortLabel = header.locator('.MuiTableSortLabel-root').first();
-                if (!(yield sortLabel.isVisible().catch(() => false)))
+                if (!(await sortLabel.isVisible().catch(() => false)))
                     return 'none';
-                const className = (yield sortLabel.getAttribute('class')) || '';
+                const className = await sortLabel.getAttribute('class') || '';
                 if (className.includes('directionAsc'))
                     return 'asc';
                 if (className.includes('directionDesc'))
@@ -127,34 +114,34 @@ exports.muiTable = {
                 if (className.includes('active'))
                     return 'asc';
                 return 'none';
-            }),
-            doSort: (_a) => __awaiter(void 0, [_a], void 0, function* ({ columnName, direction, context }) {
-                var _b, _c;
+            },
+            doSort: async ({ columnName, direction, context }) => {
+                var _a, _b;
                 if (!context.getHeaderCell)
                     return;
-                const header = yield context.getHeaderCell(columnName);
+                const header = await context.getHeaderCell(columnName);
                 const sortLabel = header.locator('.MuiTableSortLabel-root').first();
-                const target = (yield sortLabel.isVisible().catch(() => false)) ? sortLabel : header;
-                let current = (yield ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context }))) || 'none';
+                const target = await sortLabel.isVisible().catch(() => false) ? sortLabel : header;
+                let current = await ((_a = context.config.strategies.sorting) === null || _a === void 0 ? void 0 : _a.getSortState({ columnName, context })) || 'none';
                 let attempts = 0;
                 // Click until the state matches the target direction, max 3 times (none -> asc -> desc)
                 while (current !== direction && attempts < 3) {
-                    yield target.click();
-                    yield context.page.waitForTimeout(100);
-                    current = (yield ((_c = context.config.strategies.sorting) === null || _c === void 0 ? void 0 : _c.getSortState({ columnName, context }))) || 'none';
+                    await target.click();
+                    await context.page.waitForTimeout(100);
+                    current = await ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context })) || 'none';
                     attempts++;
                 }
-            })
+            }
         },
-        dedupe: (row) => __awaiter(void 0, void 0, void 0, function* () {
+        dedupe: async (row) => {
             // MUI virtualized tables attach data-index to rows 
-            const dataIndex = yield row.getAttribute('data-index');
+            const dataIndex = await row.getAttribute('data-index');
             if (dataIndex !== null)
                 return dataIndex;
             // Unvirtualized tables don't recycle nodes, but if they do duplicate, fallback to first cell's text
-            const text = yield row.locator('td, th').first().innerText().catch(() => '');
+            const text = await row.locator('td, th').first().innerText().catch(() => '');
             return text || String(Math.random());
-        })
+        }
     }
 };
 /**
@@ -173,94 +160,180 @@ exports.muiDataGrid = {
     headerSelector: '.MuiDataGrid-columnHeader',
     strategies: {
         pagination: {
-            goNext: (context) => __awaiter(void 0, void 0, void 0, function* () {
+            goNext: async (context) => {
                 const footer = context.root.locator('.MuiDataGrid-footerContainer');
                 const nextBtn = footer.locator('button[aria-label="Go to next page"]');
                 try {
-                    yield nextBtn.waitFor({ state: 'visible', timeout: 2000 });
+                    await nextBtn.waitFor({ state: 'visible', timeout: 2000 });
                 }
                 catch (e) {
                     return false;
                 }
-                if (yield nextBtn.isDisabled())
+                if (await nextBtn.isDisabled())
                     return false;
                 const displayedRows = footer.locator('.MuiTablePagination-displayedRows');
-                const oldText = yield displayedRows.innerText().catch(() => '');
-                yield nextBtn.scrollIntoViewIfNeeded().catch(() => { });
-                yield nextBtn.click({ force: true });
-                yield waitForMuiPaginationStabilization(context, displayedRows, oldText);
+                const oldText = await displayedRows.innerText().catch(() => '');
+                await nextBtn.scrollIntoViewIfNeeded().catch(() => { });
+                await nextBtn.click({ force: true });
+                await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                 return true;
-            }),
-            goPrevious: (context) => __awaiter(void 0, void 0, void 0, function* () {
+            },
+            goPrevious: async (context) => {
                 const footer = context.root.locator('.MuiDataGrid-footerContainer');
                 const prevBtn = footer.locator('button[aria-label="Go to previous page"]');
                 try {
-                    yield prevBtn.waitFor({ state: 'visible', timeout: 2000 });
+                    await prevBtn.waitFor({ state: 'visible', timeout: 2000 });
                 }
                 catch (e) {
                     return false;
                 }
-                if (yield prevBtn.isDisabled())
+                if (await prevBtn.isDisabled())
                     return false;
                 const displayedRows = footer.locator('.MuiTablePagination-displayedRows');
-                const oldText = yield displayedRows.innerText().catch(() => '');
-                yield prevBtn.scrollIntoViewIfNeeded().catch(() => { });
-                yield prevBtn.click({ force: true });
-                yield waitForMuiPaginationStabilization(context, displayedRows, oldText);
+                const oldText = await displayedRows.innerText().catch(() => '');
+                await prevBtn.scrollIntoViewIfNeeded().catch(() => { });
+                await prevBtn.click({ force: true });
+                await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                 return true;
-            })
+            }
         },
         sorting: {
-            getSortState: (_a) => __awaiter(void 0, [_a], void 0, function* ({ columnName, context }) {
+            getSortState: async ({ columnName, context }) => {
                 if (!context.getHeaderCell)
                     return 'none';
-                const header = yield context.getHeaderCell(columnName);
-                const sortAttr = yield header.getAttribute('aria-sort');
+                const header = await context.getHeaderCell(columnName);
+                const sortAttr = await header.getAttribute('aria-sort');
                 if (sortAttr === 'ascending')
                     return 'asc';
                 if (sortAttr === 'descending')
                     return 'desc';
                 return 'none';
-            }),
-            doSort: (_a) => __awaiter(void 0, [_a], void 0, function* ({ columnName, direction, context }) {
-                var _b, _c;
+            },
+            doSort: async ({ columnName, direction, context }) => {
+                var _a, _b;
                 if (!context.getHeaderCell)
                     return;
-                const header = yield context.getHeaderCell(columnName);
-                let current = (yield ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context }))) || 'none';
+                const header = await context.getHeaderCell(columnName);
+                let current = await ((_a = context.config.strategies.sorting) === null || _a === void 0 ? void 0 : _a.getSortState({ columnName, context })) || 'none';
                 let attempts = 0;
                 while (current !== direction && attempts < 3) {
                     const clickTarget = header.locator('.MuiDataGrid-columnHeaderTitleContainer').first();
-                    if (yield clickTarget.isVisible()) {
-                        yield clickTarget.click({ force: true });
+                    if (await clickTarget.isVisible()) {
+                        await clickTarget.click({ force: true });
                     }
                     else {
-                        yield header.click({ force: true });
+                        await header.click({ force: true });
                     }
                     // Sorting can trigger large re-renders/virtualization shifts
-                    yield context.page.waitForTimeout(500);
+                    await context.page.waitForTimeout(500);
                     // Wait for stabilization (using DataGrid specific overlay check inside helper)
                     const displayedRows = context.root.locator('.MuiTablePagination-displayedRows');
-                    const text = yield displayedRows.innerText().catch(() => '');
-                    yield waitForMuiPaginationStabilization(context, displayedRows, text);
-                    current = (yield ((_c = context.config.strategies.sorting) === null || _c === void 0 ? void 0 : _c.getSortState({ columnName, context }))) || 'none';
+                    const text = await displayedRows.innerText().catch(() => '');
+                    await waitForMuiPaginationStabilization(context, displayedRows, text);
+                    current = await ((_b = context.config.strategies.sorting) === null || _b === void 0 ? void 0 : _b.getSortState({ columnName, context })) || 'none';
                     attempts++;
                 }
-            })
+            }
         },
-        dedupe: (row) => __awaiter(void 0, void 0, void 0, function* () {
+        dedupe: async (row) => {
             var _a;
             // DataGrid uses data-rowindex for its own virtualization management
-            return (_a = (yield row.getAttribute('data-rowindex').catch(() => null))) !== null && _a !== void 0 ? _a : '';
-        }),
+            return (_a = (await row.getAttribute('data-rowindex').catch(() => null))) !== null && _a !== void 0 ? _a : '';
+        },
         getCellLocator: ({ row, columnIndex }) => {
             // Horizontal virtualization uses aria-colindex (1-indexed)
             return row.locator(`[aria-colindex="${columnIndex + 1}"]`);
         },
+        // MUI DataGrid virtualizes rows vertically (always) and columns horizontally (when
+        // columnBuffer is configured). The virtualScroller is a descendant of root, so
+        // scroll methods use querySelector rather than closest().
+        viewport: {
+            getVisibleRowRange: async ({ root, config }) => {
+                const rowSel = config.rowSelector;
+                return root.evaluate((el, rowSel) => {
+                    const indices = Array.from(el.querySelectorAll(rowSel))
+                        .map(r => Number(r.getAttribute('data-rowindex')))
+                        .filter(n => !isNaN(n));
+                    if (!indices.length)
+                        return { first: 0, last: 0 };
+                    return { first: Math.min(...indices), last: Math.max(...indices) };
+                }, rowSel);
+            },
+            getVisibleColumnRange: async ({ root, config }) => {
+                const rowSel = config.rowSelector;
+                const cellSel = typeof config.cellSelector === 'string' ? config.cellSelector : '[aria-colindex]';
+                return root.evaluate((el, { rowSel, cellSel }) => {
+                    const firstRow = el.querySelector(rowSel);
+                    if (!firstRow)
+                        return { first: 0, last: 0 };
+                    const indices = Array.from(firstRow.querySelectorAll(cellSel))
+                        .map(c => Number(c.getAttribute('aria-colindex')) - 1)
+                        .filter(n => !isNaN(n));
+                    if (!indices.length)
+                        return { first: 0, last: 0 };
+                    return { first: Math.min(...indices), last: Math.max(...indices) };
+                }, { rowSel, cellSel });
+            },
+            scrollToRow: async ({ root, config }, rowIndex) => {
+                const rowSel = config.rowSelector;
+                await root.evaluate((el, { rowSel, idx }) => {
+                    const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
+                    if (!scroller)
+                        return;
+                    const row = el.querySelector(`${rowSel}[data-rowindex="${idx}"]`);
+                    if (row) {
+                        row.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                        return;
+                    }
+                    const visibleRows = Array.from(el.querySelectorAll(rowSel));
+                    const heights = visibleRows
+                        .map(visibleRow => visibleRow.getBoundingClientRect().height)
+                        .filter(height => height > 0);
+                    const estimatedHeight = heights.length
+                        ? heights.reduce((sum, height) => sum + height, 0) / heights.length
+                        : 52;
+                    scroller.scrollTop = Math.max(0, idx * estimatedHeight - 20);
+                }, { rowSel, idx: rowIndex });
+                await root.locator(`${rowSel}[data-rowindex="${rowIndex}"]`)
+                    .waitFor({ state: 'attached', timeout: 3000 });
+            },
+            scrollToColumn: async ({ root, config }, colIndex) => {
+                const headerSel = typeof config.headerSelector === 'string' ? config.headerSelector : null;
+                await root.evaluate((el, { headerSel, idx }) => {
+                    // virtualScroller is a descendant — querySelector, not closest
+                    const scroller = el.querySelector('.MuiDataGrid-virtualScroller');
+                    if (!scroller || !headerSel)
+                        return;
+                    const headers = Array.from(el.querySelectorAll(headerSel));
+                    const target = headers[idx];
+                    if (!target) {
+                        const widths = headers
+                            .map(header => header.getBoundingClientRect().width)
+                            .filter(width => width > 0);
+                        const estimatedWidth = widths.length
+                            ? widths.reduce((sum, width) => sum + width, 0) / widths.length
+                            : 100;
+                        scroller.scrollLeft = Math.max(0, idx * estimatedWidth - 20);
+                        return;
+                    }
+                    const cRect = scroller.getBoundingClientRect();
+                    const tRect = target.getBoundingClientRect();
+                    if (tRect.left < cRect.left) {
+                        scroller.scrollLeft -= (cRect.left - tRect.left) + 20;
+                    }
+                    else if (tRect.right > cRect.right) {
+                        scroller.scrollLeft += (tRect.right - cRect.right) + 20;
+                    }
+                }, { headerSel, idx: colIndex });
+                await root.locator(`${config.rowSelector} [aria-colindex="${colIndex + 1}"]`)
+                    .first()
+                    .waitFor({ state: 'attached', timeout: 3000 });
+            },
+        },
         loading: {
-            isTableLoading: (context) => __awaiter(void 0, void 0, void 0, function* () {
-                return yield context.root.locator('.MuiDataGrid-overlay').isVisible().catch(() => false);
-            })
+            isTableLoading: async (context) => {
+                return await context.root.locator('.MuiDataGrid-overlay').isVisible().catch(() => false);
+            }
         }
     }
 };

package/dist/presets/rdg.d.ts

@@ -10,7 +10,7 @@ export declare const RDGStrategies: {
         goUp: ({ root, page }: any) => Promise<void>;
         goHome: ({ root, page }: any) => Promise<void>;
     };
-    pagination: import("../types").PaginationPrimitives;
+    pagination: import("..").PaginationPrimitives;
 };
 export declare const RDG: Partial<TableConfig> & {
     Strategies: typeof RDGStrategies;

package/dist/presets/rdg.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.RDG = exports.RDGStrategies = void 0;
 const pagination_1 = require("../strategies/pagination");
@@ -16,43 +7,43 @@ const stabilization_1 = require("../strategies/stabilization");
  * Scrolls the grid horizontally to collect all column headers.
  * Handles empty headers by labeling them (e.g. "Checkbox").
  */
-const scrollRightHeaderRDG = (context) => __awaiter(void 0, void 0, void 0, function* () {
+const scrollRightHeaderRDG = async (context) => {
     const { resolve, config, root, page } = context;
     const collectedHeaders = new Set();
-    const gridHandle = yield root.evaluateHandle((el) => {
+    const gridHandle = await root.evaluateHandle((el) => {
         return el.querySelector('[role="grid"]') || el.closest('[role="grid"]');
     });
-    const expectedColumns = yield gridHandle.evaluate(el => el ? parseInt(el.getAttribute('aria-colcount') || '0', 10) : 0);
-    const getVisible = () => __awaiter(void 0, void 0, void 0, function* () {
+    const expectedColumns = await gridHandle.evaluate(el => el ? parseInt(el.getAttribute('aria-colcount') || '0', 10) : 0);
+    const getVisible = async () => {
         const headerLoc = resolve(config.headerSelector, root);
-        const texts = yield headerLoc.allInnerTexts();
+        const texts = await headerLoc.allInnerTexts();
         return texts.map(t => {
             const trimmed = t.trim();
             return trimmed.length > 0 ? trimmed : 'Checkbox';
         });
-    });
-    let currentHeaders = yield getVisible();
+    };
+    let currentHeaders = await getVisible();
     currentHeaders.forEach(h => collectedHeaders.add(h));
-    const hasScroll = yield gridHandle.evaluate(el => el ? el.scrollWidth > el.clientWidth : false);
+    const hasScroll = await gridHandle.evaluate(el => el ? el.scrollWidth > el.clientWidth : false);
     if (hasScroll) {
-        yield gridHandle.evaluate(el => el.scrollLeft = 0);
-        yield page.waitForTimeout(200);
+        await gridHandle.evaluate(el => el.scrollLeft = 0);
+        await page.waitForTimeout(200);
         let iteration = 0;
         while (collectedHeaders.size < expectedColumns && iteration < 30) {
-            yield gridHandle.evaluate(el => el.scrollLeft += 500);
-            yield page.waitForTimeout(300);
-            const newHeaders = yield getVisible();
+            await gridHandle.evaluate(el => el.scrollLeft += 500);
+            await page.waitForTimeout(300);
+            const newHeaders = await getVisible();
             newHeaders.forEach(h => collectedHeaders.add(h));
-            const atEnd = yield gridHandle.evaluate(el => el.scrollLeft >= el.scrollWidth - el.clientWidth - 10);
+            const atEnd = await gridHandle.evaluate(el => el.scrollLeft >= el.scrollWidth - el.clientWidth - 10);
             iteration++;
             if (atEnd)
                 break;
         }
-        yield gridHandle.evaluate(el => el.scrollLeft = 0);
-        yield page.waitForTimeout(200);
+        await gridHandle.evaluate(el => el.scrollLeft = 0);
+        await page.waitForTimeout(200);
     }
     return Array.from(collectedHeaders);
-});
+};
 const rdgGetCellLocator = ({ row, columnIndex }) => {
     const ariaColIndex = columnIndex + 1;
     return row.locator(`[role="gridcell"][aria-colindex="${ariaColIndex}"]`);
@@ -63,43 +54,43 @@ const rdgPaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
     stabilization: stabilization_1.StabilizationStrategies.contentChanged({ timeout: 5000 })
 });
 const rdgNavigation = {
-    goRight: (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page }) {
-        yield root.evaluate((el) => {
+    goRight: async ({ root, page }) => {
+        await root.evaluate((el) => {
             const grid = el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el;
             if (grid)
                 grid.scrollLeft += 150;
         });
-    }),
-    goLeft: (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page }) {
-        yield root.evaluate((el) => {
+    },
+    goLeft: async ({ root, page }) => {
+        await root.evaluate((el) => {
             const grid = el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el;
             if (grid)
                 grid.scrollLeft -= 150;
         });
-    }),
-    goDown: (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page }) {
-        yield root.evaluate((el) => {
+    },
+    goDown: async ({ root, page }) => {
+        await root.evaluate((el) => {
             const grid = el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el;
             if (grid)
                 grid.scrollTop += 35;
         });
-    }),
-    goUp: (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page }) {
-        yield root.evaluate((el) => {
+    },
+    goUp: async ({ root, page }) => {
+        await root.evaluate((el) => {
             const grid = el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el;
             if (grid)
                 grid.scrollTop -= 35;
         });
-    }),
-    goHome: (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page }) {
-        yield root.evaluate((el) => {
+    },
+    goHome: async ({ root, page }) => {
+        await root.evaluate((el) => {
             const grid = el.querySelector('[role="grid"]') || el.closest('[role="grid"]') || el;
             if (grid) {
                 grid.scrollLeft = 0;
                 grid.scrollTop = 0;
             }
         });
-    })
+    }
 };
 /** Default strategies for the RDG preset (used when you spread Plugins.RDG). */
 const RDGDefaultStrategies = {