@rickcedwhat/playwright-smart-table 6.7.4 → 6.7.6

package/README.md

@@ -70,7 +70,7 @@ const table = await useTable(page.locator('#my-table')).init();
 const row = await table.findRow({ Name: 'John Doe' });
 
 // Access cells by column name
-const email = await row.getCell('Email').textContent();
+const email = await row.getCell('Email').innerText();
 
 // Search across paginated tables
 const allActive = await table.findRows({ Status: 'Active' });
@@ -146,9 +146,9 @@ const table = useTable(page.locator('#table'), {
     },
     // Override how data is written to the 'Tags' column (for .smartFill())
     Tags: {
-      write: async (cell, value) => {
+      write: async ({ cell, targetValue }) => {
         await cell.click();
-        await page.keyboard.type(value);
+        await page.keyboard.type(targetValue);
         await page.keyboard.press('Enter');
       }
     }
@@ -219,6 +219,10 @@ for (const row of active) {
 
 Contributions are welcome! Please feel free to submit a Pull Request.
 
+## Deprecations
+
+- `generateConfigPrompt()` — deprecated. Use `generateConfig()` instead. `generateConfigPrompt()` will be removed in v7.0.0.
+
 ## License
 
 MIT © Cedrick Catalan

package/dist/engine/rowFinder.d.ts

@@ -19,7 +19,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRow<T>>;
-    findRows(filters?: Partial<T> | Record<string, FilterValue>, options?: {
+    findRows(filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRowArray<T>>;

package/dist/engine/rowFinder.js

@@ -14,6 +14,7 @@ const debugUtils_1 = require("../utils/debugUtils");
 const smartRowArray_1 = require("../utils/smartRowArray");
 const validation_1 = require("../strategies/validation");
 const elementTracker_1 = require("../utils/elementTracker");
+const sentinel_1 = require("../utils/sentinel");
 class RowFinder {
     constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }) {
         this.rootLocator = rootLocator;
@@ -42,14 +43,14 @@ class RowFinder {
             const sentinel = this.resolve(this.config.rowSelector, this.rootLocator)
                 .filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
             const smartRow = this.makeSmartRow(sentinel, yield this.tableMapper.getMap(), 0);
-            smartRow._isSentinel = true;
+            smartRow[sentinel_1.SENTINEL_ROW] = true;
             return smartRow;
         });
     }
-    findRows(filters, options) {
-        return __awaiter(this, void 0, void 0, function* () {
+    findRows() {
+        return __awaiter(this, arguments, void 0, function* (filters = {}, options) {
             var _a, _b, _c, _d;
-            const filtersRecord = filters || {};
+            const filtersRecord = filters;
             const map = yield this.tableMapper.getMap();
             const allRows = [];
             const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
@@ -61,7 +62,7 @@ class RowFinder {
                     let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
                     // Only apply filters if we have them
                     if (Object.keys(filtersRecord).length > 0) {
-                        rowLocators = this.filterEngine.applyFilters(rowLocators, filtersRecord, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page());
+                        rowLocators = this.filterEngine.applyFilters(rowLocators, filtersRecord, map, (_a = options === null || options === void 0 ? void 0 : options.exact) !== null && _a !== void 0 ? _a : false, this.rootLocator.page(), this.rootLocator);
                     }
                     // Get only newly seen matched rows
                     const newIndices = yield tracker.getUnseenIndices(rowLocators);
@@ -132,7 +133,7 @@ class RowFinder {
                     }
                 }
                 const allRows = this.resolve(this.config.rowSelector, this.rootLocator);
-                const matchedRows = this.filterEngine.applyFilters(allRows, filters, map, options.exact || false, this.rootLocator.page());
+                const matchedRows = this.filterEngine.applyFilters(allRows, filters, map, options.exact || false, this.rootLocator.page(), this.rootLocator);
                 const count = yield matchedRows.count();
                 this.log(`Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
                 if (count > 1) {

package/dist/engine/tableIteration.d.ts

@@ -0,0 +1,25 @@
+import type { Locator, Page } from '@playwright/test';
+import type { SmartRow, RowIterationContext, RowIterationOptions } from '../types';
+import type { FinalTableConfig } from '../types';
+import type { SmartRowArray } from '../utils/smartRowArray';
+export interface TableIterationEnv<T = any> {
+    getRowLocators: () => Locator;
+    getMap: () => Map<string, number>;
+    advancePage: (useBulk: boolean) => Promise<boolean>;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number) => SmartRow<T>;
+    createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
+    config: FinalTableConfig<T>;
+    getPage: () => Page;
+}
+/**
+ * Shared row-iteration loop used by forEach, map, and filter.
+ */
+export declare function runForEach<T>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => void | Promise<void>, options?: RowIterationOptions): Promise<void>;
+/**
+ * Shared row-iteration loop for map.
+ */
+export declare function runMap<T, R>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => R | Promise<R>, options?: RowIterationOptions): Promise<R[]>;
+/**
+ * Shared row-iteration loop for filter.
+ */
+export declare function runFilter<T>(env: TableIterationEnv<T>, predicate: (ctx: RowIterationContext<T>) => boolean | Promise<boolean>, options?: RowIterationOptions): Promise<SmartRowArray<T>>;

package/dist/engine/tableIteration.js

@@ -0,0 +1,210 @@
+"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.runForEach = runForEach;
+exports.runMap = runMap;
+exports.runFilter = runFilter;
+const elementTracker_1 = require("../utils/elementTracker");
+/**
+ * Shared row-iteration loop used by forEach, map, and filter.
+ */
+function runForEach(env_1, callback_1) {
+    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
+        var _a, _b, _c, _d;
+        const map = env.getMap();
+        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
+        const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
+        const dedupeKeys = dedupeStrategy ? new Set() : null;
+        const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        const tracker = new elementTracker_1.ElementTracker('forEach');
+        try {
+            let rowIndex = 0;
+            let stopped = false;
+            let pagesScanned = 1;
+            const stop = () => { stopped = true; };
+            while (!stopped) {
+                const rowLocators = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
+                if (parallel) {
+                    yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (stopped)
+                            return;
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                return;
+                            dedupeKeys.add(key);
+                        }
+                        yield callback({ row, rowIndex: row.rowIndex, stop });
+                    })));
+                }
+                else {
+                    for (const row of smartRows) {
+                        if (stopped)
+                            break;
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                continue;
+                            dedupeKeys.add(key);
+                        }
+                        yield callback({ row, rowIndex: row.rowIndex, stop });
+                    }
+                }
+                rowIndex += smartRows.length;
+                if (stopped || pagesScanned >= effectiveMaxPages)
+                    break;
+                if (!(yield env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+    });
+}
+/**
+ * Shared row-iteration loop for map.
+ */
+function runMap(env_1, callback_1) {
+    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
+        var _a, _b, _c, _d;
+        const map = env.getMap();
+        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
+        const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
+        const dedupeKeys = dedupeStrategy ? new Set() : null;
+        const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : true;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        const tracker = new elementTracker_1.ElementTracker('map');
+        const results = [];
+        const SKIP = Symbol('skip');
+        try {
+            let rowIndex = 0;
+            let stopped = false;
+            let pagesScanned = 1;
+            const stop = () => { stopped = true; };
+            while (!stopped) {
+                const rowLocators = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
+                if (parallel) {
+                    const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                return SKIP;
+                            dedupeKeys.add(key);
+                        }
+                        return callback({ row, rowIndex: row.rowIndex, stop });
+                    })));
+                    for (const r of pageResults) {
+                        if (r !== SKIP)
+                            results.push(r);
+                    }
+                }
+                else {
+                    for (const row of smartRows) {
+                        if (stopped)
+                            break;
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                continue;
+                            dedupeKeys.add(key);
+                        }
+                        results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
+                    }
+                }
+                rowIndex += smartRows.length;
+                if (stopped || pagesScanned >= effectiveMaxPages)
+                    break;
+                if (!(yield env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+        return results;
+    });
+}
+/**
+ * Shared row-iteration loop for filter.
+ */
+function runFilter(env_1, predicate_1) {
+    return __awaiter(this, arguments, void 0, function* (env, predicate, options = {}) {
+        var _a, _b, _c, _d;
+        const map = env.getMap();
+        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
+        const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
+        const dedupeKeys = dedupeStrategy ? new Set() : null;
+        const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        const tracker = new elementTracker_1.ElementTracker('filter');
+        const matched = [];
+        try {
+            let rowIndex = 0;
+            let stopped = false;
+            let pagesScanned = 1;
+            const stop = () => { stopped = true; };
+            while (!stopped) {
+                const rowLocators = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1));
+                if (parallel) {
+                    const flags = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                return false;
+                            dedupeKeys.add(key);
+                        }
+                        return predicate({ row, rowIndex: row.rowIndex, stop });
+                    })));
+                    smartRows.forEach((row, i) => { if (flags[i])
+                        matched.push(row); });
+                }
+                else {
+                    for (const row of smartRows) {
+                        if (stopped)
+                            break;
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                continue;
+                            dedupeKeys.add(key);
+                        }
+                        if (yield predicate({ row, rowIndex: row.rowIndex, stop })) {
+                            matched.push(row);
+                        }
+                    }
+                }
+                rowIndex += smartRows.length;
+                if (stopped || pagesScanned >= effectiveMaxPages)
+                    break;
+                if (!(yield env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+        return env.createSmartRowArray(matched);
+    });
+}

package/dist/filterEngine.d.ts

@@ -6,6 +6,10 @@ export declare class FilterEngine {
     constructor(config: FinalTableConfig, resolve: (selector: any, parent: Locator | Page) => Locator);
     /**
      * Applies filters to a set of rows.
+     *
+     * Note: `rootLocator` is optional for backward compatibility in call sites that already
+     * pass only the page. When strategies.filter is present we construct a TableContext
+     * using the provided `rootLocator`.
      */
-    applyFilters(baseRows: Locator, filters: Record<string, FilterValue>, map: Map<string, number>, exact: boolean, page: Page): Locator;
+    applyFilters(baseRows: Locator, filters: Record<string, FilterValue>, map: Map<string, number>, exact: boolean, page: Page, rootLocator?: Locator): Locator;
 }

package/dist/filterEngine.js

@@ -9,31 +9,41 @@ class FilterEngine {
     }
     /**
      * Applies filters to a set of rows.
+     *
+     * Note: `rootLocator` is optional for backward compatibility in call sites that already
+     * pass only the page. When strategies.filter is present we construct a TableContext
+     * using the provided `rootLocator`.
      */
-    applyFilters(baseRows, filters, map, exact, page) {
+    applyFilters(baseRows, filters, map, exact, page, rootLocator) {
+        var _a;
         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 = 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
+            // If a pluggable FilterStrategy is provided, prefer it.
+            if (((_a = this.config.strategies) === null || _a === void 0 ? void 0 : _a.filter) && typeof this.config.strategies.filter.apply === 'function') {
+                const tableContext = {
+                    root: rootLocator,
+                    config: this.config,
+                    page,
+                    resolve: this.resolve
+                };
+                filtered = this.config.strategies.filter.apply({
+                    rows: filtered,
+                    filter: { column: colName, value: filterVal },
+                    colIndex,
+                    tableContext
+                });
+                continue;
+            }
             // Default Filter Logic
             const cellTemplate = this.resolve(this.config.cellSelector, page);
-            // ⚠️ CRITICAL WARNING: DO NOT "FIX" OR REFACTOR THIS LOGIC. ⚠️
-            // At first glance, `cellTemplate.nth(colIndex)` looks like a global page selector 
-            // that will return the Nth cell on the entire page, rather than the Nth cell in the row.
-            // THIS IS INTENTIONAL AND CORRECT. 
-            // Playwright deeply understands nested locator scoping. When this global-looking locator 
-            // is passed into `filtered.filter({ has: ... })` below, Playwright magically and 
-            // automatically re-bases the `nth()` selector to be strictly relative to the ROW being evaluated.
-            // Attempting to manually force generic relative locators here will break complex function 
-            // selectors and introduce regressions. Leave it as is.
+            // Playwright scoping: `cellTemplate.nth(colIndex)` will be re-based when used in filtered.filter({ has: ... })
             const targetCell = cellTemplate.nth(colIndex);
             if (typeof filterVal === 'function') {
                 // Locator-based filter: (cell) => cell.locator(...)

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, } from './types';
+export type { TableConfig, TableResult, SmartRow, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, } from './types';
 export { Strategies } from './strategies';
 export { Plugins } from './plugins';

package/dist/{strategies → plugins}/glide/columns.js

@@ -34,10 +34,8 @@ exports.glideGoRight = glideGoRight;
 const glideGoHome = (context) => __awaiter(void 0, void 0, void 0, function* () {
     const { root, page } = context;
     // Glide renders to canvas - the accessibility table (root) is inside the canvas
-    // We need to find and focus the canvas element that contains our root
     yield root.evaluate((el) => {
         var _a;
-        // Find the closest canvas ancestor
         const canvas = el.closest('canvas') || ((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.querySelector('canvas'));
         if (canvas instanceof HTMLCanvasElement) {
             canvas.tabIndex = 0;
@@ -45,10 +43,9 @@ const glideGoHome = (context) => __awaiter(void 0, void 0, void 0, function* ()
         }
     });
     yield page.waitForTimeout(100);
-    // Reset to top-left - Cross-OS sequence (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.keyboard.press('Meta+ArrowUp');
+    yield page.keyboard.press('Home');
     yield page.waitForTimeout(150);
 });
 exports.glideGoHome = glideGoHome;

package/dist/{strategies → plugins}/glide/headers.js

@@ -24,10 +24,8 @@ const scrollRightHeader = (context, options) => __awaiter(void 0, void 0, void 0
         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;
@@ -60,7 +58,6 @@ const scrollRightHeader = (context, options) => __awaiter(void 0, void 0, void 0
     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);

package/dist/plugins/glide/index.d.ts

@@ -0,0 +1,31 @@
+import { FillStrategy, TableConfig } from '../../types';
+/** Strategies only for Glide Data Grid. Includes fillSimple; use when you want to supply your own selectors or override fill. */
+export declare const GlideStrategies: {
+    fillSimple: FillStrategy;
+    fill: FillStrategy;
+    pagination: import("../../types").PaginationPrimitives;
+    header: (context: import("../../types").StrategyContext, options?: {
+        limit?: number;
+        selector?: string;
+        scrollAmount?: number;
+    }) => Promise<string[]>;
+    navigation: {
+        goUp: (context: import("../../types").StrategyContext) => Promise<void>;
+        goDown: (context: import("../../types").StrategyContext) => Promise<void>;
+        goLeft: (context: import("../../types").StrategyContext) => Promise<void>;
+        goRight: (context: import("../../types").StrategyContext) => Promise<void>;
+        goHome: (context: import("../../types").StrategyContext) => Promise<void>;
+    };
+    loading: {
+        isHeaderLoading: () => Promise<boolean>;
+    };
+    getCellLocator: ({ row, columnIndex }: any) => any;
+    getActiveCell: ({ page }: any) => Promise<{
+        rowIndex: number;
+        columnIndex: number;
+        locator: any;
+    } | null>;
+};
+export declare const Glide: Partial<TableConfig> & {
+    Strategies: typeof GlideStrategies;
+};

package/dist/{strategies/glide.js → plugins/glide/index.js}

@@ -9,23 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlideStrategies = exports.glideGetActiveCell = exports.glideGetCellLocator = exports.glidePaginationStrategy = exports.glideFillSimple = exports.glideFillStrategy = void 0;
-const columns_1 = require("./glide/columns");
-const headers_1 = require("./glide/headers");
-const pagination_1 = require("./pagination");
-const stabilization_1 = require("./stabilization");
-/**
- * Fill strategy for Glide Data Grid with textarea validation.
- * This is the default strategy that works with the standard Glide Data Grid editor.
- */
+exports.Glide = exports.GlideStrategies = void 0;
+const columns_1 = require("./columns");
+const headers_1 = require("./headers");
+const pagination_1 = require("../../strategies/pagination");
+const stabilization_1 = require("../../strategies/stabilization");
 const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
-    // Edit Cell
     yield page.keyboard.press('Enter');
-    // Wait for editor to appear
     const textarea = page.locator('textarea.gdg-input');
     yield textarea.waitFor({ state: 'visible', timeout: 2000 });
     yield page.keyboard.type(String(value));
-    // Wait for textarea value to match what we typed
     yield textarea.evaluate((el, expectedValue) => {
         return new Promise((resolve) => {
             const checkValue = () => {
@@ -39,74 +32,48 @@ const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ v
             checkValue();
         });
     }, String(value));
-    // Small delay to let the grid process the value
     yield page.waitForTimeout(50);
     yield page.keyboard.press('Enter');
-    // Wait for editor to close (commit completed)
     yield textarea.waitFor({ state: 'detached', timeout: 2000 });
-    // Wait for accessibility layer to sync with canvas state
     yield page.waitForTimeout(300);
 });
-exports.glideFillStrategy = glideFillStrategy;
-/**
- * Simple fill strategy for Glide Data Grid.
- * Use this if your Glide implementation doesn't use the standard textarea editor.
- * This is faster but may not work for all Glide configurations.
- */
 const glideFillSimple = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
     yield page.keyboard.press('Enter');
     yield page.keyboard.type(String(value));
     yield page.keyboard.press('Enter');
 });
-exports.glideFillSimple = glideFillSimple;
-exports.glidePaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
+const glidePaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
     scrollTarget: 'xpath=//ancestor::body//div[contains(@class, "dvn-scroller")]',
     scrollAmount: 500,
     action: 'js-scroll',
     stabilization: stabilization_1.StabilizationStrategies.contentChanged({ timeout: 5000 }),
-    timeout: 5000 // Overall timeout
+    timeout: 5000
 });
 const glideGetCellLocator = ({ row, columnIndex }) => {
-    // Use relative locator to support virtualization (where rowIndex resets or is offsets)
-    // The accessibility DOM usually contains 'td' elements with the data.
     return row.locator('td').nth(columnIndex);
 };
-exports.glideGetCellLocator = glideGetCellLocator;
 const glideGetActiveCell = (_a) => __awaiter(void 0, [_a], void 0, function* ({ page }) {
-    // Find the focused cell/element
-    // Use broad selector for focused element
     const focused = page.locator('*:focus').first();
     if ((yield focused.count()) === 0)
         return null;
-    // Debug log
-    if (process.env.DEBUG)
-        console.log('Found focused element:', yield focused.evaluate((e) => e.outerHTML));
-    // Try to extract position from ID if possible
     const id = (yield focused.getAttribute('id')) || '';
-    // Expected format: glide-cell-COL-ROW
     const parts = id.split('-');
     let rowIndex = -1;
     let columnIndex = -1;
     if (parts.length >= 4 && parts[0] === 'glide' && parts[1] === 'cell') {
-        columnIndex = parseInt(parts[2]) - 1; // 1-based in ID to 0-based
+        columnIndex = parseInt(parts[2]) - 1;
         rowIndex = parseInt(parts[3]);
     }
-    else {
-        // Fallback: If we can't parse ID, we assume it's the correct cell 
-        // because we just navigated to it. 
-        // Returning -1 indices might be confusing but won't stop smartRow from using the locator.
-    }
     return {
         rowIndex,
         columnIndex,
         locator: focused
     };
 });
-exports.glideGetActiveCell = glideGetActiveCell;
-exports.GlideStrategies = {
-    fill: exports.glideFillStrategy,
-    fillSimple: exports.glideFillSimple,
-    pagination: exports.glidePaginationStrategy,
+/** Default strategies for the Glide preset (fill only; no fillSimple). */
+const GlideDefaultStrategies = {
+    fill: glideFillStrategy,
+    pagination: glidePaginationStrategy,
     header: headers_1.scrollRightHeader,
     navigation: {
         goUp: columns_1.glideGoUp,
@@ -116,8 +83,22 @@ exports.GlideStrategies = {
         goHome: columns_1.glideGoHome
     },
     loading: {
-        isHeaderLoading: () => __awaiter(void 0, void 0, void 0, function* () { return false; }) // Glide renders headers on a canvas, there is no innerText delay
+        isHeaderLoading: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
     },
-    getCellLocator: exports.glideGetCellLocator,
-    getActiveCell: exports.glideGetActiveCell
+    getCellLocator: glideGetCellLocator,
+    getActiveCell: glideGetActiveCell
+};
+/** Strategies only for Glide Data Grid. Includes fillSimple; use when you want to supply your own selectors or override fill. */
+exports.GlideStrategies = Object.assign(Object.assign({}, GlideDefaultStrategies), { fillSimple: glideFillSimple });
+/**
+ * Full preset for Glide Data Grid (selectors + default strategies only).
+ * Spread: useTable(loc, { ...Plugins.Glide, maxPages: 5 }).
+ * Strategies only (including fillSimple): useTable(loc, { rowSelector: '...', strategies: Plugins.Glide.Strategies }).
+ */
+const GlidePreset = {
+    headerSelector: 'table[role="grid"] thead tr th',
+    rowSelector: 'table[role="grid"] tbody tr',
+    cellSelector: 'td',
+    strategies: GlideDefaultStrategies
 };
+exports.Glide = Object.defineProperty(GlidePreset, 'Strategies', { get: () => exports.GlideStrategies, enumerable: false });

package/dist/plugins/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Presets for specific table/grid libraries. Each plugin exposes:
+ * - Plugins.X — full preset (selectors + headerTransformer if any + strategies). Spread: useTable(loc, { ...Plugins.MUI, maxPages: 5 }).
+ * - Plugins.X.Strategies — strategies only. Use with your own selectors: useTable(loc, { rowSelector: '...', strategies: Plugins.MUI.Strategies }).
+ */
+export declare const Plugins: {
+    RDG: Partial<import("..").TableConfig<any>> & {
+        Strategies: typeof import("./rdg").RDGStrategies;
+    };
+    Glide: Partial<import("..").TableConfig<any>> & {
+        Strategies: typeof import("./glide").GlideStrategies;
+    };
+    MUI: Partial<import("..").TableConfig<any>> & {
+        Strategies: typeof import("./mui").MUIStrategies;
+    };
+};

package/dist/plugins/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugins = void 0;
+const rdg_1 = require("./rdg");
+const glide_1 = require("./glide");
+const mui_1 = require("./mui");
+/**
+ * Presets for specific table/grid libraries. Each plugin exposes:
+ * - Plugins.X — full preset (selectors + headerTransformer if any + strategies). Spread: useTable(loc, { ...Plugins.MUI, maxPages: 5 }).
+ * - Plugins.X.Strategies — strategies only. Use with your own selectors: useTable(loc, { rowSelector: '...', strategies: Plugins.MUI.Strategies }).
+ */
+exports.Plugins = {
+    RDG: rdg_1.RDG,
+    Glide: glide_1.Glide,
+    MUI: mui_1.MUI,
+};