@rickcedwhat/playwright-smart-table 6.7.4 → 6.7.6

package/dist/types.d.ts

@@ -259,7 +259,8 @@ import { NavigationPrimitives } from './strategies/columns';
  */
 export type { ColumnResolutionStrategy } from './strategies/resolution';
 /**
- * Strategy to filter rows based on criteria.
+ * Strategy to filter rows based on criteria. Applied when using getRow/findRow/findRows with filters.
+ * The default engine handles string, RegExp, number, and function (cell) => Locator filters.
  */
 export interface FilterStrategy {
     apply(options: {
@@ -273,7 +274,8 @@ export interface FilterStrategy {
     }): Locator;
 }
 /**
- * Strategy to check if the table or rows are loading.
+ * Strategy to check if the table or rows are loading. Used after pagination/sort to wait for content.
+ * E.g. isHeaderLoading for init stability; isTableLoading after sort/pagination.
  */
 export interface LoadingStrategy {
     isTableLoading?: (context: TableContext) => Promise<boolean>;
@@ -300,26 +302,21 @@ export interface TableStrategies {
     getCellLocator?: GetCellLocatorFn;
     /** Function to get the currently active/focused cell */
     getActiveCell?: GetActiveCellFn;
+    /**
+     * Strategy for filtering rows. If present, FilterEngine will delegate filter application
+     * to this pluggable strategy.
+     */
+    filter?: FilterStrategy;
     /**
      * Hook called before each cell value is read in toJSON and columnOverrides.read.
      * Fires for both the default innerText extraction and custom read mappers.
      * Useful for scrolling off-screen columns into view in horizontally virtualized tables.
      */
     beforeCellRead?: BeforeCellReadFn;
-    /** Custom helper to check if a table is fully loaded/ready */
-    isTableLoaded?: (args: TableContext) => Promise<boolean>;
-    /** Custom helper to check if a row is fully loaded/ready */
-    isRowLoaded?: (args: {
-        row: Locator;
-        index: number;
-    }) => Promise<boolean>;
-    /** Custom helper to check if a cell is fully loaded/ready (e.g. for editing) */
-    isCellLoaded?: (args: {
-        cell: Locator;
-        column: string;
-        row: Locator;
-    }) => Promise<boolean>;
-    /** Strategy for detecting loading states */
+    /**
+     * Strategy for detecting loading states. Use this for table-, row-, and header-level readiness.
+     * E.g. after sort/pagination, the engine uses loading.isTableLoading when present.
+     */
     loading?: LoadingStrategy;
 }
 export interface TableConfig<T = any> {
@@ -328,7 +325,7 @@ export interface TableConfig<T = any> {
     /** Selector for the table rows */
     rowSelector?: string;
     /** Selector for the cells within a row */
-    cellSelector?: string;
+    cellSelector?: string | ((row: Locator) => Locator);
     /** Number of pages to scan for verification */
     maxPages?: number;
     /** Hook to rename columns dynamically */
@@ -355,7 +352,7 @@ export interface TableConfig<T = any> {
 export interface FinalTableConfig<T = any> extends TableConfig<T> {
     headerSelector: string | ((root: Locator) => Locator);
     rowSelector: string;
-    cellSelector: string;
+    cellSelector: string | ((row: Locator) => Locator);
     maxPages: number;
     autoScroll: boolean;
     debug?: TableConfig['debug'];
@@ -427,6 +424,8 @@ export interface TableResult<T = any> extends AsyncIterable<{
     /**
      * Finds a row by filters on the current page only. Returns immediately (sync).
      * Throws error if table is not initialized.
+     * @note The returned SmartRow may have `rowIndex` as 0 when the match is not the first row.
+     * Use getRowByIndex(index) when you need a known index (e.g. for bringIntoView()).
      */
     getRow: (filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
@@ -450,10 +449,10 @@ export interface TableResult<T = any> extends AsyncIterable<{
     /**
      * ASYNC: Searches for all matching rows across pages using pagination.
      * Auto-initializes the table if not already initialized.
-     * @param filters - The filter criteria to match
+     * @param filters - The filter criteria to match (omit or pass {} for all rows)
      * @param options - Search options including exact match and max pages
      */
-    findRows: (filters: Record<string, FilterValue>, options?: {
+    findRows: (filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
     }) => Promise<SmartRowArray<T>>;

package/dist/useTable.js

@@ -21,6 +21,9 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function reject(value) { resume("throw", value); }
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTable = void 0;
 const minimalConfigContext_1 = require("./minimalConfigContext");
@@ -28,10 +31,11 @@ const validation_1 = require("./strategies/validation");
 const loading_1 = require("./strategies/loading");
 const fill_1 = require("./strategies/fill");
 const headers_1 = require("./strategies/headers");
-const smartRow_1 = require("./smartRow");
+const smartRow_1 = __importDefault(require("./smartRow"));
 const filterEngine_1 = require("./filterEngine");
 const tableMapper_1 = require("./engine/tableMapper");
 const rowFinder_1 = require("./engine/rowFinder");
+const tableIteration_1 = require("./engine/tableIteration");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
 const elementTracker_1 = require("./utils/elementTracker");
@@ -91,10 +95,12 @@ const useTable = (rootLocator, configOptions = {}) => {
     let finalTable = null;
     // Helper factory
     const _makeSmart = (rowLocator, map, rowIndex, tablePageIndex) => {
-        return (0, smartRow_1.createSmartRow)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex);
+        return (0, smartRow_1.default)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable, tablePageIndex);
     };
     const tableState = { currentPageIndex: 0 };
     const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState);
+    /** Builds a full TableContext/StrategyContext with getHeaderCell, getHeaders, scrollToColumn. Set after result is created. */
+    let createStrategyContext = () => ({ root: rootLocator, config, page: rootLocator.page(), resolve });
     const _getCleanHtml = (loc) => __awaiter(void 0, void 0, void 0, function* () {
         return loc.evaluate((el) => {
             const clone = el.cloneNode(true);
@@ -128,7 +134,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     });
     // Default: goNext (one page). Pass useBulk true to prefer goNextBulk. "How far" uses numeric return when strategy provides it.
     const _advancePage = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (useBulk = false) {
-        const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell, getHeaders: result.getHeaders, scrollToColumn: result.scrollToColumn };
+        const context = createStrategyContext();
         const pagination = config.strategies.pagination;
         let rawResult;
         if (useBulk && (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk)) {
@@ -183,11 +189,10 @@ const useTable = (rootLocator, configOptions = {}) => {
         reset: () => __awaiter(void 0, void 0, void 0, function* () {
             var _a;
             log("Resetting table...");
-            const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell };
-            yield config.onReset(context);
+            yield config.onReset(createStrategyContext());
             if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goToFirst) {
                 log("Auto-navigating to first page...");
-                yield config.strategies.pagination.goToFirst(context);
+                yield config.strategies.pagination.goToFirst(createStrategyContext());
             }
             else if (hasPaginationInConfig) {
                 log("No goToFirst strategy configured. Table may not be on page 1.");
@@ -208,7 +213,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             if (!map)
                 throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.findRows() which auto-initialize.');
             const allRows = resolve(config.rowSelector, rootLocator);
-            const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page());
+            const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page(), rootLocator);
             const rowLocator = matchedRows.first();
             return _makeSmart(rowLocator, map, 0); // fallback index 0
         },
@@ -220,11 +225,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             return _makeSmart(rowLocator, map, index);
         },
         findRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
-            // @ts-ignore
             return rowFinder.findRow(filters, options);
         }),
         findRows: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
-            return rowFinder.findRows(filters, options);
+            return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
         }),
         isInitialized: () => {
             return tableMapper.isInitialized();
@@ -236,7 +240,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
                 log(`Applying sort for column "${columnName}" (${direction})`);
-                const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell };
+                const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
                 const maxRetries = 3;
                 for (let i = 0; i < maxRetries; i++) {
                     const currentState = yield config.strategies.sorting.getSortState({ columnName, context });
@@ -264,7 +268,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 yield _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
-                const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell };
+                const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
                 return config.strategies.sorting.getSortState({ columnName, context });
             })
         },
@@ -299,189 +303,42 @@ const useTable = (rootLocator, configOptions = {}) => {
                 }
             });
         },
-        // ─── Private row-iteration engine ────────────────────────────────────────
+        // ─── Row iteration (delegated to engine/tableIteration) ──────────────────
         forEach: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            var _a, _b, _c, _d;
             yield _autoInit();
-            const map = tableMapper.getMapSync();
-            const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
-            const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
-            const dedupeKeys = dedupeStrategy ? new Set() : null;
-            const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
-            const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-            const tracker = new elementTracker_1.ElementTracker('forEach');
-            try {
-                let rowIndex = 0;
-                let stopped = false;
-                let pagesScanned = 1;
-                const stop = () => { stopped = true; };
-                while (!stopped) {
-                    const rowLocators = resolve(config.rowSelector, rootLocator);
-                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                    const pageRows = yield rowLocators.all();
-                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i));
-                    if (parallel) {
-                        yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                            if (stopped)
-                                return;
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    return;
-                                dedupeKeys.add(key);
-                            }
-                            yield callback({ row, rowIndex: row.rowIndex, stop });
-                        })));
-                    }
-                    else {
-                        for (const row of smartRows) {
-                            if (stopped)
-                                break;
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    continue;
-                                dedupeKeys.add(key);
-                            }
-                            yield callback({ row, rowIndex: row.rowIndex, stop });
-                        }
-                    }
-                    rowIndex += smartRows.length;
-                    if (stopped || pagesScanned >= effectiveMaxPages)
-                        break;
-                    if (!(yield _advancePage(useBulk)))
-                        break;
-                    pagesScanned++;
-                }
-            }
-            finally {
-                yield tracker.cleanup(rootLocator.page());
-            }
+            yield (0, tableIteration_1.runForEach)({
+                getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                getMap: () => tableMapper.getMapSync(),
+                advancePage: _advancePage,
+                makeSmartRow: (loc, map, idx, pageIdx) => _makeSmart(loc, map, idx, pageIdx),
+                createSmartRowArray: smartRowArray_1.createSmartRowArray,
+                config,
+                getPage: () => rootLocator.page(),
+            }, callback, options);
         }),
         map: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            var _a, _b, _c, _d;
             yield _autoInit();
-            const map = tableMapper.getMapSync();
-            const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
-            const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
-            const dedupeKeys = dedupeStrategy ? new Set() : null;
-            const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : true;
-            const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-            const tracker = new elementTracker_1.ElementTracker('map');
-            const results = [];
-            try {
-                let rowIndex = 0;
-                let stopped = false;
-                let pagesScanned = 1;
-                const stop = () => { stopped = true; };
-                while (!stopped) {
-                    const rowLocators = resolve(config.rowSelector, rootLocator);
-                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                    const pageRows = yield rowLocators.all();
-                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i));
-                    if (parallel) {
-                        const SKIP = Symbol('skip');
-                        const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    return SKIP;
-                                dedupeKeys.add(key);
-                            }
-                            return callback({ row, rowIndex: row.rowIndex, stop });
-                        })));
-                        for (const r of pageResults) {
-                            if (r !== SKIP)
-                                results.push(r);
-                        }
-                    }
-                    else {
-                        for (const row of smartRows) {
-                            if (stopped)
-                                break;
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    continue;
-                                dedupeKeys.add(key);
-                            }
-                            results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
-                        }
-                    }
-                    rowIndex += smartRows.length;
-                    if (stopped || pagesScanned >= effectiveMaxPages)
-                        break;
-                    if (!(yield _advancePage(useBulk)))
-                        break;
-                    pagesScanned++;
-                }
-            }
-            finally {
-                yield tracker.cleanup(rootLocator.page());
-            }
-            return results;
+            return (0, tableIteration_1.runMap)({
+                getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                getMap: () => tableMapper.getMapSync(),
+                advancePage: _advancePage,
+                makeSmartRow: (loc, map, idx, pageIdx) => _makeSmart(loc, map, idx, pageIdx),
+                createSmartRowArray: smartRowArray_1.createSmartRowArray,
+                config,
+                getPage: () => rootLocator.page(),
+            }, callback, options);
         }),
         filter: (predicate_1, ...args_1) => __awaiter(void 0, [predicate_1, ...args_1], void 0, function* (predicate, options = {}) {
-            var _a, _b, _c, _d;
             yield _autoInit();
-            const map = tableMapper.getMapSync();
-            const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
-            const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
-            const dedupeKeys = dedupeStrategy ? new Set() : null;
-            const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
-            const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
-            const tracker = new elementTracker_1.ElementTracker('filter');
-            const matched = [];
-            try {
-                let rowIndex = 0;
-                let stopped = false;
-                let pagesScanned = 1;
-                const stop = () => { stopped = true; };
-                while (!stopped) {
-                    const rowLocators = resolve(config.rowSelector, rootLocator);
-                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                    const pageRows = yield rowLocators.all();
-                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i, pagesScanned - 1));
-                    if (parallel) {
-                        const flags = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    return false;
-                                dedupeKeys.add(key);
-                            }
-                            return predicate({ row, rowIndex: row.rowIndex, stop });
-                        })));
-                        smartRows.forEach((row, i) => { if (flags[i])
-                            matched.push(row); });
-                    }
-                    else {
-                        for (const row of smartRows) {
-                            if (stopped)
-                                break;
-                            if (dedupeKeys) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key))
-                                    continue;
-                                dedupeKeys.add(key);
-                            }
-                            if (yield predicate({ row, rowIndex: row.rowIndex, stop })) {
-                                matched.push(row);
-                            }
-                        }
-                    }
-                    rowIndex += smartRows.length;
-                    if (stopped || pagesScanned >= effectiveMaxPages)
-                        break;
-                    if (!(yield _advancePage(useBulk)))
-                        break;
-                    pagesScanned++;
-                }
-            }
-            finally {
-                yield tracker.cleanup(rootLocator.page());
-            }
-            return (0, smartRowArray_1.createSmartRowArray)(matched);
+            return (0, tableIteration_1.runFilter)({
+                getRowLocators: () => resolve(config.rowSelector, rootLocator),
+                getMap: () => tableMapper.getMapSync(),
+                advancePage: _advancePage,
+                makeSmartRow: (loc, map, idx, pageIdx) => _makeSmart(loc, map, idx, pageIdx),
+                createSmartRowArray: smartRowArray_1.createSmartRowArray,
+                config,
+                getPage: () => rootLocator.page(),
+            }, predicate, options);
         }),
         generateConfig: () => __awaiter(void 0, void 0, void 0, function* () {
             const html = yield _getCleanHtml(rootLocator);
@@ -494,6 +351,15 @@ const useTable = (rootLocator, configOptions = {}) => {
             return result.generateConfig();
         }),
     };
+    createStrategyContext = () => ({
+        root: rootLocator,
+        config,
+        page: rootLocator.page(),
+        resolve,
+        getHeaderCell: result.getHeaderCell,
+        getHeaders: result.getHeaders,
+        scrollToColumn: result.scrollToColumn,
+    });
     finalTable = result;
     return result;
 };

package/dist/utils/sentinel.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Internal symbol used to mark a SmartRow as a "sentinel" (row not found).
+ * Use SmartRow.wasFound() to detect; do not rely on this symbol in user code.
+ */
+export declare const SENTINEL_ROW: unique symbol;

package/dist/utils/sentinel.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENTINEL_ROW = void 0;
+/**
+ * Internal symbol used to mark a SmartRow as a "sentinel" (row not found).
+ * Use SmartRow.wasFound() to detect; do not rely on this symbol in user code.
+ */
+exports.SENTINEL_ROW = Symbol.for('playwright-smart-table.sentinelRow');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.7.4",
+  "version": "6.7.6",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -27,12 +27,11 @@
     "pretest": "npm run clean-port",
     "posttest": "npm run clean-port",
     "test": "npm run test:unit && npx playwright test",
-    "test:unit": "vitest run --reporter=verbose --reporter=html",
+    "test:unit": "vitest run --coverage --reporter=verbose --reporter=html",
     "test:unit:ui": "vitest --ui",
     "pretest:e2e": "npm run clean-port",
     "posttest:e2e": "npm run clean-port",
     "test:e2e": "npx playwright test",
-    "test:compatibility": "npm run clean-port && npx playwright test compatibility",
     "prepare": "husky install"
   },
   "keywords": [
@@ -47,6 +46,7 @@
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "@types/node": "^22.10.5",
+    "@vitest/coverage-v8": "^4.0.18",
     "@vitest/ui": "^4.0.18",
     "happy-dom": "^20.6.1",
     "husky": "^9.1.7",
@@ -54,4 +54,4 @@
     "vitepress": "^1.6.4",
     "vitest": "^4.0.18"
   }
-}
+}

package/dist/plugins.d.ts

@@ -1,44 +0,0 @@
-export declare const Plugins: {
-    RDG: {
-        Strategies: {
-            header: (context: import("./types").TableContext) => Promise<string[]>;
-            getCellLocator: ({ row, columnIndex }: any) => any;
-            navigation: {
-                goRight: ({ root, page }: any) => Promise<void>;
-                goLeft: ({ root, page }: any) => Promise<void>;
-                goDown: ({ root, page }: any) => Promise<void>;
-                goUp: ({ root, page }: any) => Promise<void>;
-                goHome: ({ root, page }: any) => Promise<void>;
-            };
-            pagination: import("./types").PaginationPrimitives;
-        };
-    };
-    Glide: {
-        Strategies: {
-            fill: import("./types").FillStrategy;
-            fillSimple: import("./types").FillStrategy;
-            pagination: import("./types").PaginationPrimitives;
-            header: (context: import("./types").StrategyContext, options?: {
-                limit?: number;
-                selector?: string;
-                scrollAmount?: number;
-            }) => Promise<string[]>;
-            navigation: {
-                goUp: (context: import("./types").StrategyContext) => Promise<void>;
-                goDown: (context: import("./types").StrategyContext) => Promise<void>;
-                goLeft: (context: import("./types").StrategyContext) => Promise<void>;
-                goRight: (context: import("./types").StrategyContext) => Promise<void>;
-                goHome: (context: import("./types").StrategyContext) => Promise<void>;
-            };
-            loading: {
-                isHeaderLoading: () => Promise<boolean>;
-            };
-            getCellLocator: ({ row, columnIndex }: any) => any;
-            getActiveCell: ({ page }: any) => Promise<{
-                rowIndex: number;
-                columnIndex: number;
-                locator: any;
-            } | null>;
-        };
-    };
-};

package/dist/plugins.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Plugins = void 0;
-const rdg_1 = require("./strategies/rdg");
-const glide_1 = require("./strategies/glide");
-exports.Plugins = {
-    RDG: {
-        Strategies: rdg_1.RDGStrategies
-    },
-    Glide: {
-        Strategies: glide_1.GlideStrategies
-    }
-};

package/dist/strategies/glide.d.ts

@@ -1,45 +0,0 @@
-import { FillStrategy } from '../types';
-/**
- * Fill strategy for Glide Data Grid with textarea validation.
- * This is the default strategy that works with the standard Glide Data Grid editor.
- */
-export declare const glideFillStrategy: FillStrategy;
-/**
- * Simple fill strategy for Glide Data Grid.
- * Use this if your Glide implementation doesn't use the standard textarea editor.
- * This is faster but may not work for all Glide configurations.
- */
-export declare const glideFillSimple: FillStrategy;
-export declare const glidePaginationStrategy: import("../types").PaginationPrimitives;
-export declare const glideGetCellLocator: ({ row, columnIndex }: any) => any;
-export declare const glideGetActiveCell: ({ page }: any) => Promise<{
-    rowIndex: number;
-    columnIndex: number;
-    locator: any;
-} | null>;
-export declare const GlideStrategies: {
-    fill: FillStrategy;
-    fillSimple: FillStrategy;
-    pagination: import("../types").PaginationPrimitives;
-    header: (context: import("../types").StrategyContext, options?: {
-        limit?: number;
-        selector?: string;
-        scrollAmount?: number;
-    }) => Promise<string[]>;
-    navigation: {
-        goUp: (context: import("../types").StrategyContext) => Promise<void>;
-        goDown: (context: import("../types").StrategyContext) => Promise<void>;
-        goLeft: (context: import("../types").StrategyContext) => Promise<void>;
-        goRight: (context: import("../types").StrategyContext) => Promise<void>;
-        goHome: (context: import("../types").StrategyContext) => Promise<void>;
-    };
-    loading: {
-        isHeaderLoading: () => Promise<boolean>;
-    };
-    getCellLocator: ({ row, columnIndex }: any) => any;
-    getActiveCell: ({ page }: any) => Promise<{
-        rowIndex: number;
-        columnIndex: number;
-        locator: any;
-    } | null>;
-};

package/dist/strategies/rdg.d.ts

@@ -1,34 +0,0 @@
-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 the grid vertically to load more virtualized rows.
- */
-export declare const rdgPaginationStrategy: import("../types").PaginationPrimitives;
-export declare const rdgNavigation: {
-    goRight: ({ root, page }: any) => Promise<void>;
-    goLeft: ({ root, page }: any) => Promise<void>;
-    goDown: ({ root, page }: any) => Promise<void>;
-    goUp: ({ root, page }: any) => Promise<void>;
-    goHome: ({ root, page }: any) => Promise<void>;
-};
-export declare const RDGStrategies: {
-    header: (context: TableContext) => Promise<string[]>;
-    getCellLocator: ({ row, columnIndex }: any) => any;
-    navigation: {
-        goRight: ({ root, page }: any) => Promise<void>;
-        goLeft: ({ root, page }: any) => Promise<void>;
-        goDown: ({ root, page }: any) => Promise<void>;
-        goUp: ({ root, page }: any) => Promise<void>;
-        goHome: ({ root, page }: any) => Promise<void>;
-    };
-    pagination: import("../types").PaginationPrimitives;
-};