@rickcedwhat/playwright-smart-table 3.2.0 → 4.0.0

package/dist/useTable.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnStrategies = exports.HeaderStrategies = exports.FillStrategies = exports.SortingStrategies = exports.TableStrategies = exports.PaginationStrategies = exports.useTable = void 0;
+exports.Strategies = exports.ResolutionStrategies = exports.ColumnStrategies = exports.CellNavigationStrategies = exports.HeaderStrategies = exports.FillStrategies = exports.SortingStrategies = exports.DeprecatedTableStrategies = exports.PaginationStrategies = exports.useTable = void 0;
 const typeContext_1 = require("./typeContext");
 const sorting_1 = require("./strategies/sorting");
 const pagination_1 = require("./strategies/pagination");
@@ -18,14 +18,29 @@ Object.defineProperty(exports, "FillStrategies", { enumerable: true, get: functi
 const headers_1 = require("./strategies/headers");
 Object.defineProperty(exports, "HeaderStrategies", { enumerable: true, get: function () { return headers_1.HeaderStrategies; } });
 const columns_1 = require("./strategies/columns");
+Object.defineProperty(exports, "CellNavigationStrategies", { enumerable: true, get: function () { return columns_1.CellNavigationStrategies; } });
 Object.defineProperty(exports, "ColumnStrategies", { enumerable: true, get: function () { return columns_1.ColumnStrategies; } });
+const smartRow_1 = require("./smartRow");
+const filterEngine_1 = require("./filterEngine");
+const resolution_1 = require("./strategies/resolution");
+Object.defineProperty(exports, "ResolutionStrategies", { enumerable: true, get: function () { return resolution_1.ResolutionStrategies; } });
+const strategies_1 = require("./strategies");
+Object.defineProperty(exports, "Strategies", { enumerable: true, get: function () { return strategies_1.Strategies; } });
 /**
  * Main hook to interact with a table.
  */
 const useTable = (rootLocator, configOptions = {}) => {
+    var _a;
     // Store whether pagination was explicitly provided in config
-    const hasPaginationInConfig = configOptions.pagination !== undefined;
-    const config = Object.assign({ rowSelector: "tbody tr", headerSelector: "th", cellSelector: "td", pagination: () => __awaiter(void 0, void 0, void 0, function* () { return false; }), maxPages: 1, headerTransformer: ({ text, index, locator }) => text, autoScroll: true, debug: false, fillStrategy: fill_1.FillStrategies.default, headerStrategy: headers_1.HeaderStrategies.visible, columnStrategy: columns_1.ColumnStrategies.default, onReset: () => __awaiter(void 0, void 0, void 0, function* () { console.warn("⚠️ .reset() called but no 'onReset' strategy defined in config."); }) }, configOptions);
+    const hasPaginationInConfig = ((_a = configOptions.strategies) === null || _a === void 0 ? void 0 : _a.pagination) !== undefined;
+    // Default strategies
+    const defaultStrategies = {
+        fill: fill_1.FillStrategies.default,
+        header: headers_1.HeaderStrategies.visible,
+        cellNavigation: columns_1.CellNavigationStrategies.default,
+        pagination: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+    };
+    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text, index, locator }) => text, autoScroll: true, debug: false, onReset: () => __awaiter(void 0, void 0, void 0, function* () { }) }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -37,31 +52,28 @@ const useTable = (rootLocator, configOptions = {}) => {
     let _headerMap = null;
     let _hasPaginated = false;
     let _isInitialized = false;
+    // Helpers
     const logDebug = (msg) => {
         if (config.debug)
             console.log(`🔎 [SmartTable Debug] ${msg}`);
     };
-    const _suggestColumnName = (colName, availableColumns) => {
-        // Simple fuzzy matching - find columns with similar names
+    const _createColumnError = (colName, map, context) => {
+        const availableColumns = Array.from(map.keys());
+        // Use Suggestion Logic from ResolutionStrategy (if we had a fuzzy one, for now manual suggest)
         const lowerCol = colName.toLowerCase();
         const suggestions = availableColumns.filter(col => col.toLowerCase().includes(lowerCol) ||
             lowerCol.includes(col.toLowerCase()) ||
             col.toLowerCase().replace(/\s+/g, '') === lowerCol.replace(/\s+/g, ''));
+        let suggestion = '.';
         if (suggestions.length > 0 && suggestions[0] !== colName) {
-            return `. Did you mean "${suggestions[0]}"?`;
+            suggestion = `. Did you mean "${suggestions[0]}"?`;
         }
-        // Show similar column names (first 3)
-        if (availableColumns.length > 0 && availableColumns.length <= 10) {
-            return `. Available columns: ${availableColumns.map(c => `"${c}"`).join(', ')}`;
+        else if (availableColumns.length > 0 && availableColumns.length <= 10) {
+            suggestion = `. Available columns: ${availableColumns.map(c => `"${c}"`).join(', ')}`;
         }
         else if (availableColumns.length > 0) {
-            return `. Available columns (first 5): ${availableColumns.slice(0, 5).map(c => `"${c}"`).join(', ')}, ...`;
+            suggestion = `. Available columns (first 5): ${availableColumns.slice(0, 5).map(c => `"${c}"`).join(', ')}, ...`;
         }
-        return '.';
-    };
-    const _createColumnError = (colName, map, context) => {
-        const availableColumns = Array.from(map.keys());
-        const suggestion = _suggestColumnName(colName, availableColumns);
         const contextMsg = context ? ` (${context})` : '';
         return new Error(`Column "${colName}" not found${contextMsg}${suggestion}`);
     };
@@ -81,12 +93,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             yield headerLoc.first().waitFor({ state: 'visible', timeout: headerTimeout });
         }
         catch (e) { /* Ignore hydration */ }
-        // 1. Fetch headers using strategy
-        const strategy = config.headerStrategy || headers_1.HeaderStrategies.visible;
-        // We need to construct context - but wait, HeaderStrategies definition I made imports StrategyContext
-        // We need to import HeaderStrategies in useTable.ts first (it was imported as HeaderStrategies?).
-        // Wait, useTable.ts imports `FillStrategies`.
-        // I need to import `HeaderStrategies`.
+        const strategy = config.strategies.header || headers_1.HeaderStrategies.visible;
         const context = {
             root: rootLocator,
             config: config,
@@ -94,20 +101,13 @@ const useTable = (rootLocator, configOptions = {}) => {
             resolve: resolve
         };
         const rawHeaders = yield strategy(context);
-        // 2. Map Headers (Async)
-        // Note: We lose locator access here for transformer unless strategy provides it. 
-        // For now assuming transformer handles missing locator or we don't pass it if generic strategy.
         const entries = yield Promise.all(rawHeaders.map((t, i) => __awaiter(void 0, void 0, void 0, function* () {
             let text = t.trim() || `__col_${i}`;
             if (config.headerTransformer) {
                 text = yield config.headerTransformer({
                     text,
                     index: i,
-                    locator: rootLocator.locator(config.headerSelector).nth(i) // Best effort lazy locator? 
-                    // Danger: scanning strategy implies nth(i) might not map to visual i if scrolled.
-                    // But map index maps to logical index. 
-                    // If scanning returns 100 headers, nth(99) might not exist in DOM.
-                    // Passing fallback locator or stub.
+                    locator: rootLocator.locator(config.headerSelector).nth(i)
                 });
             }
             return [text, i];
@@ -116,89 +116,13 @@ const useTable = (rootLocator, configOptions = {}) => {
         logDebug(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
         return _headerMap;
     });
-    // Placeholder for the final table object, to be captured by closure
+    // Placeholder for the final table object
     let finalTable = null;
+    const filterEngine = new filterEngine_1.FilterEngine(config, resolve);
+    // Helper factory
     const _makeSmart = (rowLocator, map, rowIndex) => {
-        const smart = rowLocator;
-        smart.getRequestIndex = () => rowIndex;
-        smart.rowIndex = rowIndex;
-        smart.getCell = (colName) => {
-            const idx = map.get(colName);
-            if (idx === undefined) {
-                const availableColumns = Array.from(map.keys());
-                const suggestion = _suggestColumnName(colName, availableColumns);
-                throw new Error(`Column "${colName}" not found${suggestion}`);
-            }
-            if (config.cellResolver) {
-                return config.cellResolver({ row: rowLocator, columnName: colName, columnIndex: idx, rowIndex });
-            }
-            return resolve(config.cellSelector, rowLocator).nth(idx);
-        };
-        smart.toJSON = () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = {};
-            const cells = typeof config.cellSelector === 'string'
-                ? rowLocator.locator(config.cellSelector)
-                : resolve(config.cellSelector, rowLocator);
-            const texts = yield cells.allInnerTexts();
-            for (const [col, idx] of map.entries()) {
-                result[col] = (texts[idx] || '').trim();
-            }
-            return result;
-        });
-        // @ts-ignore - Intentionally overriding Locator's fill method to accept object
-        smart.fill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
-            logDebug(`Filling row with data: ${JSON.stringify(data)}`);
-            // Fill each column
-            for (const [colName, value] of Object.entries(data)) {
-                const colIdx = map.get(colName);
-                if (colIdx === undefined) {
-                    throw _createColumnError(colName, map, 'in fill data');
-                }
-                // Execute Column Strategy BEFORE filling
-                yield config.columnStrategy({
-                    config: config,
-                    root: rootLocator,
-                    page: rootLocator.page(),
-                    resolve,
-                    column: colName,
-                    index: colIdx,
-                    rowLocator: rowLocator,
-                    rowIndex: rowIndex
-                });
-                // Use configured strategy or default to internal DOM logic
-                const strategy = config.fillStrategy || fill_1.FillStrategies.default;
-                yield strategy({
-                    row: smart,
-                    columnName: colName,
-                    value,
-                    index: -1,
-                    page: rootLocator.page(),
-                    rootLocator,
-                    table: finalTable,
-                    fillOptions
-                });
-            }
-            logDebug('Fill operation completed');
-        });
-        // Alias for explicit usage avoiding Locator.fill conflict
-        smart.smartFill = smart.fill;
-        return smart;
-    };
-    const _applyFilters = (baseRows, filters, map, exact) => {
-        let filtered = baseRows;
-        const page = rootLocator.page();
-        for (const [colName, value] of Object.entries(filters)) {
-            const colIndex = map.get(colName);
-            if (colIndex === undefined) {
-                throw _createColumnError(colName, map, 'in filter');
-            }
-            const filterVal = typeof value === 'number' ? String(value) : value;
-            const cellTemplate = resolve(config.cellSelector, page);
-            filtered = filtered.filter({
-                has: cellTemplate.nth(colIndex).getByText(filterVal, { exact }),
-            });
-        }
-        return filtered;
+        // Use the wrapped SmartRow logic
+        return (0, smartRow_1.createSmartRow)(rowLocator, map, rowIndex, config, rootLocator, resolve, finalTable);
     };
     const _findRowLocator = (filters_1, ...args_1) => __awaiter(void 0, [filters_1, ...args_1], void 0, function* (filters, options = {}) {
         var _a;
@@ -208,11 +132,12 @@ const useTable = (rootLocator, configOptions = {}) => {
         logDebug(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
         while (true) {
             const allRows = resolve(config.rowSelector, rootLocator);
-            const matchedRows = _applyFilters(allRows, filters, map, options.exact || false);
+            // Use FilterEngine
+            const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page());
             const count = yield matchedRows.count();
             logDebug(`Page ${currentPage}: Found ${count} matches.`);
             if (count > 1) {
-                // Try to get sample row data to help user identify the issue
+                // Sample data logic (simplified for refactor, kept inline or moved to util if needed)
                 const sampleData = [];
                 try {
                     const firstFewRows = yield matchedRows.all();
@@ -222,12 +147,8 @@ const useTable = (rootLocator, configOptions = {}) => {
                         sampleData.push(JSON.stringify(rowData));
                     }
                 }
-                catch (e) {
-                    // If we can't extract sample data, that's okay - continue without it
-                }
-                const sampleMsg = sampleData.length > 0
-                    ? `\nSample matching rows:\n${sampleData.map((d, i) => `  ${i + 1}. ${d}`).join('\n')}`
-                    : '';
+                catch (e) { }
+                const sampleMsg = sampleData.length > 0 ? `\nSample matching rows:\n${sampleData.map((d, i) => `  ${i + 1}. ${d}`).join('\n')}` : '';
                 throw new Error(`Strict Mode Violation: Found ${count} rows matching ${JSON.stringify(filters)} on page ${currentPage}. ` +
                     `Expected exactly one match. Try adding more filters to make your query unique.${sampleMsg}`);
             }
@@ -241,7 +162,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                     page: rootLocator.page(),
                     resolve: resolve
                 };
-                const didLoadMore = yield config.pagination(context);
+                const didLoadMore = yield config.strategies.pagination(context);
                 if (didLoadMore) {
                     _hasPaginated = true;
                     currentPage++;
@@ -258,33 +179,27 @@ const useTable = (rootLocator, configOptions = {}) => {
         }
     });
     const _handlePrompt = (promptName_1, content_1, ...args_1) => __awaiter(void 0, [promptName_1, content_1, ...args_1], void 0, function* (promptName, content, options = {}) {
+        // ... same logic ...
         const { output = 'console', includeTypes = true } = options;
         let finalPrompt = content;
-        if (includeTypes) {
+        if (includeTypes)
             finalPrompt += `\n\n👇 Useful TypeScript Definitions 👇\n\`\`\`typescript\n${typeContext_1.TYPE_CONTEXT}\n\`\`\`\n`;
-        }
         if (output === 'error') {
             console.log(`⚠️ Throwing error to display [${promptName}] cleanly...`);
             throw new Error(finalPrompt);
         }
         console.log(finalPrompt);
     });
-    // Helper to extract clean HTML for prompts
     const _getCleanHtml = (loc) => __awaiter(void 0, void 0, void 0, function* () {
         return loc.evaluate((el) => {
             const clone = el.cloneNode(true);
-            // 1. Remove Heavy/Useless Elements
             const removeSelectors = 'script, style, svg, path, circle, rect, noscript, [hidden]';
             clone.querySelectorAll(removeSelectors).forEach(n => n.remove());
-            // 2. Clean Attributes
             const walker = document.createTreeWalker(clone, NodeFilter.SHOW_ELEMENT);
             let currentNode = walker.currentNode;
             while (currentNode) {
-                currentNode.removeAttribute('style'); // Inline styles are noise
+                currentNode.removeAttribute('style');
                 currentNode.removeAttribute('data-reactid');
-                // 3. Condense Tailwind Classes (Heuristic)
-                // If class string is very long (>50 chars), keep the first few tokens and truncate.
-                // This preserves "MuiRow" but cuts "text-sm p-4 hover:bg-gray-50 ..."
                 const cls = currentNode.getAttribute('class');
                 if (cls && cls.length > 80) {
                     const tokens = cls.split(' ');
@@ -297,7 +212,6 @@ const useTable = (rootLocator, configOptions = {}) => {
             return clone.outerHTML;
         });
     });
-    // Helper to ensure initialization for async methods
     const _ensureInitialized = () => __awaiter(void 0, void 0, void 0, function* () {
         if (!_isInitialized) {
             yield _getMap();
@@ -306,9 +220,8 @@ const useTable = (rootLocator, configOptions = {}) => {
     });
     const result = {
         init: (options) => __awaiter(void 0, void 0, void 0, function* () {
-            if (_isInitialized && _headerMap) {
+            if (_isInitialized && _headerMap)
                 return result;
-            }
             yield _getMap(options === null || options === void 0 ? void 0 : options.timeout);
             _isInitialized = true;
             return result;
@@ -316,10 +229,9 @@ const useTable = (rootLocator, configOptions = {}) => {
         scrollToColumn: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
             const map = yield _getMap();
             const idx = map.get(columnName);
-            if (idx === undefined) {
+            if (idx === undefined)
                 throw _createColumnError(columnName, map);
-            }
-            yield config.columnStrategy({
+            yield config.strategies.cellNavigation({
                 config: config,
                 root: rootLocator,
                 page: rootLocator.page(),
@@ -329,15 +241,13 @@ const useTable = (rootLocator, configOptions = {}) => {
             });
         }),
         getHeaders: () => __awaiter(void 0, void 0, void 0, function* () {
-            if (!_isInitialized || !_headerMap) {
+            if (!_isInitialized || !_headerMap)
                 throw new Error('Table not initialized. Call await table.init() first.');
-            }
             return Array.from(_headerMap.keys());
         }),
         getHeaderCell: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            if (!_isInitialized || !_headerMap) {
+            if (!_isInitialized || !_headerMap)
                 throw new Error('Table not initialized. Call await table.init() first.');
-            }
             const idx = _headerMap.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, _headerMap, 'header cell');
@@ -345,21 +255,21 @@ const useTable = (rootLocator, configOptions = {}) => {
         }),
         reset: () => __awaiter(void 0, void 0, void 0, function* () {
             logDebug("Resetting table...");
-            const context = {
-                root: rootLocator,
-                config: config,
-                page: rootLocator.page(),
-                resolve: resolve
-            };
+            const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
             yield config.onReset(context);
             _hasPaginated = false;
             _headerMap = null;
             _isInitialized = false;
             logDebug("Table reset complete.");
         }),
+        revalidate: () => __awaiter(void 0, void 0, void 0, function* () {
+            logDebug("Revalidating table structure...");
+            _headerMap = null; // Clear the map to force re-scanning
+            yield _getMap(); // Re-scan headers
+            logDebug("Table revalidated.");
+        }),
         getColumnValues: (column, options) => __awaiter(void 0, void 0, void 0, function* () {
             var _a, _b;
-            // Auto-init if needed (async methods can auto-init)
             yield _ensureInitialized();
             const colIdx = _headerMap.get(column);
             if (colIdx === undefined)
@@ -378,10 +288,8 @@ const useTable = (rootLocator, configOptions = {}) => {
                     results.push(yield mapper(cell));
                 }
                 if (currentPage < effectiveMaxPages) {
-                    const context = {
-                        root: rootLocator, config, page: rootLocator.page(), resolve
-                    };
-                    if (yield config.pagination(context)) {
+                    const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
+                    if (yield config.strategies.pagination(context)) {
                         _hasPaginated = true;
                         currentPage++;
                         continue;
@@ -391,32 +299,23 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return results;
         }),
-        // @ts-ignore - implementing overload
-        getByRow: (filtersOrIndex, options = { exact: false }) => {
-            // Throw error if not initialized
-            if (!_isInitialized || !_headerMap) {
+        getByRow: (filters, options = { exact: false }) => {
+            if (!_isInitialized || !_headerMap)
                 throw new Error('Table not initialized. Call await table.init() first.');
-            }
-            // Handle Index Overload (1-based index)
-            if (typeof filtersOrIndex === 'number') {
-                const rowIndex = filtersOrIndex - 1;
-                const rowLocator = resolve(config.rowSelector, rootLocator).nth(rowIndex);
-                return _makeSmart(rowLocator, _headerMap, rowIndex);
-            }
-            // Handle Filter Logic (Sync - lazy)
-            const filters = filtersOrIndex;
             const allRows = resolve(config.rowSelector, rootLocator);
-            const matchedRows = _applyFilters(allRows, filters, _headerMap, options.exact || false);
+            const matchedRows = filterEngine.applyFilters(allRows, filters, _headerMap, options.exact || false, rootLocator.page());
             const rowLocator = matchedRows.first();
-            // We pass rowIndex=0 as a fallback. 
-            // NOTE: Filter-based sync lookup doesn't know the absolute index easily without scanning.
-            // If accurate rowIndex is needed for filtered rows, use searchForRow or getAllCurrentRows.
-            return _makeSmart(rowLocator, _headerMap, 0);
+            return _makeSmart(rowLocator, _headerMap, 0); // fallback index 0
+        },
+        getByRowIndex: (index, options = {}) => {
+            if (!_isInitialized || !_headerMap)
+                throw new Error('Table not initialized. Call await table.init() first.');
+            const rowIndex = index - 1; // Convert 1-based to 0-based
+            const rowLocator = resolve(config.rowSelector, rootLocator).nth(rowIndex);
+            return _makeSmart(rowLocator, _headerMap, rowIndex);
         },
         searchForRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
-            // Auto-init if needed (async methods can auto-init)
             yield _ensureInitialized();
-            // Full pagination logic (existing _findRowLocator logic)
             let row = yield _findRowLocator(filters, options);
             if (!row) {
                 row = resolve(config.rowSelector, rootLocator).filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
@@ -424,11 +323,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             return _makeSmart(row, _headerMap, 0);
         }),
         getAllCurrentRows: (options) => __awaiter(void 0, void 0, void 0, function* () {
-            // Auto-init if needed (async methods can auto-init)
             yield _ensureInitialized();
             let rowLocators = resolve(config.rowSelector, rootLocator);
             if (options === null || options === void 0 ? void 0 : options.filter) {
-                rowLocators = _applyFilters(rowLocators, options.filter, _headerMap, options.exact || false);
+                rowLocators = filterEngine.applyFilters(rowLocators, options.filter, _headerMap, options.exact || false, rootLocator.page());
             }
             const rows = yield rowLocators.all();
             const smartRows = rows.map((loc, i) => _makeSmart(loc, _headerMap, i));
@@ -437,9 +335,6 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return smartRows;
         }),
-        /**
-         * @deprecated Use getAllCurrentRows instead. This method will be removed in a future major version.
-         */
         getAllRows: (options) => __awaiter(void 0, void 0, void 0, function* () {
             console.warn("⚠️ [SmartTable] getAllRows is deprecated. Use getAllCurrentRows instead.");
             return result.getAllCurrentRows(options);
@@ -458,82 +353,58 @@ const useTable = (rootLocator, configOptions = {}) => {
         }),
         sorting: {
             apply: (columnName, direction) => __awaiter(void 0, void 0, void 0, function* () {
-                // Auto-init if needed (async methods can auto-init)
                 yield _ensureInitialized();
-                if (!config.sorting) {
-                    throw new Error('No sorting strategy has been configured. Please add a `sorting` strategy to your useTable config.');
-                }
+                if (!config.strategies.sorting)
+                    throw new Error('No sorting strategy has been configured.');
                 logDebug(`Applying sort for column "${columnName}" (${direction})`);
-                const context = {
-                    root: rootLocator,
-                    config: config,
-                    page: rootLocator.page(),
-                    resolve: resolve
-                };
-                yield config.sorting.doSort({ columnName, direction, context });
+                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
+                yield config.strategies.sorting.doSort({ columnName, direction, context });
             }),
             getState: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-                // Auto-init if needed (async methods can auto-init)
                 yield _ensureInitialized();
-                if (!config.sorting) {
-                    throw new Error('No sorting strategy has been configured. Please add a `sorting` strategy to your useTable config.');
-                }
-                logDebug(`Getting sort state for column "${columnName}"`);
-                const context = {
-                    root: rootLocator,
-                    config: config,
-                    page: rootLocator.page(),
-                    resolve: resolve
-                };
-                return config.sorting.getSortState({ columnName, context });
+                if (!config.strategies.sorting)
+                    throw new Error('No sorting strategy has been configured.');
+                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
+                return config.strategies.sorting.getSortState({ columnName, context });
             })
         },
         iterateThroughTable: (callback, options) => __awaiter(void 0, void 0, void 0, function* () {
             var _a, _b, _c, _d;
-            // Auto-init if needed (async methods can auto-init)
             yield _ensureInitialized();
-            // Determine pagination strategy
-            const paginationStrategy = (_a = options === null || options === void 0 ? void 0 : options.pagination) !== null && _a !== void 0 ? _a : config.pagination;
-            // Check if pagination was explicitly provided in options or config
+            const paginationStrategy = (_a = options === null || options === void 0 ? void 0 : options.pagination) !== null && _a !== void 0 ? _a : config.strategies.pagination;
             const hasPaginationInOptions = (options === null || options === void 0 ? void 0 : options.pagination) !== undefined;
-            if (!hasPaginationInOptions && !hasPaginationInConfig) {
-                throw new Error('No pagination strategy provided. Either set pagination in options or in table config.');
-            }
-            // Reset to initial page before starting
+            if (!hasPaginationInOptions && !hasPaginationInConfig)
+                throw new Error('No pagination strategy provided.');
             yield result.reset();
             yield result.init();
-            // Create restricted table instance (excludes problematic methods)
             const restrictedTable = {
                 init: result.init,
                 getHeaders: result.getHeaders,
                 getHeaderCell: result.getHeaderCell,
                 getByRow: result.getByRow,
+                getByRowIndex: result.getByRowIndex,
                 getAllCurrentRows: result.getAllCurrentRows,
                 getColumnValues: result.getColumnValues,
                 generateConfigPrompt: result.generateConfigPrompt,
                 generateStrategyPrompt: result.generateStrategyPrompt,
                 sorting: result.sorting,
-                scrollToColumn: result.scrollToColumn, // Add to restricted result as well
+                scrollToColumn: result.scrollToColumn,
+                revalidate: result.revalidate,
             };
-            // Default functions
             const getIsFirst = (_b = options === null || options === void 0 ? void 0 : options.getIsFirst) !== null && _b !== void 0 ? _b : (({ index }) => index === 0);
             const getIsLast = (_c = options === null || options === void 0 ? void 0 : options.getIsLast) !== null && _c !== void 0 ? _c : (() => false);
-            // Create allData array (persists across iterations)
             const allData = [];
             const effectiveMaxIterations = (_d = options === null || options === void 0 ? void 0 : options.maxIterations) !== null && _d !== void 0 ? _d : config.maxPages;
             let index = 0;
-            let paginationResult = true; // Will be set after first pagination attempt
-            let seenKeys = null; // Track seen keys across iterations for deduplication
+            let paginationResult = true;
+            let seenKeys = null;
             logDebug(`Starting iterateThroughTable (maxIterations: ${effectiveMaxIterations})`);
             while (index < effectiveMaxIterations) {
-                // Get current rows
                 const rowLocators = yield resolve(config.rowSelector, rootLocator).all();
                 let rows = rowLocators.map((loc, i) => _makeSmart(loc, _headerMap, i));
-                // Deduplicate if dedupeStrategy provided (across all iterations)
                 if ((options === null || options === void 0 ? void 0 : options.dedupeStrategy) && rows.length > 0) {
-                    if (!seenKeys) {
+                    if (!seenKeys)
                         seenKeys = new Set();
-                    }
                     const deduplicated = [];
                     for (const row of rows) {
                         const key = yield options.dedupeStrategy(row);
@@ -545,43 +416,20 @@ const useTable = (rootLocator, configOptions = {}) => {
                     rows = deduplicated;
                     logDebug(`Deduplicated ${rowLocators.length} rows to ${rows.length} unique rows (total seen: ${seenKeys.size})`);
                 }
-                // Determine flags (isLast will be checked after pagination attempt)
                 const isFirst = getIsFirst({ index });
                 let isLast = getIsLast({ index, paginationResult });
-                // Check if this is the last iteration due to maxIterations (before attempting pagination)
                 const isLastDueToMax = index === effectiveMaxIterations - 1;
-                // Call onFirst hook if applicable
-                if (isFirst && (options === null || options === void 0 ? void 0 : options.onFirst)) {
+                if (isFirst && (options === null || options === void 0 ? void 0 : options.onFirst))
                     yield options.onFirst({ index, rows, allData });
-                }
-                // Call main callback
-                const returnValue = yield callback({
-                    index,
-                    isFirst,
-                    isLast,
-                    rows,
-                    allData,
-                    table: restrictedTable,
-                });
-                // Append return value to allData
+                const returnValue = yield callback({ index, isFirst, isLast, rows, allData, table: restrictedTable });
                 allData.push(returnValue);
-                // Attempt pagination (before checking if we should continue)
-                const context = {
-                    root: rootLocator,
-                    config: config,
-                    page: rootLocator.page(),
-                    resolve: resolve
-                };
+                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
                 paginationResult = yield paginationStrategy(context);
-                // Now check isLast with updated paginationResult
                 isLast = getIsLast({ index, paginationResult }) || isLastDueToMax;
-                // Call onLast hook if applicable (after we know pagination failed or we're at max iterations)
-                if (isLast && (options === null || options === void 0 ? void 0 : options.onLast)) {
+                if (isLast && (options === null || options === void 0 ? void 0 : options.onLast))
                     yield options.onLast({ index, rows, allData });
-                }
-                // Check if we should continue
                 if (isLast || !paginationResult) {
-                    logDebug(`Reached last iteration (index: ${index}, paginationResult: ${paginationResult}, isLastDueToMax: ${isLastDueToMax})`);
+                    logDebug(`Reached last iteration (index: ${index}, paginationResult: ${paginationResult})`);
                     break;
                 }
                 index++;
@@ -596,5 +444,6 @@ const useTable = (rootLocator, configOptions = {}) => {
 };
 exports.useTable = useTable;
 exports.PaginationStrategies = pagination_1.PaginationStrategies;
-exports.TableStrategies = pagination_1.TableStrategies;
+/** @deprecated Use Strategies.Pagination instead */
+exports.DeprecatedTableStrategies = pagination_1.DeprecatedPaginationStrategies;
 exports.SortingStrategies = sorting_1.SortingStrategies;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "description": "A smart table utility for Playwright with built-in pagination strategies that are fully extensible.",
   "repository": {
     "type": "git",