@rickcedwhat/playwright-smart-table 6.1.0 → 6.2.0

package/dist/useTable.js

@@ -9,10 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strategies = exports.ResolutionStrategies = exports.CellNavigationStrategies = exports.HeaderStrategies = exports.FillStrategies = exports.SortingStrategies = exports.PaginationStrategies = exports.useTable = void 0;
+exports.Strategies = exports.ResolutionStrategies = exports.CellNavigationStrategies = exports.HeaderStrategies = exports.FillStrategies = exports.DedupeStrategies = exports.SortingStrategies = exports.LoadingStrategies = exports.PaginationStrategies = exports.useTable = void 0;
 const typeContext_1 = require("./typeContext");
 const sorting_1 = require("./strategies/sorting");
 const pagination_1 = require("./strategies/pagination");
+const dedupe_1 = require("./strategies/dedupe");
+const loading_1 = require("./strategies/loading");
 const fill_1 = require("./strategies/fill");
 Object.defineProperty(exports, "FillStrategies", { enumerable: true, get: function () { return fill_1.FillStrategies; } });
 const headers_1 = require("./strategies/headers");
@@ -21,11 +23,12 @@ const columns_1 = require("./strategies/columns");
 Object.defineProperty(exports, "CellNavigationStrategies", { enumerable: true, get: function () { return columns_1.CellNavigationStrategies; } });
 const smartRow_1 = require("./smartRow");
 const filterEngine_1 = require("./filterEngine");
+const tableMapper_1 = require("./engine/tableMapper");
+const rowFinder_1 = require("./engine/rowFinder");
 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; } });
-const validation_1 = require("./strategies/validation");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
 /**
@@ -41,8 +44,11 @@ const useTable = (rootLocator, configOptions = {}) => {
         header: headers_1.HeaderStrategies.visible,
         cellNavigation: columns_1.CellNavigationStrategies.default,
         pagination: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+        loading: {
+            isHeaderLoading: loading_1.LoadingStrategies.Headers.stable(200)
+        }
     };
-    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text, index, locator }) => text, autoScroll: true, onReset: () => __awaiter(void 0, void 0, void 0, function* () { }) }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
+    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, 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);
@@ -51,16 +57,13 @@ const useTable = (rootLocator, configOptions = {}) => {
         return item;
     };
     // Internal State
-    let _headerMap = null;
     let _hasPaginated = false;
-    let _isInitialized = false;
     // Helpers
     const log = (msg) => {
-        (0, debugUtils_1.logDebug)(config, 'verbose', msg); // Legacy(`🔎 [SmartTable Debug] ${msg}`);
+        (0, debugUtils_1.logDebug)(config, 'verbose', msg);
     };
     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()) ||
@@ -73,130 +76,21 @@ const useTable = (rootLocator, configOptions = {}) => {
             suggestion = `. Available columns: ${availableColumns.map(c => `"${c}"`).join(', ')}`;
         }
         else if (availableColumns.length > 0) {
-            suggestion = `. Available columns (first 5): ${availableColumns.slice(0, 5).map(c => `"${c}"`).join(', ')}, ...`;
+            suggestion = `. Available columns (first 10 of ${availableColumns.length}): ${availableColumns.slice(0, 10).map(c => `"${c}"`).join(', ')}, ...`;
         }
         const contextMsg = context ? ` (${context})` : '';
         return new Error(`Column "${colName}" not found${contextMsg}${suggestion}`);
     };
-    const _getMap = (timeout) => __awaiter(void 0, void 0, void 0, function* () {
-        if (_headerMap)
-            return _headerMap;
-        log('Mapping headers...');
-        const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
-        if (config.autoScroll) {
-            try {
-                yield rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
-            }
-            catch (e) { }
-        }
-        const headerLoc = resolve(config.headerSelector, rootLocator);
-        try {
-            yield headerLoc.first().waitFor({ state: 'visible', timeout: headerTimeout });
-        }
-        catch (e) { /* Ignore hydration */ }
-        const strategy = config.strategies.header || headers_1.HeaderStrategies.visible;
-        const context = {
-            root: rootLocator,
-            config: config,
-            page: rootLocator.page(),
-            resolve: resolve
-        };
-        const rawHeaders = yield strategy(context);
-        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)
-                });
-            }
-            return [text, i];
-        })));
-        // Validation: Check for empty table
-        if (entries.length === 0) {
-            throw new Error(`Initialization Error: No columns found using selector "${config.headerSelector}". Check your selector or ensure the table is visible.`);
-        }
-        // Validation: Check for duplicates
-        const seen = new Set();
-        const duplicates = new Set();
-        for (const [name] of entries) {
-            if (seen.has(name)) {
-                duplicates.add(name);
-            }
-            seen.add(name);
-        }
-        if (duplicates.size > 0) {
-            const dupList = Array.from(duplicates).map(d => `"${d}"`).join(', ');
-            throw new Error(`Initialization Error: Duplicate column names found: ${dupList}. Use 'headerTransformer' to rename duplicate columns.`);
-        }
-        _headerMap = new Map(entries);
-        log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
-        return _headerMap;
-    });
+    // Engines
+    const filterEngine = new filterEngine_1.FilterEngine(config, resolve);
+    const tableMapper = new tableMapper_1.TableMapper(rootLocator, config, resolve);
     // Placeholder for the final table object
     let finalTable = null;
-    const filterEngine = new filterEngine_1.FilterEngine(config, resolve);
     // Helper factory
     const _makeSmart = (rowLocator, map, rowIndex) => {
-        // 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;
-        const map = yield _getMap();
-        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
-        let currentPage = 1;
-        log(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
-        while (true) {
-            const allRows = resolve(config.rowSelector, rootLocator);
-            // Use FilterEngine
-            const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page());
-            const count = yield matchedRows.count();
-            log(`Page ${currentPage}: Found ${count} matches.`);
-            if (count > 1) {
-                // Sample data logic (simplified for refactor, kept inline or moved to util if needed)
-                const sampleData = [];
-                try {
-                    const firstFewRows = yield matchedRows.all();
-                    const sampleCount = Math.min(firstFewRows.length, 3);
-                    for (let i = 0; i < sampleCount; i++) {
-                        const rowData = yield _makeSmart(firstFewRows[i], map).toJSON();
-                        sampleData.push(JSON.stringify(rowData));
-                    }
-                }
-                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}`);
-            }
-            if (count === 1)
-                return matchedRows.first();
-            if (currentPage < effectiveMaxPages) {
-                log(`Page ${currentPage}: Not found. Attempting pagination...`);
-                const context = {
-                    root: rootLocator,
-                    config: config,
-                    page: rootLocator.page(),
-                    resolve: resolve
-                };
-                const paginationResult = yield config.strategies.pagination(context);
-                const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
-                if (didLoadMore) {
-                    _hasPaginated = true;
-                    currentPage++;
-                    continue;
-                }
-                else {
-                    log(`Page ${currentPage}: Pagination failed (end of data).`);
-                }
-            }
-            if (_hasPaginated) {
-                console.warn(`⚠️ [SmartTable] Row not found. The table has been paginated (Current Page: ${currentPage}). You may need to call 'await table.reset()' if the target row is on a previous page.`);
-            }
-            return null;
-        }
-    });
+    const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart);
     const _getCleanHtml = (loc) => __awaiter(void 0, void 0, void 0, function* () {
         return loc.evaluate((el) => {
             const clone = el.cloneNode(true);
@@ -232,28 +126,21 @@ const useTable = (rootLocator, configOptions = {}) => {
         console.log(finalPrompt);
     });
     const _ensureInitialized = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!_isInitialized) {
-            yield _getMap();
-            _isInitialized = true;
-        }
+        yield tableMapper.getMap();
     });
     const result = {
         init: (options) => __awaiter(void 0, void 0, void 0, function* () {
-            if (_isInitialized && _headerMap)
+            if (tableMapper.isInitialized())
                 return result;
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
-            yield _getMap(options === null || options === void 0 ? void 0 : options.timeout);
-            _isInitialized = true;
-            if (_headerMap) {
-                (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${_headerMap.size} columns`, Array.from(_headerMap.keys()));
-                // Trace event removed - redundant with debug logging
-            }
+            const map = yield tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
+            (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${map.size} columns`, Array.from(map.keys()));
             yield (0, debugUtils_1.debugDelay)(config, 'default');
             return result;
         }),
         scrollToColumn: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield _getMap();
+            const map = yield tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map);
@@ -267,16 +154,14 @@ const useTable = (rootLocator, configOptions = {}) => {
             });
         }),
         getHeaders: () => __awaiter(void 0, void 0, void 0, function* () {
-            if (!_isInitialized || !_headerMap)
-                throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.getRows() which auto-initialize.');
-            return Array.from(_headerMap.keys());
+            const map = yield tableMapper.getMap();
+            return Array.from(map.keys());
         }),
         getHeaderCell: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            if (!_isInitialized || !_headerMap)
-                throw new Error('Table not initialized. Call await table.init() first.');
-            const idx = _headerMap.get(columnName);
+            const map = yield tableMapper.getMap();
+            const idx = map.get(columnName);
             if (idx === undefined)
-                throw _createColumnError(columnName, _headerMap, 'header cell');
+                throw _createColumnError(columnName, map, 'header cell');
             return resolve(config.headerSelector, rootLocator).nth(idx);
         }),
         reset: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -284,22 +169,20 @@ const useTable = (rootLocator, configOptions = {}) => {
             const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
             yield config.onReset(context);
             _hasPaginated = false;
-            _headerMap = null;
-            _isInitialized = false;
+            tableMapper.clear();
             log("Table reset complete.");
         }),
         revalidate: () => __awaiter(void 0, void 0, void 0, function* () {
             log("Revalidating table structure...");
-            _headerMap = null; // Clear the map to force re-scanning
-            yield _getMap(); // Re-scan headers
+            yield tableMapper.remapHeaders();
             log("Table revalidated.");
         }),
         getColumnValues: (column, options) => __awaiter(void 0, void 0, void 0, function* () {
             var _a, _b;
-            yield _ensureInitialized();
-            const colIdx = _headerMap.get(column);
+            const map = yield tableMapper.getMap();
+            const colIdx = map.get(column);
             if (colIdx === undefined)
-                throw _createColumnError(column, _headerMap);
+                throw _createColumnError(column, map);
             const mapper = (_a = options === null || options === void 0 ? void 0 : options.mapper) !== null && _a !== void 0 ? _a : ((c) => c.innerText());
             const effectiveMaxPages = (_b = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _b !== void 0 ? _b : config.maxPages;
             let currentPage = 1;
@@ -326,82 +209,33 @@ const useTable = (rootLocator, configOptions = {}) => {
             return results;
         }),
         getRow: (filters, options = { exact: false }) => {
-            if (!_isInitialized || !_headerMap)
+            const map = tableMapper.getMapSync();
+            if (!map)
                 throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.getRows() which auto-initialize.');
             const allRows = resolve(config.rowSelector, rootLocator);
-            const matchedRows = filterEngine.applyFilters(allRows, filters, _headerMap, options.exact || false, rootLocator.page());
+            const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page());
             const rowLocator = matchedRows.first();
-            return _makeSmart(rowLocator, _headerMap, 0); // fallback index 0
+            return _makeSmart(rowLocator, map, 0); // fallback index 0
         },
         getRowByIndex: (index, options = {}) => {
-            if (!_isInitialized || !_headerMap)
+            const map = tableMapper.getMapSync();
+            if (!map)
                 throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.getRows() which auto-initialize.');
-            const rowIndex = index - 1; // Convert 1-based to 0-based
-            const rowLocator = resolve(config.rowSelector, rootLocator).nth(rowIndex);
-            return _makeSmart(rowLocator, _headerMap, rowIndex);
+            const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
+            return _makeSmart(rowLocator, map, index);
         },
         findRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
-            (0, debugUtils_1.logDebug)(config, 'info', 'Searching for row', filters);
-            yield _ensureInitialized();
-            let row = yield _findRowLocator(filters, options);
-            if (row) {
-                (0, debugUtils_1.logDebug)(config, 'info', 'Row found');
-                yield (0, debugUtils_1.debugDelay)(config, 'findRow');
-                return _makeSmart(row, _headerMap, 0);
-            }
-            (0, debugUtils_1.logDebug)(config, 'error', 'Row not found', filters);
-            yield (0, debugUtils_1.debugDelay)(config, 'findRow');
-            // Return sentinel row
-            row = resolve(config.rowSelector, rootLocator).filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
-            return _makeSmart(row, _headerMap, 0);
+            return rowFinder.findRow(filters, options);
         }),
         getRows: (options) => __awaiter(void 0, void 0, void 0, function* () {
-            yield _ensureInitialized();
-            let rowLocators = resolve(config.rowSelector, rootLocator);
-            if (options === null || options === void 0 ? void 0 : options.filter) {
-                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));
-            return (0, smartRowArray_1.createSmartRowArray)(smartRows);
+            console.warn('DEPRECATED: table.getRows() is deprecated and will be removed in a future version. Use table.findRows() instead.');
+            return rowFinder.findRows((options === null || options === void 0 ? void 0 : options.filter) || {}, Object.assign(Object.assign({}, options), { maxPages: 1 }));
         }),
         findRows: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            yield _ensureInitialized();
-            const allRows = [];
-            const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
-            let pageCount = 0;
-            // Collect rows from current page
-            let rowLocators = resolve(config.rowSelector, rootLocator);
-            rowLocators = filterEngine.applyFilters(rowLocators, filters, _headerMap, (_c = options === null || options === void 0 ? void 0 : options.exact) !== null && _c !== void 0 ? _c : false, rootLocator.page());
-            let rows = yield rowLocators.all();
-            allRows.push(...rows.map((loc, i) => _makeSmart(loc, _headerMap, i)));
-            // Paginate and collect more rows
-            while (pageCount < effectiveMaxPages && config.strategies.pagination) {
-                const paginationResult = yield config.strategies.pagination({
-                    root: rootLocator,
-                    config,
-                    resolve,
-                    page: rootLocator.page()
-                });
-                const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
-                if (!didPaginate)
-                    break;
-                pageCount++;
-                _hasPaginated = true;
-                // Collect rows from new page
-                rowLocators = resolve(config.rowSelector, rootLocator);
-                rowLocators = filterEngine.applyFilters(rowLocators, filters, _headerMap, (_d = options === null || options === void 0 ? void 0 : options.exact) !== null && _d !== void 0 ? _d : false, rootLocator.page());
-                rows = yield rowLocators.all();
-                allRows.push(...rows.map((loc, i) => _makeSmart(loc, _headerMap, i)));
-            }
-            if (options === null || options === void 0 ? void 0 : options.asJSON) {
-                return Promise.all(allRows.map(r => r.toJSON()));
-            }
-            return allRows;
+            return rowFinder.findRows(filters, options);
         }),
         isInitialized: () => {
-            return _isInitialized;
+            return tableMapper.isInitialized();
         },
         sorting: {
             apply: (columnName, direction) => __awaiter(void 0, void 0, void 0, function* () {
@@ -421,7 +255,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             })
         },
         iterateThroughTable: (callback, options) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f, _g;
             yield _ensureInitialized();
             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;
@@ -429,6 +263,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw new Error('No pagination strategy provided.');
             yield result.reset();
             yield result.init();
+            const map = tableMapper.getMapSync();
             const restrictedTable = {
                 init: result.init,
                 getHeaders: result.getHeaders,
@@ -451,6 +286,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             const effectiveMaxIterations = (_d = options === null || options === void 0 ? void 0 : options.maxIterations) !== null && _d !== void 0 ? _d : config.maxPages;
             const batchSize = options === null || options === void 0 ? void 0 : options.batchSize;
             const isBatching = batchSize !== undefined && batchSize > 1;
+            const autoFlatten = (_e = options === null || options === void 0 ? void 0 : options.autoFlatten) !== null && _e !== void 0 ? _e : false;
             let index = 0;
             let paginationResult = true;
             let seenKeys = null;
@@ -459,19 +295,28 @@ const useTable = (rootLocator, configOptions = {}) => {
             log(`Starting iterateThroughTable (maxIterations: ${effectiveMaxIterations}, batchSize: ${batchSize !== null && batchSize !== void 0 ? batchSize : 'none'})`);
             while (index < effectiveMaxIterations) {
                 const rowLocators = yield resolve(config.rowSelector, rootLocator).all();
-                let rows = rowLocators.map((loc, i) => _makeSmart(loc, _headerMap, i));
-                if ((options === null || options === void 0 ? void 0 : options.dedupeStrategy) && rows.length > 0) {
+                const smartRowsArray = [];
+                const isRowLoading = (_f = config.strategies.loading) === null || _f === void 0 ? void 0 : _f.isRowLoading;
+                for (let i = 0; i < rowLocators.length; i++) {
+                    const smartRow = _makeSmart(rowLocators[i], map, i);
+                    if (isRowLoading && (yield isRowLoading(smartRow)))
+                        continue;
+                    smartRowsArray.push(smartRow);
+                }
+                let rows = (0, smartRowArray_1.createSmartRowArray)(smartRowsArray);
+                const dedupeStrategy = (_g = options === null || options === void 0 ? void 0 : options.dedupeStrategy) !== null && _g !== void 0 ? _g : config.strategies.dedupe;
+                if (dedupeStrategy && rows.length > 0) {
                     if (!seenKeys)
                         seenKeys = new Set();
                     const deduplicated = [];
                     for (const row of rows) {
-                        const key = yield options.dedupeStrategy(row);
+                        const key = yield dedupeStrategy(row);
                         if (!seenKeys.has(key)) {
                             seenKeys.add(key);
                             deduplicated.push(row);
                         }
                     }
-                    rows = deduplicated;
+                    rows = (0, smartRowArray_1.createSmartRowArray)(deduplicated);
                     log(`Deduplicated ${rowLocators.length} rows to ${rows.length} unique rows (total seen: ${seenKeys.size})`);
                 }
                 // Add rows to batch if batching is enabled
@@ -489,7 +334,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                     let isLast = getIsLast({ index: callbackIndex, paginationResult });
                     const isLastDueToMax = index === effectiveMaxIterations - 1;
                     if (isFirst && (options === null || options === void 0 ? void 0 : options.beforeFirst)) {
-                        yield options.beforeFirst({ index: callbackIndex, rows: callbackRows, allData });
+                        yield options.beforeFirst({ index: callbackIndex, rows: (0, smartRowArray_1.createSmartRowArray)(callbackRows), allData });
                     }
                     const batchInfo = isBatching ? {
                         startIndex: batchStartIndex,
@@ -500,12 +345,17 @@ const useTable = (rootLocator, configOptions = {}) => {
                         index: callbackIndex,
                         isFirst,
                         isLast,
-                        rows: callbackRows,
+                        rows: (0, smartRowArray_1.createSmartRowArray)(callbackRows),
                         allData,
                         table: restrictedTable,
                         batchInfo
                     });
-                    allData.push(returnValue);
+                    if (autoFlatten && Array.isArray(returnValue)) {
+                        allData.push(...returnValue);
+                    }
+                    else {
+                        allData.push(returnValue);
+                    }
                     // Determine if this is truly the last iteration
                     let finalIsLast = isLastDueToMax;
                     if (!isLastIteration) {
@@ -516,7 +366,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                         finalIsLast = getIsLast({ index: callbackIndex, paginationResult }) || !paginationResult;
                     }
                     if (finalIsLast && (options === null || options === void 0 ? void 0 : options.afterLast)) {
-                        yield options.afterLast({ index: callbackIndex, rows: callbackRows, allData });
+                        yield options.afterLast({ index: callbackIndex, rows: (0, smartRowArray_1.createSmartRowArray)(callbackRows), allData });
                     }
                     if (finalIsLast || !paginationResult) {
                         log(`Reached last iteration (index: ${index}, paginationResult: ${paginationResult})`);
@@ -540,7 +390,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                         const isFirst = getIsFirst({ index: callbackIndex });
                         const isLast = true;
                         if (isFirst && (options === null || options === void 0 ? void 0 : options.beforeFirst)) {
-                            yield options.beforeFirst({ index: callbackIndex, rows: batchRows, allData });
+                            yield options.beforeFirst({ index: callbackIndex, rows: (0, smartRowArray_1.createSmartRowArray)(batchRows), allData });
                         }
                         const batchInfo = {
                             startIndex: batchStartIndex,
@@ -551,14 +401,19 @@ const useTable = (rootLocator, configOptions = {}) => {
                             index: callbackIndex,
                             isFirst,
                             isLast,
-                            rows: batchRows,
+                            rows: (0, smartRowArray_1.createSmartRowArray)(batchRows),
                             allData,
                             table: restrictedTable,
                             batchInfo
                         });
-                        allData.push(returnValue);
+                        if (autoFlatten && Array.isArray(returnValue)) {
+                            allData.push(...returnValue);
+                        }
+                        else {
+                            allData.push(returnValue);
+                        }
                         if (options === null || options === void 0 ? void 0 : options.afterLast) {
-                            yield options.afterLast({ index: callbackIndex, rows: batchRows, allData });
+                            yield options.afterLast({ index: callbackIndex, rows: (0, smartRowArray_1.createSmartRowArray)(batchRows), allData });
                         }
                         log(`Pagination failed mid-batch (index: ${index})`);
                         break;
@@ -573,7 +428,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         generateConfigPrompt: (options) => __awaiter(void 0, void 0, void 0, function* () {
             const html = yield _getCleanHtml(rootLocator);
             const separator = "=".repeat(50);
-            const content = `\n${separator}\n🤖 COPY INTO GEMINI/ChatGPT 🤖\n${separator}\nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()}\nGenerate config for:\n\`\`\`html\n${html.substring(0, 10000)} ...\n\`\`\`\n${separator}\n`;
+            const content = `\n${separator} \n🤖 COPY INTO GEMINI / ChatGPT 🤖\n${separator} \nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()} \nGenerate config for: \n\`\`\`html\n${html.substring(0, 10000)} ...\n\`\`\`\n${separator}\n`;
             yield _handlePrompt('Smart Table Config', content, options);
         }),
     };
@@ -581,5 +436,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     return result;
 };
 exports.useTable = useTable;
-exports.PaginationStrategies = pagination_1.PaginationStrategies;
+exports.PaginationStrategies = Object.assign({}, pagination_1.PaginationStrategies);
+exports.LoadingStrategies = loading_1.LoadingStrategies;
 exports.SortingStrategies = sorting_1.SortingStrategies;
+exports.DedupeStrategies = dedupe_1.DedupeStrategies;

package/dist/utils/stringUtils.js

@@ -18,11 +18,19 @@ function levenshteinDistance(a, b) {
     }
     for (let i = 1; i <= b.length; i++) {
         for (let j = 1; j <= a.length; j++) {
-            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+            const charB = b.charAt(i - 1);
+            const charA = a.charAt(j - 1);
+            if (charB === charA) {
+                // Exact match
                 matrix[i][j] = matrix[i - 1][j - 1];
             }
             else {
-                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
+                let cost = 1;
+                // If characters match ignoring case, cost is only 0.1 (almost identical)
+                if (charB.toLowerCase() === charA.toLowerCase()) {
+                    cost = 0.1;
+                }
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + cost, // substitution
                 matrix[i][j - 1] + 1, // insertion
                 matrix[i - 1][j] + 1 // deletion
                 );
@@ -36,7 +44,8 @@ function levenshteinDistance(a, b) {
  * 1 = identical, 0 = completely different
  */
 function stringSimilarity(a, b) {
-    const distance = levenshteinDistance(a.toLowerCase(), b.toLowerCase());
+    // We do NOT modify case here anymore, because levenshteinDistance now handles case weighting
+    const distance = levenshteinDistance(a, b);
     const maxLen = Math.max(a.length, b.length);
     return maxLen === 0 ? 1 : 1 - (distance / maxLen);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -22,7 +22,10 @@
     "docs:build": "vitepress build docs",
     "build": "npm run generate-types && npm run generate-docs && npm run generate-all-api-docs && npm run update-all-api-signatures && tsc",
     "prepublishOnly": "npm run build",
-    "test": "npx playwright test",
+    "test": "npm run test:unit && npx playwright test",
+    "test:unit": "vitest run --reporter=verbose --reporter=html",
+    "test:unit:ui": "vitest --ui",
+    "test:e2e": "npx playwright test",
     "test:compatibility": "npx playwright test compatibility",
     "prepare": "husky install"
   },
@@ -38,9 +41,11 @@
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "@types/node": "^22.10.5",
+    "@vitest/ui": "^4.0.18",
+    "happy-dom": "^20.6.1",
     "husky": "^9.1.7",
     "typescript": "^5.7.2",
-    "vitepress": "^1.6.4"
-  },
-  "dependencies": {}
+    "vitepress": "^1.6.4",
+    "vitest": "^4.0.18"
+  }
 }

package/dist/src/filterEngine.d.ts

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

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterEngine = void 0;
-const stringUtils_1 = require("./utils/stringUtils");
-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((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
-            }
-            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/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from './useTable';
-export * from './types';