@rickcedwhat/playwright-smart-table 3.0.0 → 3.2.0

package/dist/useTable.js

@@ -9,26 +9,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTable = exports.SortingStrategies = exports.TableStrategies = exports.PaginationStrategies = void 0;
+exports.ColumnStrategies = exports.HeaderStrategies = exports.FillStrategies = exports.SortingStrategies = exports.TableStrategies = exports.PaginationStrategies = exports.useTable = void 0;
 const typeContext_1 = require("./typeContext");
 const sorting_1 = require("./strategies/sorting");
 const pagination_1 = require("./strategies/pagination");
+const fill_1 = require("./strategies/fill");
+Object.defineProperty(exports, "FillStrategies", { enumerable: true, get: function () { return fill_1.FillStrategies; } });
+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, "ColumnStrategies", { enumerable: true, get: function () { return columns_1.ColumnStrategies; } });
 /**
- * A collection of pre-built pagination strategies.
+ * Main hook to interact with a table.
  */
-exports.PaginationStrategies = pagination_1.PaginationStrategies;
-/**
- * @deprecated Use `PaginationStrategies` instead. This alias will be removed in a future major version.
- */
-exports.TableStrategies = pagination_1.TableStrategies;
-/**
- * A collection of pre-built sorting strategies.
- */
-exports.SortingStrategies = sorting_1.SortingStrategies;
 const useTable = (rootLocator, configOptions = {}) => {
     // 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, onReset: () => __awaiter(void 0, void 0, void 0, function* () { console.warn("⚠️ .reset() called but no 'onReset' strategy defined in config."); }) }, configOptions);
+    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 resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -84,17 +81,33 @@ const useTable = (rootLocator, configOptions = {}) => {
             yield headerLoc.first().waitFor({ state: 'visible', timeout: headerTimeout });
         }
         catch (e) { /* Ignore hydration */ }
-        // 1. Fetch data efficiently
-        const texts = yield headerLoc.allInnerTexts();
-        const locators = yield headerLoc.all();
+        // 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 context = {
+            root: rootLocator,
+            config: config,
+            page: rootLocator.page(),
+            resolve: resolve
+        };
+        const rawHeaders = yield strategy(context);
         // 2. Map Headers (Async)
-        const entries = yield Promise.all(texts.map((t, i) => __awaiter(void 0, void 0, void 0, function* () {
+        // 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: locators[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.
                 });
             }
             return [text, i];
@@ -103,8 +116,12 @@ const useTable = (rootLocator, configOptions = {}) => {
         logDebug(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
         return _headerMap;
     });
-    const _makeSmart = (rowLocator, map) => {
+    // Placeholder for the final table object, to be captured by closure
+    let finalTable = null;
+    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) {
@@ -112,12 +129,10 @@ const useTable = (rootLocator, configOptions = {}) => {
                 const suggestion = _suggestColumnName(colName, availableColumns);
                 throw new Error(`Column "${colName}" not found${suggestion}`);
             }
-            if (typeof config.cellSelector === 'string') {
-                return rowLocator.locator(config.cellSelector).nth(idx);
-            }
-            else {
-                return resolve(config.cellSelector, rowLocator).nth(idx);
+            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 = {};
@@ -130,8 +145,8 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return result;
         });
-        smart.smartFill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
+        // @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)) {
@@ -139,83 +154,34 @@ const useTable = (rootLocator, configOptions = {}) => {
                 if (colIdx === undefined) {
                     throw _createColumnError(colName, map, 'in fill data');
                 }
-                const cell = smart.getCell(colName);
-                // Use custom input mapper for this column if provided, otherwise auto-detect
-                let inputLocator;
-                if ((_a = fillOptions === null || fillOptions === void 0 ? void 0 : fillOptions.inputMappers) === null || _a === void 0 ? void 0 : _a[colName]) {
-                    inputLocator = fillOptions.inputMappers[colName](cell);
-                }
-                else {
-                    // Auto-detect input type
-                    // Try different input types in order of commonality
-                    // Check for text input
-                    const textInput = cell.locator('input[type="text"], input:not([type]), textarea').first();
-                    const textInputCount = yield textInput.count().catch(() => 0);
-                    // Check for select
-                    const select = cell.locator('select').first();
-                    const selectCount = yield select.count().catch(() => 0);
-                    // Check for checkbox/radio
-                    const checkbox = cell.locator('input[type="checkbox"], input[type="radio"], [role="checkbox"]').first();
-                    const checkboxCount = yield checkbox.count().catch(() => 0);
-                    // Check for contenteditable or div-based inputs
-                    const contentEditable = cell.locator('[contenteditable="true"]').first();
-                    const contentEditableCount = yield contentEditable.count().catch(() => 0);
-                    // Determine which input to use (prioritize by commonality)
-                    if (textInputCount > 0 && selectCount === 0 && checkboxCount === 0) {
-                        inputLocator = textInput;
-                    }
-                    else if (selectCount > 0) {
-                        inputLocator = select;
-                    }
-                    else if (checkboxCount > 0) {
-                        inputLocator = checkbox;
-                    }
-                    else if (contentEditableCount > 0) {
-                        inputLocator = contentEditable;
-                    }
-                    else if (textInputCount > 0) {
-                        // Fallback to text input even if others exist
-                        inputLocator = textInput;
-                    }
-                    else {
-                        // No input found - try to click the cell itself (might trigger an editor)
-                        inputLocator = cell;
-                    }
-                    // Warn if multiple inputs found (ambiguous)
-                    const totalInputs = textInputCount + selectCount + checkboxCount + contentEditableCount;
-                    if (totalInputs > 1 && config.debug) {
-                        logDebug(`⚠️ Multiple inputs found in cell "${colName}" (${totalInputs} total). Using first match. Consider using inputMapper option for explicit control.`);
-                    }
-                }
-                // Fill based on value type and input type
-                const inputTag = yield inputLocator.evaluate((el) => el.tagName.toLowerCase()).catch(() => 'unknown');
-                const inputType = yield inputLocator.getAttribute('type').catch(() => null);
-                const isContentEditable = yield inputLocator.getAttribute('contenteditable').catch(() => null);
-                logDebug(`Filling "${colName}" with value "${value}" (input: ${inputTag}, type: ${inputType})`);
-                if (inputType === 'checkbox' || inputType === 'radio') {
-                    // Boolean value for checkbox/radio
-                    const shouldBeChecked = Boolean(value);
-                    const isChecked = yield inputLocator.isChecked().catch(() => false);
-                    if (isChecked !== shouldBeChecked) {
-                        yield inputLocator.click();
-                    }
-                }
-                else if (inputTag === 'select') {
-                    // Select dropdown
-                    yield inputLocator.selectOption(String(value));
-                }
-                else if (isContentEditable === 'true') {
-                    // Contenteditable div
-                    yield inputLocator.click();
-                    yield inputLocator.fill(String(value));
-                }
-                else {
-                    // Text input, textarea, or generic
-                    yield inputLocator.fill(String(value));
-                }
+                // 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) => {
@@ -347,6 +313,21 @@ const useTable = (rootLocator, configOptions = {}) => {
             _isInitialized = true;
             return result;
         }),
+        scrollToColumn: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
+            const map = yield _getMap();
+            const idx = map.get(columnName);
+            if (idx === undefined) {
+                throw _createColumnError(columnName, map);
+            }
+            yield config.columnStrategy({
+                config: config,
+                root: rootLocator,
+                page: rootLocator.page(),
+                resolve,
+                column: columnName,
+                index: idx
+            });
+        }),
         getHeaders: () => __awaiter(void 0, void 0, void 0, function* () {
             if (!_isInitialized || !_headerMap) {
                 throw new Error('Table not initialized. Call await table.init() first.');
@@ -410,23 +391,29 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return results;
         }),
-        getByRow: (filters, options) => {
-            // Throw error if not initialized (sync methods require explicit init)
+        // @ts-ignore - implementing overload
+        getByRow: (filtersOrIndex, options = { exact: false }) => {
+            // Throw error if not initialized
             if (!_isInitialized || !_headerMap) {
                 throw new Error('Table not initialized. Call await table.init() first.');
             }
-            // Build locator chain (sync) - current page only
+            // 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 === null || options === void 0 ? void 0 : options.exact) || false);
-            // Return first match (or sentinel) - lazy, doesn't check existence
+            const matchedRows = _applyFilters(allRows, filters, _headerMap, options.exact || false);
             const rowLocator = matchedRows.first();
-            const smartRow = _makeSmart(rowLocator, _headerMap);
-            if (options === null || options === void 0 ? void 0 : options.asJSON) {
-                return smartRow.toJSON();
-            }
-            return smartRow;
+            // 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);
         },
-        getByRowAcrossPages: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+        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)
@@ -434,13 +421,9 @@ const useTable = (rootLocator, configOptions = {}) => {
             if (!row) {
                 row = resolve(config.rowSelector, rootLocator).filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
             }
-            const smartRow = _makeSmart(row, _headerMap);
-            if (options === null || options === void 0 ? void 0 : options.asJSON) {
-                return smartRow.toJSON();
-            }
-            return smartRow;
+            return _makeSmart(row, _headerMap, 0);
         }),
-        getAllRows: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        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);
@@ -448,16 +431,23 @@ const useTable = (rootLocator, configOptions = {}) => {
                 rowLocators = _applyFilters(rowLocators, options.filter, _headerMap, options.exact || false);
             }
             const rows = yield rowLocators.all();
-            const smartRows = rows.map(loc => _makeSmart(loc, _headerMap));
+            const smartRows = rows.map((loc, i) => _makeSmart(loc, _headerMap, i));
             if (options === null || options === void 0 ? void 0 : options.asJSON) {
                 return Promise.all(smartRows.map(r => r.toJSON()));
             }
             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);
+        }),
         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'. Generate 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);
         }),
         generateStrategyPrompt: (options) => __awaiter(void 0, void 0, void 0, function* () {
@@ -518,11 +508,12 @@ const useTable = (rootLocator, configOptions = {}) => {
                 getHeaders: result.getHeaders,
                 getHeaderCell: result.getHeaderCell,
                 getByRow: result.getByRow,
-                getAllRows: result.getAllRows,
+                getAllCurrentRows: result.getAllCurrentRows,
                 getColumnValues: result.getColumnValues,
                 generateConfigPrompt: result.generateConfigPrompt,
                 generateStrategyPrompt: result.generateStrategyPrompt,
                 sorting: result.sorting,
+                scrollToColumn: result.scrollToColumn, // Add to restricted result as well
             };
             // Default functions
             const getIsFirst = (_b = options === null || options === void 0 ? void 0 : options.getIsFirst) !== null && _b !== void 0 ? _b : (({ index }) => index === 0);
@@ -537,7 +528,7 @@ const useTable = (rootLocator, configOptions = {}) => {
             while (index < effectiveMaxIterations) {
                 // Get current rows
                 const rowLocators = yield resolve(config.rowSelector, rootLocator).all();
-                let rows = rowLocators.map(loc => _makeSmart(loc, _headerMap));
+                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) {
@@ -600,6 +591,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             return allData;
         }),
     };
+    finalTable = result;
     return result;
 };
 exports.useTable = useTable;
+exports.PaginationStrategies = pagination_1.PaginationStrategies;
+exports.TableStrategies = pagination_1.TableStrategies;
+exports.SortingStrategies = sorting_1.SortingStrategies;

package/package.json

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