@rickcedwhat/playwright-smart-table 6.1.0 → 6.2.0

package/dist/src/index.js

@@ -1,18 +0,0 @@
-"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 });
-__exportStar(require("./useTable"), exports);
-__exportStar(require("./types"), exports);

package/dist/src/smartRow.d.ts

@@ -1,7 +0,0 @@
-import type { Locator, Page } from '@playwright/test';
-import { SmartRow as SmartRowType, FinalTableConfig, TableResult } from './types';
-/**
- * Factory to create a SmartRow by extending a Playwright Locator.
- * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
- */
-export declare const createSmartRow: <T = any>(rowLocator: Locator, map: Map<string, number>, rowIndex: number | undefined, config: FinalTableConfig, rootLocator: Locator, resolve: (item: any, parent: Locator | Page) => Locator, table: TableResult<T> | null) => SmartRowType<T>;

package/dist/src/smartRow.js

@@ -1,160 +0,0 @@
-"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.createSmartRow = void 0;
-const fill_1 = require("./strategies/fill");
-const stringUtils_1 = require("./utils/stringUtils");
-const debugUtils_1 = require("./utils/debugUtils");
-/**
- * Factory to create a SmartRow by extending a Playwright Locator.
- * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
- */
-const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve, table) => {
-    const smart = rowLocator;
-    // Attach State
-    smart.rowIndex = rowIndex;
-    // Attach Methods
-    smart.getCell = (colName) => {
-        const idx = map.get(colName);
-        if (idx === undefined) {
-            throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
-        }
-        if (config.strategies.getCellLocator) {
-            return config.strategies.getCellLocator({
-                row: rowLocator,
-                columnName: colName,
-                columnIndex: idx,
-                rowIndex: rowIndex,
-                page: rootLocator.page()
-            });
-        }
-        return resolve(config.cellSelector, rowLocator).nth(idx);
-    };
-    smart.toJSON = (options) => __awaiter(void 0, void 0, void 0, function* () {
-        const result = {};
-        const page = rootLocator.page();
-        for (const [col, idx] of map.entries()) {
-            if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(col)) {
-                continue;
-            }
-            // Get the cell locator
-            const cell = config.strategies.getCellLocator
-                ? config.strategies.getCellLocator({
-                    row: rowLocator,
-                    columnName: col,
-                    columnIndex: idx,
-                    rowIndex: rowIndex,
-                    page: page
-                })
-                : resolve(config.cellSelector, rowLocator).nth(idx);
-            let targetCell = cell;
-            // Check if cell exists
-            const count = yield cell.count();
-            if (count === 0) {
-                // Optimization: Check if we are ALREADY at the target cell
-                if (config.strategies.getActiveCell) {
-                    const active = yield config.strategies.getActiveCell({
-                        config,
-                        root: rootLocator,
-                        page,
-                        resolve
-                    });
-                    if (active && active.rowIndex === rowIndex && active.columnIndex === idx) {
-                        if (config.debug)
-                            console.log(`[SmartRow] Already at target cell (r:${active.rowIndex}, c:${active.columnIndex}), skipping navigation.`);
-                        targetCell = active.locator;
-                        // Skip navigation and go to reading text
-                        const text = yield targetCell.innerText();
-                        result[col] = (text || '').trim();
-                        continue;
-                    }
-                }
-                // Cell doesn't exist - navigate to it
-                if (config.debug) {
-                    console.log(`[SmartRow.toJSON] Cell not found for column "${col}" (index ${idx}), navigating...`);
-                }
-                yield config.strategies.cellNavigation({
-                    config: config,
-                    root: rootLocator,
-                    page: page,
-                    resolve: resolve,
-                    column: col,
-                    index: idx,
-                    rowLocator: rowLocator,
-                    rowIndex: rowIndex
-                });
-                // Optimization: check if we can get the active cell directly
-                if (config.strategies.getActiveCell) {
-                    const activeCell = yield config.strategies.getActiveCell({
-                        config,
-                        root: rootLocator,
-                        page,
-                        resolve
-                    });
-                    if (activeCell) {
-                        if (config.debug) {
-                            console.log(`[SmartRow.toJSON] switching to active cell locator (r:${activeCell.rowIndex}, c:${activeCell.columnIndex})`);
-                        }
-                        targetCell = activeCell.locator;
-                    }
-                }
-            }
-            const text = yield targetCell.innerText();
-            result[col] = (text || '').trim();
-        }
-        return result;
-    });
-    smart.smartFill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
-        (0, debugUtils_1.logDebug)(config, 'info', 'Filling row', data);
-        for (const [colName, value] of Object.entries(data)) {
-            if (value === undefined)
-                continue;
-            const colIdx = map.get(colName);
-            if (colIdx === undefined) {
-                throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
-            }
-            yield config.strategies.cellNavigation({
-                config: config,
-                root: rootLocator,
-                page: rootLocator.page(),
-                resolve: resolve,
-                column: colName,
-                index: colIdx,
-                rowLocator: rowLocator,
-                rowIndex: rowIndex
-            });
-            const strategy = config.strategies.fill || fill_1.FillStrategies.default;
-            (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);
-            yield strategy({
-                row: smart,
-                columnName: colName,
-                value,
-                index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
-                page: rowLocator.page(),
-                rootLocator,
-                table: table,
-                fillOptions
-            });
-            // Delay after filling
-            yield (0, debugUtils_1.debugDelay)(config, 'getCell');
-        }
-        (0, debugUtils_1.logDebug)(config, 'info', 'Row fill complete');
-    });
-    smart.bringIntoView = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (rowIndex === undefined) {
-            throw new Error('Cannot bring row into view - row index is unknown. Use getRowByIndex() instead of getRow().');
-        }
-        // Scroll row into view using Playwright's built-in method
-        yield rowLocator.scrollIntoViewIfNeeded();
-    });
-    return smart;
-};
-exports.createSmartRow = createSmartRow;

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

@@ -1,18 +0,0 @@
-import { StrategyContext } from '../types';
-/**
- * Defines the contract for a cell navigation strategy.
- * It is responsible for ensuring a specific CELL is visible/focused (navigates to row + column),
- * typically by scrolling or using keyboard navigation.
- */
-export type CellNavigationStrategy = (context: StrategyContext & {
-    column: string;
-    index: number;
-    rowIndex?: number;
-}) => Promise<void>;
-export declare const CellNavigationStrategies: {
-    /**
-     * Default strategy: Assumes column is accessible or standard scrolling works.
-     * No specific action taken other than what Playwright's default locator handling does.
-     */
-    default: () => Promise<void>;
-};

package/dist/src/strategies/columns.js

@@ -1,21 +0,0 @@
-"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.CellNavigationStrategies = void 0;
-exports.CellNavigationStrategies = {
-    /**
-     * Default strategy: Assumes column is accessible or standard scrolling works.
-     * No specific action taken other than what Playwright's default locator handling does.
-     */
-    default: () => __awaiter(void 0, void 0, void 0, function* () {
-        // No-op
-    })
-};

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

@@ -1,7 +0,0 @@
-import type { FillStrategy } from '../types';
-export declare const FillStrategies: {
-    /**
-     * Default strategy: Detects input type and fills accordingly (Text, Select, Checkbox, ContentEditable).
-     */
-    default: ({ row, columnName, value, fillOptions }: Parameters<FillStrategy>[0]) => Promise<void>;
-};

package/dist/src/strategies/fill.js

@@ -1,88 +0,0 @@
-"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.FillStrategies = void 0;
-exports.FillStrategies = {
-    /**
-     * Default strategy: Detects input type and fills accordingly (Text, Select, Checkbox, ContentEditable).
-     */
-    default: (_a) => __awaiter(void 0, [_a], void 0, function* ({ row, columnName, value, fillOptions }) {
-        var _b;
-        const cell = row.getCell(columnName);
-        // Use custom input mapper for this column if provided, otherwise auto-detect
-        let inputLocator;
-        if ((_b = fillOptions === null || fillOptions === void 0 ? void 0 : fillOptions.inputMappers) === null || _b === void 0 ? void 0 : _b[columnName]) {
-            inputLocator = fillOptions.inputMappers[columnName](cell);
-        }
-        else {
-            // Auto-detect input type
-            // Check for text input
-            const textInput = cell.locator('input[type="text"], input:not([type]), textarea').first();
-            const textInputCount = yield textInput.count().catch(() => 0);
-            // Check for select
-            const select = cell.locator('select').first();
-            const selectCount = yield select.count().catch(() => 0);
-            // Check for checkbox/radio
-            const checkbox = cell.locator('input[type="checkbox"], input[type="radio"], [role="checkbox"]').first();
-            const checkboxCount = yield checkbox.count().catch(() => 0);
-            // Check for contenteditable or div-based inputs
-            const contentEditable = cell.locator('[contenteditable="true"]').first();
-            const contentEditableCount = yield contentEditable.count().catch(() => 0);
-            // Determine which input to use (prioritize by commonality)
-            if (textInputCount > 0 && selectCount === 0 && checkboxCount === 0) {
-                inputLocator = textInput;
-            }
-            else if (selectCount > 0) {
-                inputLocator = select;
-            }
-            else if (checkboxCount > 0) {
-                inputLocator = checkbox;
-            }
-            else if (contentEditableCount > 0) {
-                inputLocator = contentEditable;
-            }
-            else if (textInputCount > 0) {
-                // Fallback to text input even if others exist
-                inputLocator = textInput;
-            }
-            else {
-                // No input found - try to click the cell itself (might trigger an editor)
-                inputLocator = cell;
-            }
-        }
-        // Fill based on value type and input type
-        const inputTag = yield inputLocator.evaluate((el) => el.tagName.toLowerCase()).catch(() => 'unknown');
-        const inputType = yield inputLocator.getAttribute('type').catch(() => null);
-        const isContentEditable = yield inputLocator.getAttribute('contenteditable').catch(() => null);
-        // console.log(`[SmartTable] Filling "${columnName}" with value "${value}" (input: ${inputTag}, type: ${inputType})`);
-        if (inputType === 'checkbox' || inputType === 'radio') {
-            // Boolean value for checkbox/radio
-            const shouldBeChecked = Boolean(value);
-            const isChecked = yield inputLocator.isChecked().catch(() => false);
-            if (isChecked !== shouldBeChecked) {
-                yield inputLocator.click();
-            }
-        }
-        else if (inputTag === 'select') {
-            // Select dropdown
-            yield inputLocator.selectOption(String(value));
-        }
-        else if (isContentEditable === 'true') {
-            // Contenteditable div
-            yield inputLocator.click();
-            yield inputLocator.fill(String(value));
-        }
-        else {
-            // Text input, textarea, or generic
-            yield inputLocator.fill(String(value));
-        }
-    })
-};

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

@@ -1,13 +0,0 @@
-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

@@ -1,30 +0,0 @@
-"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

@@ -1,54 +0,0 @@
-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

@@ -1,43 +0,0 @@
-"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/pagination.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,79 +0,0 @@
-"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/resolution.d.ts

@@ -1,22 +0,0 @@
-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

@@ -1,30 +0,0 @@
-"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();
-        }
-    }
-};

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

@@ -1,12 +0,0 @@
-import type { SortingStrategy } from '../types';
-/**
- * A collection of pre-built sorting strategies.
- */
-export declare const SortingStrategies: {
-    /**
-     * A sorting strategy that interacts with column headers based on ARIA attributes.
-     * - `doSort`: Clicks the header repeatedly until the desired `aria-sort` state is achieved.
-     * - `getSortState`: Reads the `aria-sort` attribute from the header.
-     */
-    AriaSort: () => SortingStrategy;
-};