@rickcedwhat/playwright-smart-table 5.3.0 → 6.0.0

package/dist/src/strategies/glide.js

@@ -0,0 +1,98 @@
+"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.GlideStrategies = exports.glideGetActiveCell = exports.glideGetCellLocator = exports.glidePaginationStrategy = exports.glideFillStrategy = void 0;
+const columns_1 = require("../../examples/glide-strategies/columns");
+const headers_1 = require("../../examples/glide-strategies/headers");
+const pagination_1 = require("./pagination");
+const stabilization_1 = require("./stabilization");
+const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
+    // Edit Cell
+    yield page.keyboard.press('Enter');
+    // Wait for editor to appear
+    const textarea = page.locator('textarea.gdg-input');
+    yield textarea.waitFor({ state: 'visible', timeout: 2000 });
+    yield page.keyboard.type(String(value));
+    // Wait for textarea value to match what we typed
+    yield textarea.evaluate((el, expectedValue) => {
+        return new Promise((resolve) => {
+            const checkValue = () => {
+                if (el.value === expectedValue) {
+                    resolve();
+                }
+                else {
+                    setTimeout(checkValue, 10);
+                }
+            };
+            checkValue();
+        });
+    }, String(value));
+    // Small delay to let the grid process the value
+    yield page.waitForTimeout(50);
+    yield page.keyboard.press('Enter');
+    // Wait for editor to close (commit completed)
+    yield textarea.waitFor({ state: 'detached', timeout: 2000 });
+    // Wait for accessibility layer to sync with canvas state
+    yield page.waitForTimeout(300);
+});
+exports.glideFillStrategy = glideFillStrategy;
+exports.glidePaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
+    scrollTarget: 'xpath=//ancestor::body//div[contains(@class, "dvn-scroller")]',
+    scrollAmount: 500,
+    action: 'js-scroll',
+    stabilization: stabilization_1.StabilizationStrategies.contentChanged({ timeout: 5000 }),
+    timeout: 5000 // Overall timeout
+});
+const glideGetCellLocator = ({ row, columnIndex }) => {
+    // Use relative locator to support virtualization (where rowIndex resets or is offsets)
+    // The accessibility DOM usually contains 'td' elements with the data.
+    return row.locator('td').nth(columnIndex);
+};
+exports.glideGetCellLocator = glideGetCellLocator;
+const glideGetActiveCell = (_a) => __awaiter(void 0, [_a], void 0, function* ({ page }) {
+    // Find the focused cell/element
+    // Use broad selector for focused element
+    const focused = page.locator('*:focus').first();
+    if ((yield focused.count()) === 0)
+        return null;
+    // Debug log
+    if (process.env.DEBUG)
+        console.log('Found focused element:', yield focused.evaluate((e) => e.outerHTML));
+    // Try to extract position from ID if possible
+    const id = (yield focused.getAttribute('id')) || '';
+    // Expected format: glide-cell-COL-ROW
+    const parts = id.split('-');
+    let rowIndex = -1;
+    let columnIndex = -1;
+    if (parts.length >= 4 && parts[0] === 'glide' && parts[1] === 'cell') {
+        columnIndex = parseInt(parts[2]) - 1; // 1-based in ID to 0-based
+        rowIndex = parseInt(parts[3]);
+    }
+    else {
+        // Fallback: If we can't parse ID, we assume it's the correct cell 
+        // because we just navigated to it. 
+        // Returning -1 indices might be confusing but won't stop smartRow from using the locator.
+    }
+    return {
+        rowIndex,
+        columnIndex,
+        locator: focused
+    };
+});
+exports.glideGetActiveCell = glideGetActiveCell;
+exports.GlideStrategies = {
+    fill: exports.glideFillStrategy,
+    pagination: exports.glidePaginationStrategy,
+    header: headers_1.scrollRightHeader,
+    cellNavigation: columns_1.keyboardCellNavigation,
+    getCellLocator: exports.glideGetCellLocator,
+    getActiveCell: exports.glideGetActiveCell
+};

package/dist/src/strategies/headers.d.ts

@@ -0,0 +1,13 @@
+import { StrategyContext } from '../types';
+/**
+ * Defines the contract for a header retrieval strategy.
+ * Returns a list of unique header names found in the table.
+ */
+export type HeaderStrategy = (context: StrategyContext) => Promise<string[]>;
+export declare const HeaderStrategies: {
+    /**
+     * Default strategy: Returns only the headers currently visible in the DOM.
+     * This is fast but won't find virtualized columns off-screen.
+     */
+    visible: ({ config, resolve, root }: StrategyContext) => Promise<string[]>;
+};

package/dist/src/strategies/headers.js

@@ -0,0 +1,30 @@
+"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.HeaderStrategies = void 0;
+exports.HeaderStrategies = {
+    /**
+     * Default strategy: Returns only the headers currently visible in the DOM.
+     * This is fast but won't find virtualized columns off-screen.
+     */
+    visible: (_a) => __awaiter(void 0, [_a], void 0, function* ({ config, resolve, root }) {
+        const headerLoc = resolve(config.headerSelector, root);
+        try {
+            // Wait for at least one header to be visible
+            yield headerLoc.first().waitFor({ state: 'visible', timeout: 3000 });
+        }
+        catch (e) {
+            // Ignore hydration/timeout issues, return what we have
+        }
+        const texts = yield headerLoc.allInnerTexts();
+        return texts.map(t => t.trim());
+    })
+};

package/dist/src/strategies/index.d.ts

@@ -0,0 +1,54 @@
+export * from './pagination';
+export * from './sorting';
+export * from './columns';
+export * from './headers';
+export * from './fill';
+export * from './resolution';
+export * from './dedupe';
+export * from './loading';
+export declare const Strategies: {
+    Pagination: {
+        clickNext: (nextButtonSelector: import("..").Selector, options?: {
+            stabilization?: import("./stabilization").StabilizationStrategy;
+            timeout?: number;
+        }) => import("..").PaginationStrategy;
+        infiniteScroll: (options?: {
+            action?: "scroll" | "js-scroll";
+            scrollTarget?: import("..").Selector;
+            scrollAmount?: number;
+            stabilization?: import("./stabilization").StabilizationStrategy;
+            timeout?: number;
+        }) => import("..").PaginationStrategy;
+    };
+    Sorting: {
+        AriaSort: () => import("..").SortingStrategy;
+    };
+    CellNavigation: {
+        default: () => Promise<void>;
+    };
+    Header: {
+        visible: ({ config, resolve, root }: import("..").StrategyContext) => Promise<string[]>;
+    };
+    Fill: {
+        default: ({ row, columnName, value, fillOptions }: Parameters<import("..").FillStrategy>[0]) => Promise<void>;
+    };
+    Resolution: {
+        default: import("./resolution").ColumnResolutionStrategy;
+    };
+    Dedupe: {
+        byTopPosition: (tolerance?: number) => import("..").DedupeStrategy;
+    };
+    Loading: {
+        Table: {
+            hasSpinner: (selector?: string) => ({ root }: import("..").TableContext) => Promise<boolean>;
+            custom: (fn: (context: import("..").TableContext) => Promise<boolean>) => (context: import("..").TableContext) => Promise<boolean>;
+            never: () => Promise<boolean>;
+        };
+        Row: {
+            hasClass: (className?: string) => (row: import("..").SmartRow) => Promise<boolean>;
+            hasText: (text?: string | RegExp) => (row: import("..").SmartRow) => Promise<boolean>;
+            hasEmptyCells: () => (row: import("..").SmartRow) => Promise<boolean>;
+            never: () => Promise<boolean>;
+        };
+    };
+};

package/dist/src/strategies/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strategies = void 0;
+const pagination_1 = require("./pagination");
+const sorting_1 = require("./sorting");
+const columns_1 = require("./columns");
+const headers_1 = require("./headers");
+const fill_1 = require("./fill");
+const resolution_1 = require("./resolution");
+const dedupe_1 = require("./dedupe");
+const loading_1 = require("./loading");
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./sorting"), exports);
+__exportStar(require("./columns"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./fill"), exports);
+__exportStar(require("./resolution"), exports);
+__exportStar(require("./dedupe"), exports);
+__exportStar(require("./loading"), exports);
+exports.Strategies = {
+    Pagination: pagination_1.PaginationStrategies,
+    Sorting: sorting_1.SortingStrategies,
+    CellNavigation: columns_1.CellNavigationStrategies,
+    Header: headers_1.HeaderStrategies,
+    Fill: fill_1.FillStrategies,
+    Resolution: resolution_1.ResolutionStrategies,
+    Dedupe: dedupe_1.DedupeStrategies,
+    Loading: loading_1.LoadingStrategies,
+};

package/dist/src/strategies/loading.d.ts

@@ -0,0 +1,48 @@
+import { SmartRow, TableContext } from '../types';
+/**
+ * Strategies for detecting loading states.
+ * Return `true` if the item is loading/busy, `false` if it is ready.
+ */
+export declare const LoadingStrategies: {
+    /**
+     * Strategies for detecting if the entire table is loading.
+     */
+    Table: {
+        /**
+         * Checks if a global spinner or loading overlay is visible.
+         * @param selector Selector for the loading indicator (e.g. '.loading-spinner')
+         */
+        hasSpinner: (selector?: string) => ({ root }: TableContext) => Promise<boolean>;
+        /**
+         * Custom function to determine table loading state.
+         */
+        custom: (fn: (context: TableContext) => Promise<boolean>) => (context: TableContext) => Promise<boolean>;
+        /**
+         * Assume table is never loading (default).
+         */
+        never: () => Promise<boolean>;
+    };
+    /**
+     * Strategies for detecting if a specific row is loading (e.g. Skeleton).
+     */
+    Row: {
+        /**
+         * Checks if the row contains a specific class indicating it's a skeleton/loading row.
+         * @param className Class name acting as the loading indicator (default: 'skeleton')
+         */
+        hasClass: (className?: string) => (row: SmartRow) => Promise<boolean>;
+        /**
+         * Checks if the row's text content matches a "Loading..." string or regex.
+         */
+        hasText: (text?: string | RegExp) => (row: SmartRow) => Promise<boolean>;
+        /**
+         * Checks if the row has any cell with empty/falsy content (if strict).
+         * Useful if rows render with empty cells before populating.
+         */
+        hasEmptyCells: () => (row: SmartRow) => Promise<boolean>;
+        /**
+         * Assume row is never loading (default).
+         */
+        never: () => Promise<boolean>;
+    };
+};

package/dist/src/strategies/loading.js

@@ -0,0 +1,82 @@
+"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.LoadingStrategies = void 0;
+/**
+ * Strategies for detecting loading states.
+ * Return `true` if the item is loading/busy, `false` if it is ready.
+ */
+exports.LoadingStrategies = {
+    /**
+     * Strategies for detecting if the entire table is loading.
+     */
+    Table: {
+        /**
+         * Checks if a global spinner or loading overlay is visible.
+         * @param selector Selector for the loading indicator (e.g. '.loading-spinner')
+         */
+        hasSpinner: (selector = '.loading-spinner') => (_a) => __awaiter(void 0, [_a], void 0, function* ({ root }) {
+            // Check if spinner exists and is visible within the table wrapper or page
+            const spinner = root.locator(selector).first();
+            try {
+                return yield spinner.isVisible();
+            }
+            catch (_b) {
+                return false;
+            }
+        }),
+        /**
+         * Custom function to determine table loading state.
+         */
+        custom: (fn) => fn,
+        /**
+         * Assume table is never loading (default).
+         */
+        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+    },
+    /**
+     * Strategies for detecting if a specific row is loading (e.g. Skeleton).
+     */
+    Row: {
+        /**
+         * Checks if the row contains a specific class indicating it's a skeleton/loading row.
+         * @param className Class name acting as the loading indicator (default: 'skeleton')
+         */
+        hasClass: (className = 'skeleton') => (row) => __awaiter(void 0, void 0, void 0, function* () {
+            const cls = yield row.getAttribute('class');
+            return cls ? cls.includes(className) : false;
+        }),
+        /**
+         * Checks if the row's text content matches a "Loading..." string or regex.
+         */
+        hasText: (text = 'Loading...') => (row) => __awaiter(void 0, void 0, void 0, function* () {
+            const content = yield row.innerText();
+            if (typeof text === 'string')
+                return content.includes(text);
+            return text.test(content);
+        }),
+        /**
+         * Checks if the row has any cell with empty/falsy content (if strict).
+         * Useful if rows render with empty cells before populating.
+         */
+        hasEmptyCells: () => (row) => __awaiter(void 0, void 0, void 0, function* () {
+            // Logic: Get all cells, check if any are empty.
+            // Note: This might be expensive if done for every row check.
+            // Simplified: check if InnerText is empty or very short?
+            const text = yield row.innerText();
+            return !text.trim();
+        }),
+        /**
+         * Assume row is never loading (default).
+         */
+        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+    }
+};

package/dist/src/strategies/pagination.d.ts

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

package/dist/src/strategies/pagination.js

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

package/dist/src/strategies/rdg.d.ts

@@ -0,0 +1,25 @@
+import { TableContext } from '../types';
+/**
+ * Scrolls the grid horizontally to collect all column headers.
+ * Handles empty headers by labeling them (e.g. "Checkbox").
+ */
+export declare const scrollRightHeaderRDG: (context: TableContext) => Promise<string[]>;
+/**
+ * Uses a row-relative locator to avoid issues with absolute aria-rowindex
+ * changing during pagination/scrolling.
+ */
+export declare const rdgGetCellLocator: ({ row, columnIndex }: any) => any;
+/**
+ * Scrolls virtualized columns into view before reading.
+ */
+export declare const rdgCellNavigation: ({ root, page, index }: any) => Promise<void>;
+/**
+ * Scrolls the grid vertically to load more virtualized rows.
+ */
+export declare const rdgPaginationStrategy: import("../types").PaginationStrategy;
+export declare const RDGStrategies: {
+    header: (context: TableContext) => Promise<string[]>;
+    getCellLocator: ({ row, columnIndex }: any) => any;
+    cellNavigation: ({ root, page, index }: any) => Promise<void>;
+    pagination: import("../types").PaginationStrategy;
+};

package/dist/src/strategies/rdg.js

@@ -0,0 +1,100 @@
+"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.RDGStrategies = exports.rdgPaginationStrategy = exports.rdgCellNavigation = exports.rdgGetCellLocator = exports.scrollRightHeaderRDG = void 0;
+/**
+ * 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 { resolve, config, root, page } = context;
+    const collectedHeaders = new Set();
+    const gridHandle = yield 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 headerLoc = resolve(config.headerSelector, root);
+        const texts = yield headerLoc.allInnerTexts();
+        return texts.map(t => {
+            const trimmed = t.trim();
+            // Assign a name to empty headers (like selection checkboxes)
+            return trimmed.length > 0 ? trimmed : 'Checkbox';
+        });
+    });
+    let currentHeaders = yield getVisible();
+    currentHeaders.forEach(h => collectedHeaders.add(h));
+    const hasScroll = yield gridHandle.evaluate(el => el ? el.scrollWidth > el.clientWidth : false);
+    if (hasScroll) {
+        yield gridHandle.evaluate(el => el.scrollLeft = 0);
+        yield page.waitForTimeout(200);
+        let iteration = 0;
+        // Safety break at 30 iterations to prevent infinite loops
+        while (collectedHeaders.size < expectedColumns && iteration < 30) {
+            yield gridHandle.evaluate(el => el.scrollLeft += 500);
+            yield page.waitForTimeout(300);
+            const newHeaders = yield getVisible();
+            newHeaders.forEach(h => collectedHeaders.add(h));
+            const atEnd = yield 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);
+    }
+    return Array.from(collectedHeaders);
+});
+exports.scrollRightHeaderRDG = scrollRightHeaderRDG;
+/**
+ * Uses a row-relative locator to avoid issues with absolute aria-rowindex
+ * changing during pagination/scrolling.
+ */
+const rdgGetCellLocator = ({ row, columnIndex }) => {
+    const ariaColIndex = columnIndex + 1;
+    return row.locator(`[role="gridcell"][aria-colindex="${ariaColIndex}"]`);
+};
+exports.rdgGetCellLocator = rdgGetCellLocator;
+/**
+ * Scrolls virtualized columns into view before reading.
+ */
+const rdgCellNavigation = (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, page, index }) {
+    // Check if the column header is visible and scroll horizontally if needed
+    const headerCell = root.locator(`[role="columnheader"][aria-colindex="${index + 1}"]`);
+    const isVisible = yield headerCell.isVisible().catch(() => false);
+    if (!isVisible) {
+        const estimatedScroll = index * 150;
+        yield root.evaluate((el, scrollAmount) => {
+            el.scrollLeft = scrollAmount;
+        }, estimatedScroll);
+        yield page.waitForTimeout(300);
+    }
+});
+exports.rdgCellNavigation = rdgCellNavigation;
+/**
+ * Scrolls the grid vertically to load more virtualized rows.
+ */
+const pagination_1 = require("./pagination");
+const stabilization_1 = require("./stabilization");
+/**
+ * Scrolls the grid vertically to load more virtualized rows.
+ */
+exports.rdgPaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
+    action: 'js-scroll',
+    scrollAmount: 500,
+    stabilization: stabilization_1.StabilizationStrategies.contentChanged({ timeout: 5000 })
+});
+exports.RDGStrategies = {
+    header: exports.scrollRightHeaderRDG,
+    getCellLocator: exports.rdgGetCellLocator,
+    cellNavigation: exports.rdgCellNavigation,
+    pagination: exports.rdgPaginationStrategy
+};

package/dist/src/strategies/resolution.d.ts

@@ -0,0 +1,22 @@
+import { StrategyContext } from '../types';
+export interface ColumnResolutionStrategy {
+    /**
+     * Resolves a column name (string or Regex) to a column index.
+     * Returns undefined if not found.
+     */
+    resolveIndex(options: {
+        query: string | RegExp;
+        headerMap: Map<string, number>;
+        context: StrategyContext;
+    }): number | undefined;
+    /**
+     * Resolves a column name to a clean string name (for error messages or debugging).
+     */
+    resolveName(options: {
+        query: string | RegExp;
+        headerMap: Map<string, number>;
+    }): string;
+}
+export declare const ResolutionStrategies: {
+    default: ColumnResolutionStrategy;
+};

package/dist/src/strategies/resolution.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolutionStrategies = void 0;
+exports.ResolutionStrategies = {
+    default: {
+        resolveIndex: ({ query, headerMap }) => {
+            // 1. Exact / String Match
+            if (typeof query === 'string') {
+                if (headerMap.has(query))
+                    return headerMap.get(query);
+            }
+            // 2. Regex Match
+            if (query instanceof RegExp) {
+                for (const [colName, idx] of headerMap.entries()) {
+                    if (query.test(colName))
+                        return idx;
+                }
+                return undefined;
+            }
+            // 3. (Optional) Fuzzy String Match fallback could go here
+            // But for strict default strategy, we might want to keep it simple first
+            // The original code didn't do fuzzy *resolution* logic inside the get(), it just did strict get().
+            // The fuzzy logic was only for *suggestions* on error.
+            return undefined;
+        },
+        resolveName: ({ query }) => {
+            return query.toString();
+        }
+    }
+};