@rickcedwhat/playwright-smart-table 3.2.0 → 5.0.0

package/dist/filterEngine.d.ts

@@ -0,0 +1,11 @@
+import { Locator, Page } from "@playwright/test";
+import { FinalTableConfig } from "./types";
+export declare class FilterEngine {
+    private config;
+    private resolve;
+    constructor(config: FinalTableConfig, resolve: (selector: any, parent: Locator | Page) => Locator);
+    /**
+     * Applies filters to a set of rows.
+     */
+    applyFilters(baseRows: Locator, filters: Record<string, string | RegExp | number>, map: Map<string, number>, exact: boolean, page: Page): Locator;
+}

package/dist/filterEngine.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterEngine = void 0;
+class FilterEngine {
+    constructor(config, resolve) {
+        this.config = config;
+        this.resolve = resolve;
+    }
+    /**
+     * Applies filters to a set of rows.
+     */
+    applyFilters(baseRows, filters, map, exact, page) {
+        let filtered = baseRows;
+        // Iterate through each filter criteria
+        for (const [colName, value] of Object.entries(filters)) {
+            // Find column index
+            const colIndex = map.get(colName);
+            // TODO: Use ColumnStrategy for better resolution error handling
+            if (colIndex === undefined) {
+                throw new Error(`Filter Error: Column "${colName}" not found.`);
+            }
+            const filterVal = typeof value === 'number' ? String(value) : value;
+            // Use strategy if provided (For future: configured filter strategies)
+            // But for now, we implement the default logic or use custom if we add it to config later
+            // Default Filter Logic
+            const cellTemplate = this.resolve(this.config.cellSelector, page);
+            // This logic assumes 1:1 row-to-cell mapping based on index.
+            // filter({ has: ... }) checks if the row *contains* the matching cell.
+            // But we need to be specific about WHICH cell.
+            // Locator filtering by `has: locator.nth(index)` works if `locator` search is relative to the row.
+            filtered = filtered.filter({
+                has: cellTemplate.nth(colIndex).getByText(filterVal, { exact }),
+            });
+        }
+        return filtered;
+    }
+}
+exports.FilterEngine = FilterEngine;

package/dist/smartRow.d.ts

@@ -0,0 +1,7 @@
+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/smartRow.js

@@ -0,0 +1,152 @@
+"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");
+/**
+ * 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) {
+            const availableColumns = Array.from(map.keys());
+            throw new Error(`Column "${colName}" not found. Available: ${availableColumns.join(', ')}`);
+        }
+        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* () {
+        for (const [colName, value] of Object.entries(data)) {
+            const colIdx = map.get(colName);
+            if (colIdx === undefined) {
+                throw new Error(`Column "${colName}" not found in fill data.`);
+            }
+            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;
+            yield strategy({
+                row: smart,
+                columnName: colName,
+                value,
+                index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
+                page: rowLocator.page(),
+                rootLocator,
+                table: table,
+                fillOptions
+            });
+        }
+    });
+    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/strategies/columns.d.ts

@@ -1,30 +1,18 @@
 import { StrategyContext } from '../types';
 /**
- * Defines the contract for a column navigation strategy.
- * It is responsible for ensuring a specific column is visible/focused,
- * typically by scrolling or navigating to it.
+ * 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 ColumnStrategy = (context: StrategyContext & {
+export type CellNavigationStrategy = (context: StrategyContext & {
     column: string;
     index: number;
     rowIndex?: number;
 }) => Promise<void>;
-export declare const ColumnStrategies: {
+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>;
-    /**
-     * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate to the target column index.
-     *
-     * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
-     * or where keyboard navigation is the primary way to move focus.
-     */
-    keyboard: (context: StrategyContext & {
-        column: string;
-        index: number;
-        rowIndex?: number;
-    }) => Promise<void>;
 };

package/dist/strategies/columns.js

@@ -9,45 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnStrategies = void 0;
-exports.ColumnStrategies = {
+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
-    }),
-    /**
-     * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate to the target column index.
-     *
-     * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
-     * or where keyboard navigation is the primary way to move focus.
-     */
-    keyboard: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const { root, page, index, rowLocator, rowIndex } = context;
-        if (typeof rowIndex !== 'number') {
-            throw new Error('Row index is required for keyboard navigation');
-        }
-        console.log(`[ColumnStrat:keyboard] Using Row Index Navigation: Row ${rowIndex}, Col ${index}`);
-        yield root.focus();
-        yield page.waitForTimeout(200);
-        // Robust Navigation:
-        // 1. Jump to Top-Left (Reset) - Sequence for Cross-OS (Mac/Windows)
-        yield page.keyboard.press('Control+Home');
-        yield page.keyboard.press('Meta+ArrowUp'); // Mac Go-To-Top
-        yield page.keyboard.press('Home'); // Ensure start of row
-        yield page.waitForTimeout(300);
-        // 2. Move Down to Target Row
-        for (let i = 0; i < rowIndex; i++) {
-            yield page.keyboard.press('ArrowDown');
-        }
-        // 3. Move Right to Target Column
-        for (let i = 0; i < index; i++) {
-            yield page.keyboard.press('ArrowRight');
-        }
-        yield page.waitForTimeout(100);
-        yield page.waitForTimeout(100);
     })
 };

package/dist/strategies/headers.d.ts

@@ -10,20 +10,4 @@ export declare const HeaderStrategies: {
      * This is fast but won't find virtualized columns off-screen.
      */
     visible: ({ config, resolve, root }: StrategyContext) => Promise<string[]>;
-    /**
-     * Scans for headers by finding a scrollable container and setting scrollLeft.
-     */
-    scrollRight: (context: StrategyContext, options?: {
-        limit?: number;
-        selector?: string;
-        scrollAmount?: number;
-    }) => Promise<string[]>;
-    /**
-     * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate cell-by-cell, collecting headers found along the way.
-     */
-    keyboard: (context: StrategyContext, options?: {
-        limit?: number;
-        maxSilentClicks?: number;
-    }) => Promise<string[]>;
 };

package/dist/strategies/headers.js

@@ -26,117 +26,5 @@ exports.HeaderStrategies = {
         }
         const texts = yield headerLoc.allInnerTexts();
         return texts.map(t => t.trim());
-    }),
-    /**
-     * Scans for headers by finding a scrollable container and setting scrollLeft.
-     */
-    scrollRight: (context, options) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        const { resolve, config, root, page } = context;
-        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 20;
-        const scrollAmount = (_b = options === null || options === void 0 ? void 0 : options.scrollAmount) !== null && _b !== void 0 ? _b : 300;
-        const collectedHeaders = new Set();
-        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 => t.trim());
-        });
-        // Initial capture
-        let currentHeaders = yield getVisible();
-        currentHeaders.forEach(h => collectedHeaders.add(h));
-        // Find scroller using JS for better iframe/shadow support
-        const scrollerHandle = yield root.evaluateHandle((el, selector) => {
-            if (selector && el.matches(selector))
-                return el;
-            const effectiveSelector = selector || '.dvn-scroller';
-            const ancestor = el.closest(effectiveSelector);
-            if (ancestor)
-                return ancestor;
-            return document.querySelector(effectiveSelector);
-        }, options === null || options === void 0 ? void 0 : options.selector);
-        const isScrollerFound = yield scrollerHandle.evaluate(el => !!el);
-        if (isScrollerFound) {
-            yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
-            yield page.waitForTimeout(200);
-            for (let i = 0; i < limit; i++) {
-                const sizeBefore = collectedHeaders.size;
-                yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
-                yield page.waitForTimeout(300);
-                const newHeaders = yield getVisible();
-                console.log(`[HeaderStrat:scrollRight] Scrolled ${scrollAmount}, found: ${newHeaders.length} visible.`);
-                newHeaders.forEach(h => collectedHeaders.add(h));
-                if (collectedHeaders.size === sizeBefore) {
-                    yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
-                    yield page.waitForTimeout(300);
-                    const retryHeaders = yield getVisible();
-                    retryHeaders.forEach(h => collectedHeaders.add(h));
-                    if (collectedHeaders.size === sizeBefore)
-                        break;
-                }
-            }
-        }
-        else {
-            console.warn("HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
-        }
-        // Scroll back to start
-        yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
-        yield page.waitForTimeout(200);
-        return Array.from(collectedHeaders);
-    }),
-    /**
-     * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
-     * to navigate cell-by-cell, collecting headers found along the way.
-     */
-    keyboard: (context, options) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        const { resolve, config, root, page } = context;
-        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 100;
-        const maxSilentClicks = (_b = options === null || options === void 0 ? void 0 : options.maxSilentClicks) !== null && _b !== void 0 ? _b : 10;
-        const collectedHeaders = new Set();
-        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 => t.trim());
-        });
-        // 1. Initial capture
-        let currentHeaders = yield getVisible();
-        currentHeaders.forEach(h => collectedHeaders.add(h));
-        // 2. Click to focus
-        // Try to find the canvas sibling specifically for Glide, otherwise click root
-        const canvas = root.locator('xpath=ancestor::div').locator('canvas').first();
-        if ((yield canvas.count()) > 0) {
-            // Click lower in the canvas to hit a data cell instead of header
-            // Adjusted to y=60 to target Row 1
-            yield canvas.click({ position: { x: 50, y: 60 }, force: true }).catch(() => { });
-        }
-        else {
-            yield root.click({ position: { x: 10, y: 10 }, force: true }).catch(() => { });
-        }
-        // Reset to home
-        yield page.keyboard.press('Control+Home');
-        yield page.keyboard.press('Home');
-        yield page.waitForTimeout(200);
-        currentHeaders = yield getVisible();
-        currentHeaders.forEach(h => collectedHeaders.add(h));
-        // 3. Navigate right loop
-        let silentCounter = 0;
-        for (let i = 0; i < limit; i++) {
-            const sizeBefore = collectedHeaders.size;
-            yield page.keyboard.press('ArrowRight');
-            yield page.waitForTimeout(100);
-            const newHeaders = yield getVisible();
-            console.log(`[HeaderStrat:keyboard] Step ${i}, found visible: ${newHeaders}`);
-            newHeaders.forEach(h => collectedHeaders.add(h));
-            if (collectedHeaders.size === sizeBefore) {
-                silentCounter++;
-            }
-            else {
-                silentCounter = 0;
-            }
-            if (silentCounter >= maxSilentClicks) {
-                break;
-            }
-        }
-        return Array.from(collectedHeaders);
-    }),
+    })
 };

package/dist/strategies/index.d.ts

@@ -1,2 +1,27 @@
 export * from './pagination';
 export * from './sorting';
+export * from './columns';
+export * from './headers';
+export * from './fill';
+export * from './resolution';
+export declare const Strategies: {
+    Pagination: {
+        clickNext: (nextButtonSelector: import("..").Selector, timeout?: number) => import("..").PaginationStrategy;
+        infiniteScroll: (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;
+    };
+};

package/dist/strategies/index.js

@@ -14,6 +14,24 @@ 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 });
-// src/strategies/index.ts
+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");
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./sorting"), exports);
+__exportStar(require("./columns"), exports);
+__exportStar(require("./headers"), exports);
+__exportStar(require("./fill"), exports);
+__exportStar(require("./resolution"), 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,
+};

package/dist/strategies/pagination.d.ts

@@ -4,27 +4,6 @@ export declare const PaginationStrategies: {
      * Strategy: Clicks a "Next" button and waits for the first row of data to change.
      */
     clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
-    /**
-     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
-     */
-    clickLoadMore: (buttonSelector: Selector, timeout?: number) => PaginationStrategy;
-    /**
-     * Strategy: Scrolls to the bottom and waits for more rows to appear.
-     */
-    infiniteScroll: (timeout?: number) => PaginationStrategy;
-};
-/**
- * @deprecated Use `PaginationStrategies` instead. This alias will be removed in a future major version.
- */
-export declare const TableStrategies: {
-    /**
-     * Strategy: Clicks a "Next" button and waits for the first row of data to change.
-     */
-    clickNext: (nextButtonSelector: Selector, timeout?: number) => PaginationStrategy;
-    /**
-     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
-     */
-    clickLoadMore: (buttonSelector: Selector, timeout?: number) => PaginationStrategy;
     /**
      * Strategy: Scrolls to the bottom and waits for more rows to appear.
      */

package/dist/strategies/pagination.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableStrategies = exports.PaginationStrategies = void 0;
+exports.PaginationStrategies = void 0;
 const utils_1 = require("../utils");
 exports.PaginationStrategies = {
     /**
@@ -31,24 +31,6 @@ exports.PaginationStrategies = {
             return success;
         });
     },
-    /**
-     * Strategy: Clicks a "Load More" button and waits for the row count to increase.
-     */
-    clickLoadMore: (buttonSelector, timeout = 5000) => {
-        return (_a) => __awaiter(void 0, [_a], void 0, function* ({ root, config, resolve, page }) {
-            const loadMoreBtn = resolve(buttonSelector, root).first();
-            if (!(yield loadMoreBtn.isVisible()) || !(yield loadMoreBtn.isEnabled())) {
-                return false;
-            }
-            const rows = resolve(config.rowSelector, root);
-            const oldCount = yield rows.count();
-            yield loadMoreBtn.click();
-            return yield (0, utils_1.waitForCondition)(() => __awaiter(void 0, void 0, void 0, function* () {
-                const newCount = yield rows.count();
-                return newCount > oldCount;
-            }), timeout, page);
-        });
-    },
     /**
      * Strategy: Scrolls to the bottom and waits for more rows to appear.
      */
@@ -66,7 +48,3 @@ exports.PaginationStrategies = {
         });
     }
 };
-/**
- * @deprecated Use `PaginationStrategies` instead. This alias will be removed in a future major version.
- */
-exports.TableStrategies = exports.PaginationStrategies;

package/dist/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/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();
+        }
+    }
+};

package/dist/strategies/validation.d.ts

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