@rickcedwhat/playwright-smart-table 6.1.0 → 6.1.1

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;
-};

package/dist/src/strategies/sorting.js

@@ -1,68 +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.SortingStrategies = void 0;
-/**
- * A collection of pre-built sorting strategies.
- */
-exports.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: () => {
-        return {
-            doSort(_a) {
-                return __awaiter(this, arguments, void 0, function* ({ columnName, direction, context }) {
-                    const { resolve, config, root } = context;
-                    const headerLoc = resolve(config.headerSelector, root);
-                    const headers = yield headerLoc.all();
-                    const headerTexts = yield Promise.all(headers.map(h => h.innerText()));
-                    const columnIndex = headerTexts.findIndex(text => text.trim() === columnName);
-                    if (columnIndex === -1) {
-                        throw new Error(`[AriaSort] Header with text "${columnName}" not found.`);
-                    }
-                    const targetHeader = headers[columnIndex];
-                    // Click repeatedly to cycle through sort states
-                    for (let i = 0; i < 3; i++) { // Max 3 clicks to prevent infinite loops (none -> asc -> desc)
-                        const currentState = yield targetHeader.getAttribute('aria-sort');
-                        const mappedState = currentState === 'ascending' ? 'asc' : currentState === 'descending' ? 'desc' : 'none';
-                        if (mappedState === direction) {
-                            return; // Desired state achieved
-                        }
-                        yield targetHeader.click();
-                    }
-                    throw new Error(`[AriaSort] Could not achieve sort direction "${direction}" for column "${columnName}" after 3 clicks.`);
-                });
-            },
-            getSortState(_a) {
-                return __awaiter(this, arguments, void 0, function* ({ columnName, context }) {
-                    const { resolve, config, root } = context;
-                    const headerLoc = resolve(config.headerSelector, root);
-                    const headers = yield headerLoc.all();
-                    const headerTexts = yield Promise.all(headers.map(h => h.innerText()));
-                    const columnIndex = headerTexts.findIndex(text => text.trim() === columnName);
-                    if (columnIndex === -1) {
-                        return 'none'; // Header not found, so it's not sorted
-                    }
-                    const targetHeader = headers[columnIndex];
-                    const ariaSort = yield targetHeader.getAttribute('aria-sort');
-                    if (ariaSort === 'ascending')
-                        return 'asc';
-                    if (ariaSort === 'descending')
-                        return 'desc';
-                    return 'none';
-                });
-            },
-        };
-    },
-};

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

@@ -1,22 +0,0 @@
-import type { PaginationStrategy, SortingStrategy, FillStrategy } from '../types';
-/**
- * Validates that a pagination strategy returns a boolean.
- * @param result - The result from a pagination strategy
- * @param strategyName - Name of the strategy for error messages
- */
-export declare function validatePaginationResult(result: any, strategyName?: string): boolean;
-/**
- * Validates that a pagination strategy is properly configured.
- * @param strategy - The pagination strategy to validate
- */
-export declare function validatePaginationStrategy(strategy: any): strategy is PaginationStrategy;
-/**
- * Validates that a sorting strategy has the required methods.
- * @param strategy - The sorting strategy to validate
- */
-export declare function validateSortingStrategy(strategy: any): strategy is SortingStrategy;
-/**
- * Validates that a fill strategy is properly configured.
- * @param strategy - The fill strategy to validate
- */
-export declare function validateFillStrategy(strategy: any): strategy is FillStrategy;

package/dist/src/strategies/validation.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePaginationResult = validatePaginationResult;
-exports.validatePaginationStrategy = validatePaginationStrategy;
-exports.validateSortingStrategy = validateSortingStrategy;
-exports.validateFillStrategy = validateFillStrategy;
-/**
- * Validates that a pagination strategy returns a boolean.
- * @param result - The result from a pagination strategy
- * @param strategyName - Name of the strategy for error messages
- */
-function validatePaginationResult(result, strategyName = 'Custom Pagination Strategy') {
-    if (typeof result !== 'boolean') {
-        throw new Error(`[${strategyName}] Pagination strategy must return a boolean (true if paginated, false if no more pages). ` +
-            `Received: ${typeof result} (${JSON.stringify(result)})`);
-    }
-    return result;
-}
-/**
- * Validates that a pagination strategy is properly configured.
- * @param strategy - The pagination strategy to validate
- */
-function validatePaginationStrategy(strategy) {
-    if (typeof strategy !== 'function') {
-        throw new Error(`Pagination strategy must be a function. Received: ${typeof strategy}`);
-    }
-    return true;
-}
-/**
- * Validates that a sorting strategy has the required methods.
- * @param strategy - The sorting strategy to validate
- */
-function validateSortingStrategy(strategy) {
-    if (!strategy || typeof strategy !== 'object') {
-        throw new Error(`Sorting strategy must be an object with 'doSort' and 'getSortState' methods. Received: ${typeof strategy}`);
-    }
-    if (typeof strategy.doSort !== 'function') {
-        throw new Error(`Sorting strategy must have a 'doSort' method. Missing or not a function.`);
-    }
-    if (typeof strategy.getSortState !== 'function') {
-        throw new Error(`Sorting strategy must have a 'getSortState' method. Missing or not a function.`);
-    }
-    return true;
-}
-/**
- * Validates that a fill strategy is properly configured.
- * @param strategy - The fill strategy to validate
- */
-function validateFillStrategy(strategy) {
-    if (typeof strategy !== 'function') {
-        throw new Error(`Fill strategy must be a function. Received: ${typeof strategy}`);
-    }
-    return true;
-}

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

@@ -1,32 +0,0 @@
-import { PaginationStrategy } from '../types';
-/**
- * Strategies for handling virtualized pagination where:
- * 1. The total row count might not change (DOM recycling).
- * 2. We need to check for *new content* appearing to confirm pagination success.
- */
-export declare const virtualizedInfiniteScroll: (options?: {
-    /** Selector for the scrollable container. Defaults to table root. */
-    scrollTarget?: string;
-    /** Amount to scroll in pixels. Default 500. */
-    scrollAmount?: number;
-    /** Timeout to wait for content stability. Default 500ms. */
-    stabilityTimeout?: number;
-    /** Max retries to detect content change. Default 3. */
-    retries?: number;
-    /** force use of JS scrollTop property instead of mouse wheel. Default: false */
-    useJsScroll?: boolean;
-}) => PaginationStrategy;
-export declare const VirtualizedPaginationStrategies: {
-    virtualInfiniteScroll: (options?: {
-        /** Selector for the scrollable container. Defaults to table root. */
-        scrollTarget?: string;
-        /** Amount to scroll in pixels. Default 500. */
-        scrollAmount?: number;
-        /** Timeout to wait for content stability. Default 500ms. */
-        stabilityTimeout?: number;
-        /** Max retries to detect content change. Default 3. */
-        retries?: number;
-        /** force use of JS scrollTop property instead of mouse wheel. Default: false */
-        useJsScroll?: boolean;
-    }) => PaginationStrategy;
-};