@rickcedwhat/playwright-smart-table 5.3.0 → 6.0.0

package/dist/examples/glide-strategies/columns.d.ts

@@ -0,0 +1,13 @@
+import { StrategyContext } from '../../src/types';
+/**
+ * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
+ * to navigate to the target CELL (navigates down to the row, then right to the column).
+ *
+ * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
+ * or where keyboard navigation is the primary way to move focus.
+ */
+export declare const keyboardCellNavigation: (context: StrategyContext & {
+    column: string;
+    index: number;
+    rowIndex?: number;
+}) => Promise<void>;

package/dist/examples/glide-strategies/columns.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyboardCellNavigation = void 0;
+/**
+ * Strategy that clicks into the table to establish focus and then uses the Right Arrow key
+ * to navigate to the target CELL (navigates down to the row, then right to the column).
+ *
+ * Useful for canvas-based grids like Glide where DOM scrolling might not be enough for interaction
+ * or where keyboard navigation is the primary way to move focus.
+ */
+const keyboardCellNavigation = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const { root, page, index, rowIndex } = context;
+    if (typeof rowIndex !== 'number') {
+        throw new Error('Row index is required for keyboard navigation');
+    }
+    yield root.focus();
+    yield page.waitForTimeout(100);
+    // Robust Navigation:
+    // 1. Jump to Top-Left (Reset) - Sequence for Cross-OS (Mac/Windows)
+    yield page.keyboard.press('Control+Home');
+    yield page.keyboard.press('Meta+ArrowUp'); // Mac Go-To-Top
+    yield page.keyboard.press('Home'); // Ensure start of row
+    yield page.waitForTimeout(150);
+    // 2. Move Down to Target Row
+    for (let i = 0; i < rowIndex; i++) {
+        yield page.keyboard.press('ArrowDown');
+    }
+    // 3. Move Right to Target Column
+    for (let i = 0; i < index; i++) {
+        yield page.keyboard.press('ArrowRight');
+    }
+    yield page.waitForTimeout(50);
+});
+exports.keyboardCellNavigation = keyboardCellNavigation;

package/dist/examples/glide-strategies/headers.d.ts

@@ -0,0 +1,9 @@
+import { StrategyContext } from '../../src/types';
+/**
+ * Scans for headers by finding a scrollable container and setting scrollLeft.
+ */
+export declare const scrollRightHeader: (context: StrategyContext, options?: {
+    limit?: number;
+    selector?: string;
+    scrollAmount?: number;
+}) => Promise<string[]>;

package/dist/examples/glide-strategies/headers.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollRightHeader = void 0;
+/**
+ * Scans for headers by finding a scrollable container and setting scrollLeft.
+ */
+const scrollRightHeader = (context, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { resolve, config, root, page } = context;
+    const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 20;
+    const scrollAmount = (_b = options === null || options === void 0 ? void 0 : options.scrollAmount) !== null && _b !== void 0 ? _b : 300;
+    const collectedHeaders = new Set();
+    const getVisible = () => __awaiter(void 0, void 0, void 0, function* () {
+        const headerLoc = resolve(config.headerSelector, root);
+        const texts = yield headerLoc.allInnerTexts();
+        return texts.map(t => t.trim());
+    });
+    // Initial capture
+    let currentHeaders = yield getVisible();
+    currentHeaders.forEach(h => collectedHeaders.add(h));
+    // Find scroller using JS for better iframe/shadow support
+    const scrollerHandle = yield root.evaluateHandle((el, selector) => {
+        if (selector && el.matches(selector))
+            return el;
+        const effectiveSelector = selector || '.dvn-scroller';
+        const ancestor = el.closest(effectiveSelector);
+        if (ancestor)
+            return ancestor;
+        return document.querySelector(effectiveSelector);
+    }, options === null || options === void 0 ? void 0 : options.selector);
+    const isScrollerFound = yield scrollerHandle.evaluate(el => !!el);
+    if (isScrollerFound) {
+        yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
+        yield page.waitForTimeout(200);
+        for (let i = 0; i < limit; i++) {
+            const sizeBefore = collectedHeaders.size;
+            yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+            yield page.waitForTimeout(300);
+            const newHeaders = yield getVisible();
+            newHeaders.forEach(h => collectedHeaders.add(h));
+            if (collectedHeaders.size === sizeBefore) {
+                yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+                yield page.waitForTimeout(300);
+                const retryHeaders = yield getVisible();
+                retryHeaders.forEach(h => collectedHeaders.add(h));
+                if (collectedHeaders.size === sizeBefore)
+                    break;
+            }
+        }
+    }
+    else {
+        console.warn("HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+    }
+    // Scroll back to start
+    yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
+    yield page.waitForTimeout(200);
+    return Array.from(collectedHeaders);
+});
+exports.scrollRightHeader = scrollRightHeader;

package/dist/src/filterEngine.d.ts

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

package/dist/src/filterEngine.js

@@ -0,0 +1,39 @@
+"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

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

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useTable"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/plugins.d.ts

@@ -0,0 +1,32 @@
+export declare const Plugins: {
+    RDG: {
+        Strategies: {
+            header: (context: import("./types").TableContext) => Promise<string[]>;
+            getCellLocator: ({ row, columnIndex }: any) => any;
+            cellNavigation: ({ root, page, index }: any) => Promise<void>;
+            pagination: import("./types").PaginationStrategy;
+        };
+    };
+    Glide: {
+        Strategies: {
+            fill: import("./types").FillStrategy;
+            pagination: import("./types").PaginationStrategy;
+            header: (context: import("./types").StrategyContext, options?: {
+                limit?: number;
+                selector?: string;
+                scrollAmount?: number;
+            }) => Promise<string[]>;
+            cellNavigation: (context: import("./types").StrategyContext & {
+                column: string;
+                index: number;
+                rowIndex?: number;
+            }) => Promise<void>;
+            getCellLocator: ({ row, columnIndex }: any) => any;
+            getActiveCell: ({ page }: any) => Promise<{
+                rowIndex: number;
+                columnIndex: number;
+                locator: any;
+            } | null>;
+        };
+    };
+};

package/dist/src/plugins.js

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

package/dist/src/smartRow.d.ts

@@ -0,0 +1,7 @@
+import type { Locator, Page } from '@playwright/test';
+import { SmartRow as SmartRowType, FinalTableConfig, TableResult } from './types';
+/**
+ * Factory to create a SmartRow by extending a Playwright Locator.
+ * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
+ */
+export declare const createSmartRow: <T = any>(rowLocator: Locator, map: Map<string, number>, rowIndex: number | undefined, config: FinalTableConfig, rootLocator: Locator, resolve: (item: any, parent: Locator | Page) => Locator, table: TableResult<T> | null) => SmartRowType<T>;

package/dist/src/smartRow.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSmartRow = void 0;
+const fill_1 = require("./strategies/fill");
+const stringUtils_1 = require("./utils/stringUtils");
+const debugUtils_1 = require("./utils/debugUtils");
+/**
+ * Factory to create a SmartRow by extending a Playwright Locator.
+ * We avoid Class/Proxy to ensure full compatibility with Playwright's expect(locator) matchers.
+ */
+const createSmartRow = (rowLocator, map, rowIndex, config, rootLocator, resolve, table) => {
+    const smart = rowLocator;
+    // Attach State
+    smart.rowIndex = rowIndex;
+    // Attach Methods
+    smart.getCell = (colName) => {
+        const idx = map.get(colName);
+        if (idx === undefined) {
+            throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
+        }
+        if (config.strategies.getCellLocator) {
+            return config.strategies.getCellLocator({
+                row: rowLocator,
+                columnName: colName,
+                columnIndex: idx,
+                rowIndex: rowIndex,
+                page: rootLocator.page()
+            });
+        }
+        return resolve(config.cellSelector, rowLocator).nth(idx);
+    };
+    smart.toJSON = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = {};
+        const page = rootLocator.page();
+        for (const [col, idx] of map.entries()) {
+            if ((options === null || options === void 0 ? void 0 : options.columns) && !options.columns.includes(col)) {
+                continue;
+            }
+            // Get the cell locator
+            const cell = config.strategies.getCellLocator
+                ? config.strategies.getCellLocator({
+                    row: rowLocator,
+                    columnName: col,
+                    columnIndex: idx,
+                    rowIndex: rowIndex,
+                    page: page
+                })
+                : resolve(config.cellSelector, rowLocator).nth(idx);
+            let targetCell = cell;
+            // Check if cell exists
+            const count = yield cell.count();
+            if (count === 0) {
+                // Optimization: Check if we are ALREADY at the target cell
+                if (config.strategies.getActiveCell) {
+                    const active = yield config.strategies.getActiveCell({
+                        config,
+                        root: rootLocator,
+                        page,
+                        resolve
+                    });
+                    if (active && active.rowIndex === rowIndex && active.columnIndex === idx) {
+                        if (config.debug)
+                            console.log(`[SmartRow] Already at target cell (r:${active.rowIndex}, c:${active.columnIndex}), skipping navigation.`);
+                        targetCell = active.locator;
+                        // Skip navigation and go to reading text
+                        const text = yield targetCell.innerText();
+                        result[col] = (text || '').trim();
+                        continue;
+                    }
+                }
+                // Cell doesn't exist - navigate to it
+                if (config.debug) {
+                    console.log(`[SmartRow.toJSON] Cell not found for column "${col}" (index ${idx}), navigating...`);
+                }
+                yield config.strategies.cellNavigation({
+                    config: config,
+                    root: rootLocator,
+                    page: page,
+                    resolve: resolve,
+                    column: col,
+                    index: idx,
+                    rowLocator: rowLocator,
+                    rowIndex: rowIndex
+                });
+                // Optimization: check if we can get the active cell directly
+                if (config.strategies.getActiveCell) {
+                    const activeCell = yield config.strategies.getActiveCell({
+                        config,
+                        root: rootLocator,
+                        page,
+                        resolve
+                    });
+                    if (activeCell) {
+                        if (config.debug) {
+                            console.log(`[SmartRow.toJSON] switching to active cell locator (r:${activeCell.rowIndex}, c:${activeCell.columnIndex})`);
+                        }
+                        targetCell = activeCell.locator;
+                    }
+                }
+            }
+            const text = yield targetCell.innerText();
+            result[col] = (text || '').trim();
+        }
+        return result;
+    });
+    smart.smartFill = (data, fillOptions) => __awaiter(void 0, void 0, void 0, function* () {
+        (0, debugUtils_1.logDebug)(config, 'info', 'Filling row', data);
+        for (const [colName, value] of Object.entries(data)) {
+            if (value === undefined)
+                continue;
+            const colIdx = map.get(colName);
+            if (colIdx === undefined) {
+                throw new Error((0, stringUtils_1.buildColumnNotFoundError)(colName, Array.from(map.keys())));
+            }
+            yield config.strategies.cellNavigation({
+                config: config,
+                root: rootLocator,
+                page: rootLocator.page(),
+                resolve: resolve,
+                column: colName,
+                index: colIdx,
+                rowLocator: rowLocator,
+                rowIndex: rowIndex
+            });
+            const strategy = config.strategies.fill || fill_1.FillStrategies.default;
+            (0, debugUtils_1.logDebug)(config, 'verbose', `Filling cell "${colName}" with value`, value);
+            yield strategy({
+                row: smart,
+                columnName: colName,
+                value,
+                index: rowIndex !== null && rowIndex !== void 0 ? rowIndex : -1,
+                page: rowLocator.page(),
+                rootLocator,
+                table: table,
+                fillOptions
+            });
+            // Delay after filling
+            yield (0, debugUtils_1.debugDelay)(config, 'getCell');
+        }
+        (0, debugUtils_1.logDebug)(config, 'info', 'Row fill complete');
+    });
+    smart.bringIntoView = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (rowIndex === undefined) {
+            throw new Error('Cannot bring row into view - row index is unknown. Use getRowByIndex() instead of getRow().');
+        }
+        // Scroll row into view using Playwright's built-in method
+        yield rowLocator.scrollIntoViewIfNeeded();
+    });
+    return smart;
+};
+exports.createSmartRow = createSmartRow;

package/dist/src/strategies/columns.d.ts

@@ -0,0 +1,18 @@
+import { StrategyContext } from '../types';
+/**
+ * Defines the contract for a cell navigation strategy.
+ * It is responsible for ensuring a specific CELL is visible/focused (navigates to row + column),
+ * typically by scrolling or using keyboard navigation.
+ */
+export type CellNavigationStrategy = (context: StrategyContext & {
+    column: string;
+    index: number;
+    rowIndex?: number;
+}) => Promise<void>;
+export declare const CellNavigationStrategies: {
+    /**
+     * Default strategy: Assumes column is accessible or standard scrolling works.
+     * No specific action taken other than what Playwright's default locator handling does.
+     */
+    default: () => Promise<void>;
+};

package/dist/src/strategies/columns.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CellNavigationStrategies = void 0;
+exports.CellNavigationStrategies = {
+    /**
+     * Default strategy: Assumes column is accessible or standard scrolling works.
+     * No specific action taken other than what Playwright's default locator handling does.
+     */
+    default: () => __awaiter(void 0, void 0, void 0, function* () {
+        // No-op
+    })
+};

package/dist/src/strategies/dedupe.d.ts

@@ -0,0 +1,9 @@
+import { DedupeStrategy } from '../types';
+export declare const DedupeStrategies: {
+    /**
+     * Deduplicates rows based on their vertical position (Y coordinate).
+     * Useful for virtualized tables where row DOM elements are reused but content changes.
+     * @param tolerance Pixel tolerance for position comparison (default: 2)
+     */
+    byTopPosition: (tolerance?: number) => DedupeStrategy;
+};

package/dist/src/strategies/dedupe.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedupeStrategies = void 0;
+exports.DedupeStrategies = {
+    /**
+     * Deduplicates rows based on their vertical position (Y coordinate).
+     * Useful for virtualized tables where row DOM elements are reused but content changes.
+     * @param tolerance Pixel tolerance for position comparison (default: 2)
+     */
+    byTopPosition: (tolerance = 2) => (row) => __awaiter(void 0, void 0, void 0, function* () {
+        const box = yield row.boundingBox();
+        if (!box)
+            return 'unknown';
+        // Round to nearest tolerance
+        const y = Math.round(box.y / tolerance) * tolerance;
+        return `pos_${y}`;
+    })
+};

package/dist/src/strategies/fill.d.ts

@@ -0,0 +1,7 @@
+import type { FillStrategy } from '../types';
+export declare const FillStrategies: {
+    /**
+     * Default strategy: Detects input type and fills accordingly (Text, Select, Checkbox, ContentEditable).
+     */
+    default: ({ row, columnName, value, fillOptions }: Parameters<FillStrategy>[0]) => Promise<void>;
+};

package/dist/src/strategies/fill.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FillStrategies = void 0;
+exports.FillStrategies = {
+    /**
+     * Default strategy: Detects input type and fills accordingly (Text, Select, Checkbox, ContentEditable).
+     */
+    default: (_a) => __awaiter(void 0, [_a], void 0, function* ({ row, columnName, value, fillOptions }) {
+        var _b;
+        const cell = row.getCell(columnName);
+        // Use custom input mapper for this column if provided, otherwise auto-detect
+        let inputLocator;
+        if ((_b = fillOptions === null || fillOptions === void 0 ? void 0 : fillOptions.inputMappers) === null || _b === void 0 ? void 0 : _b[columnName]) {
+            inputLocator = fillOptions.inputMappers[columnName](cell);
+        }
+        else {
+            // Auto-detect input type
+            // 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;
+            }
+        }
+        // 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);
+        // console.log(`[SmartTable] Filling "${columnName}" 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));
+        }
+    })
+};

package/dist/src/strategies/glide.d.ts

@@ -0,0 +1,29 @@
+import { FillStrategy } from '../types';
+export declare const glideFillStrategy: FillStrategy;
+export declare const glidePaginationStrategy: import("../types").PaginationStrategy;
+export declare const glideGetCellLocator: ({ row, columnIndex }: any) => any;
+export declare const glideGetActiveCell: ({ page }: any) => Promise<{
+    rowIndex: number;
+    columnIndex: number;
+    locator: any;
+} | null>;
+export declare const GlideStrategies: {
+    fill: FillStrategy;
+    pagination: import("../types").PaginationStrategy;
+    header: (context: import("../types").StrategyContext, options?: {
+        limit?: number;
+        selector?: string;
+        scrollAmount?: number;
+    }) => Promise<string[]>;
+    cellNavigation: (context: import("../types").StrategyContext & {
+        column: string;
+        index: number;
+        rowIndex?: number;
+    }) => Promise<void>;
+    getCellLocator: ({ row, columnIndex }: any) => any;
+    getActiveCell: ({ page }: any) => Promise<{
+        rowIndex: number;
+        columnIndex: number;
+        locator: any;
+    } | null>;
+};