@rickcedwhat/playwright-smart-table 6.11.0 → 6.13.0

package/README.md

@@ -45,6 +45,7 @@ await table.forEach(async ({ row }) => {
 npm install @rickcedwhat/playwright-smart-table
 ```
 
+
 ## Quick Start
 
 ```typescript

package/dist/engine/rowFinder.d.ts

@@ -11,10 +11,9 @@ export declare class RowFinder<T = any> {
     private makeSmartRow;
     private tableState;
     private resolve;
-    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number, tablePageIndex?: number) => SmartRow<T>, tableState?: {
+    constructor(rootLocator: Locator, config: FinalTableConfig, resolve: (item: Selector, parent: Locator | Page) => Locator, filterEngine: FilterEngine, tableMapper: TableMapper, makeSmartRow: (loc: Locator, map: Map<string, number>, index: number | undefined, tablePageIndex?: number) => SmartRow<T>, tableState?: {
         currentPageIndex: number;
     });
-    private log;
     findRow(filters: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
@@ -22,6 +21,8 @@ export declare class RowFinder<T = any> {
     findRows(filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
+        useBulkPagination?: boolean;
     }): Promise<SmartRowArray<T>>;
     private findRowLocator;
+    private resolveRowIndex;
 }

package/dist/engine/rowFinder.js

@@ -16,9 +16,6 @@ class RowFinder {
         this.tableState = tableState;
         this.resolve = resolve;
     }
-    log(msg) {
-        (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
-    }
     async findRow(filters, options = {}) {
         (0, debugUtils_1.logDebug)(this.config, 'info', 'Searching for row', filters);
         await this.tableMapper.getMap();
@@ -26,7 +23,9 @@ class RowFinder {
         if (rowLocator) {
             (0, debugUtils_1.logDebug)(this.config, 'info', 'Row found');
             await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
-            return this.makeSmartRow(rowLocator, await this.tableMapper.getMap(), 0);
+            const map = await this.tableMapper.getMap();
+            const rowIndex = await this.resolveRowIndex(rowLocator);
+            return this.makeSmartRow(rowLocator, map, rowIndex, this.tableState.currentPageIndex);
         }
         (0, debugUtils_1.logDebug)(this.config, 'error', 'Row not found', filters);
         await (0, debugUtils_1.debugDelay)(this.config, 'findRow');
@@ -43,7 +42,7 @@ class RowFinder {
         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;
         let pagesScanned = 1;
-        this.log(`findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
+        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: starting (maxPages=${effectiveMaxPages}, filters=${JSON.stringify(filtersRecord)})`);
         const tracker = new elementTracker_1.ElementTracker('findRows');
         try {
             const collectMatches = async () => {
@@ -61,13 +60,13 @@ class RowFinder {
                 for (const idx of newIndices) {
                     const smartRow = this.makeSmartRow(currentRows[idx], map, allRows.length, this.tableState.currentPageIndex);
                     if (isRowLoading && await isRowLoading(smartRow)) {
-                        this.log(`findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true)`);
+                        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true)`);
                         continue;
                     }
                     allRows.push(smartRow);
                     added++;
                 }
-                this.log(`findRows: page ${this.tableState.currentPageIndex} — ${added} new match(es) (total: ${allRows.length})`);
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: page ${this.tableState.currentPageIndex} — ${added} new match(es) (total: ${allRows.length})`);
             };
             // Scan first page
             await collectMatches();
@@ -80,40 +79,42 @@ class RowFinder {
                     page: this.rootLocator.page()
                 };
                 let paginationResult;
-                if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
+                const useBulk = (options === null || options === void 0 ? void 0 : options.useBulkPagination) !== false && !!((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk);
+                if (useBulk) {
                     paginationResult = await this.config.strategies.pagination.goNextBulk(context);
                 }
                 else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
                     paginationResult = await this.config.strategies.pagination.goNext(context);
                 }
                 else {
-                    this.log(`findRows: no pagination primitive — stopping`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: no pagination primitive — stopping`);
                     break;
                 }
                 const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
                 if (!didPaginate) {
-                    this.log(`findRows: pagination returned false — end of data`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: pagination returned false — end of data`);
                     break;
                 }
                 const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
                 this.tableState.currentPageIndex += pagesJumped;
                 pagesScanned += pagesJumped;
-                this.log(`findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
+                await (0, debugUtils_1.debugDelay)(this.config, 'pagination');
                 await collectMatches();
             }
         }
         finally {
             await tracker.cleanup(this.rootLocator.page());
         }
-        this.log(`findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
+        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: done — ${allRows.length} row(s) collected across ${pagesScanned} page(s)`);
         return (0, smartRowArray_1.createSmartRowArray)(allRows);
     }
     async findRowLocator(filters, options = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const map = await this.tableMapper.getMap();
         const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
         let pagesScanned = 1;
-        this.log(`Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
+        (0, debugUtils_1.logDebug)(this.config, 'verbose', `Looking for row: ${JSON.stringify(filters)} (MaxPages: ${effectiveMaxPages})`);
         while (true) {
             // Check Loading
             if ((_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isTableLoading) {
@@ -124,7 +125,7 @@ class RowFinder {
                     resolve: this.resolve
                 });
                 if (isLoading) {
-                    this.log('Table is loading... waiting');
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', 'Table is loading... waiting');
                     await this.rootLocator.page().waitForTimeout(200);
                     continue;
                 }
@@ -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(), this.rootLocator);
             const count = await matchedRows.count();
-            this.log(`Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
+            (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Found ${count} matches.`);
             if (count > 1) {
                 const sampleData = [];
                 try {
@@ -151,7 +152,7 @@ class RowFinder {
             if (count === 1)
                 return matchedRows.first();
             if (pagesScanned < effectiveMaxPages) {
-                this.log(`Page ${this.tableState.currentPageIndex}: Not found. Attempting pagination...`);
+                (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Not found. Attempting pagination...`);
                 const context = {
                     root: this.rootLocator,
                     config: this.config,
@@ -159,14 +160,16 @@ class RowFinder {
                     page: this.rootLocator.page()
                 };
                 let paginationResult;
-                if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
-                    paginationResult = await this.config.strategies.pagination.goNextBulk(context);
+                const pagination = this.config.strategies.pagination;
+                const useBulk = options.useBulkPagination !== false && !!(pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk);
+                if (useBulk && (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk)) {
+                    paginationResult = await pagination.goNextBulk(context);
                 }
-                else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
-                    paginationResult = await this.config.strategies.pagination.goNext(context);
+                else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNext) {
+                    paginationResult = await pagination.goNext(context);
                 }
                 else {
-                    this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
                     return null;
                 }
                 const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
@@ -174,14 +177,29 @@ class RowFinder {
                     const pagesJumped = typeof paginationResult === 'number' ? paginationResult : 1;
                     this.tableState.currentPageIndex += pagesJumped;
                     pagesScanned += pagesJumped;
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRowLocator: advanced ${pagesJumped} page(s), now at page ${this.tableState.currentPageIndex}`);
+                    await (0, debugUtils_1.debugDelay)(this.config, 'pagination');
                     continue;
                 }
                 else {
-                    this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (end of data).`);
+                    (0, debugUtils_1.logDebug)(this.config, 'verbose', `Page ${this.tableState.currentPageIndex}: Pagination failed (end of data).`);
                 }
             }
             return null;
         }
     }
+    async resolveRowIndex(rowLocator) {
+        const allRows = await this.resolve(this.config.rowSelector, this.rootLocator).all();
+        const targetHandle = await rowLocator.elementHandle();
+        if (!targetHandle)
+            return undefined;
+        for (let i = 0; i < allRows.length; i++) {
+            const handle = await allRows[i].elementHandle();
+            if (handle && await handle.evaluate((el, t) => el === t, targetHandle)) {
+                return i;
+            }
+        }
+        return undefined;
+    }
 }
 exports.RowFinder = RowFinder;

package/dist/engine/tableIteration.d.ts

@@ -11,6 +11,7 @@ export interface TableIterationEnv<T = any> {
     createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
     config: FinalTableConfig<T>;
     getPage: () => Page;
+    getCurrentPageIndex: () => number;
 }
 /** Delegates to {@link runMap}; void results are discarded. */
 export declare function runForEach<T>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => void | Promise<void>, options?: RowIterationOptions): Promise<void>;

package/dist/engine/tableIteration.js

@@ -27,7 +27,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
     const dedupeKeys = dedupeStrategy ? new Set() : null;
     const defaultMode = label === 'map' ? 'parallel' : 'sequential';
     const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : defaultMode;
-    const useBarrier = concurrency !== 'sequential';
+    const useBarrier = concurrency === 'synchronized';
     // Mutex must not pair with the navigation barrier: synchronized mode needs every row
     // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
     // for batchSize peers that never reach the barrier).
@@ -50,8 +50,15 @@ async function runMap(env, callback, options = {}, label = 'map') {
         };
         while (!stopped) {
             const rowLocators = env.getRowLocators();
-            const newIndices = await tracker.getUnseenIndices(rowLocators);
+            const allIndices = await tracker.peekUnseenIndices(rowLocators);
             const pageRows = await rowLocators.all();
+            // In synchronized mode, overscan rows rendered beyond the visible viewport by virtual
+            // scrollers can be evicted when the horizontal barrier fires snapFirstColumnIntoView.
+            // Filter them out before committing so they stay unseen and are picked up on the next page.
+            const newIndices = concurrency === 'synchronized'
+                ? (await Promise.all(allIndices.map(async (idx) => ({ idx, present: pageRows[idx] != null && (await pageRows[idx].count()) > 0 })))).filter(r => r.present).map(r => r.idx)
+                : allIndices;
+            await tracker.commitIndices(rowLocators, newIndices);
             const batchSize = newIndices.length;
             if (batchSize === 0) {
                 log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
@@ -60,7 +67,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
                 log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
                 const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
                 const actionMutex = useMutex ? new mutex_1.Mutex() : null;
-                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1, barrier));
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, env.getCurrentPageIndex(), barrier));
                 const processRow = async (row) => {
                     try {
                         if (stopped && row.rowIndex > stoppedIndex) {
@@ -79,7 +86,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
                             if (stopped && row.rowIndex > stoppedIndex)
                                 return SKIP;
                             log(env.config, `${label}: processing row ${row.rowIndex}`);
-                            return await callback({ row, index: row.rowIndex, rowIndex: row.rowIndex, stop: () => stop(row.rowIndex) });
+                            return await callback({ row, index: row.rowIndex, rowIndex: row.rowIndex, pageIndex: env.getCurrentPageIndex(), stop: () => stop(row.rowIndex) });
                         };
                         if (actionMutex) {
                             return await actionMutex.run(runCallback);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { PLAYWRIGHT_SMART_TABLE_VERSION } from './packageVersion';
 export { useTable } from './useTable';
-export type { TableConfig, TableResult, SmartRow, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /** @deprecated Use `presets` instead. Plugins will be removed in v7.0.0. */

package/dist/packageVersion.d.ts

@@ -3,4 +3,4 @@
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.11.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.13.0";

package/dist/packageVersion.js

@@ -6,4 +6,4 @@ exports.PLAYWRIGHT_SMART_TABLE_VERSION = void 0;
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.11.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.13.0";

package/dist/plugins/index.d.ts

@@ -8,15 +8,15 @@ export declare const Plugins: {
     /** @deprecated Use `presets.rdg` */
     RDG: {
         Strategies: import("../types").TableStrategies | undefined;
-        headerSelector?: string | ((root: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;
-            locator: import("playwright-core").Locator;
+            locator: import("@playwright/test").Locator;
             seenHeaders: Set<string>;
         }) => string | Promise<string>) | undefined;
         autoScroll?: boolean | undefined;
@@ -28,15 +28,15 @@ export declare const Plugins: {
     /** @deprecated Use `presets.glide` */
     Glide: {
         Strategies: import("../types").TableStrategies | undefined;
-        headerSelector?: string | ((root: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;
-            locator: import("playwright-core").Locator;
+            locator: import("@playwright/test").Locator;
             seenHeaders: Set<string>;
         }) => string | Promise<string>) | undefined;
         autoScroll?: boolean | undefined;
@@ -48,15 +48,15 @@ export declare const Plugins: {
     /** @deprecated Use `presets.muiDataGrid` */
     MUI: {
         Strategies: import("../types").TableStrategies | undefined;
-        headerSelector?: string | ((root: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        headerSelector?: string | ((root: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         rowSelector?: string | undefined;
-        cellSelector?: string | ((row: import("playwright-core").Locator) => import("playwright-core").Locator) | undefined;
+        cellSelector?: string | ((row: import("@playwright/test").Locator) => import("@playwright/test").Locator) | undefined;
         maxPages?: number | undefined;
         concurrency?: import("../types").RowIterationMode | undefined;
         headerTransformer?: ((args: {
             text: string;
             index: number;
-            locator: import("playwright-core").Locator;
+            locator: import("@playwright/test").Locator;
             seenHeaders: Set<string>;
         }) => string | Promise<string>) | undefined;
         autoScroll?: boolean | undefined;

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

@@ -1,4 +1,7 @@
 import { FillStrategy, TableConfig } from '../../types';
+export { createGlideViewport } from './viewport';
+export type { GlideViewportOptions } from './viewport';
+import { GlideViewportOptions } from './viewport';
 /** 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;
@@ -9,15 +12,7 @@ export declare const GlideStrategies: {
         selector?: string;
         scrollAmount?: number;
     }) => Promise<string[]>;
-    navigation: {
-        goUp: (context: import("../..").StrategyContext) => Promise<void>;
-        goDown: (context: import("../..").StrategyContext) => Promise<void>;
-        goLeft: (context: import("../..").StrategyContext) => Promise<void>;
-        goRight: (context: import("../..").StrategyContext) => Promise<void>;
-        goHome: (context: import("../..").StrategyContext) => Promise<void>;
-        snapFirstColumnIntoView: (context: import("../..").StrategyContext) => Promise<void>;
-        seekColumnIndex: (context: import("../..").StrategyContext, columnIndex: number) => Promise<void>;
-    };
+    viewport: import("../../types").ViewportStrategy;
     loading: {
         isHeaderLoading: () => Promise<boolean>;
     };
@@ -28,6 +23,16 @@ export declare const GlideStrategies: {
         locator: any;
     } | null>;
 };
+/** Alias of {@link GlideViewportOptions}. All fields are forwarded to the viewport strategy. */
+export type GlideOptions = GlideViewportOptions;
+/**
+ * Factory that returns a configured Glide preset.
+ * Use when your grid differs from the defaults:
+ * ```ts
+ * useTable(loc, { ...createGlide({ attachTimeout: 5000 }), maxPages: 5 })
+ * ```
+ */
+export declare function createGlide(options?: GlideOptions): Partial<TableConfig>;
 export declare const Glide: Partial<TableConfig> & {
     Strategies: typeof GlideStrategies;
 };

package/dist/presets/glide/index.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Glide = exports.GlideStrategies = void 0;
-const columns_1 = require("./columns");
+exports.Glide = exports.GlideStrategies = exports.createGlideViewport = void 0;
+exports.createGlide = createGlide;
 const headers_1 = require("./headers");
 const pagination_1 = require("../../strategies/pagination");
 const stabilization_1 = require("../../strategies/stabilization");
+var viewport_1 = require("./viewport");
+Object.defineProperty(exports, "createGlideViewport", { enumerable: true, get: function () { return viewport_1.createGlideViewport; } });
+const viewport_2 = require("./viewport");
 const glideFillStrategy = async ({ row, columnName, value, page }) => {
     // Canvas-aware click: Glide is a canvas grid. The accessibility 'td' elements
     // may not trigger internal focus on a simple click. We click the canvas at the cell's location.
@@ -86,15 +89,7 @@ const GlideDefaultStrategies = {
     fill: glideFillStrategy,
     pagination: glidePaginationStrategy,
     header: headers_1.scrollRightHeader,
-    navigation: {
-        goUp: columns_1.glideGoUp,
-        goDown: columns_1.glideGoDown,
-        goLeft: columns_1.glideGoLeft,
-        goRight: columns_1.glideGoRight,
-        goHome: columns_1.glideSnapFirstColumnIntoView,
-        snapFirstColumnIntoView: columns_1.glideSnapFirstColumnIntoView,
-        seekColumnIndex: columns_1.glideSeekColumnIndex
-    },
+    viewport: (0, viewport_2.createGlideViewport)(),
     loading: {
         isHeaderLoading: async () => false
     },
@@ -103,10 +98,27 @@ const GlideDefaultStrategies = {
 };
 /** 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 });
+/**
+ * Factory that returns a configured Glide preset.
+ * Use when your grid differs from the defaults:
+ * ```ts
+ * useTable(loc, { ...createGlide({ attachTimeout: 5000 }), maxPages: 5 })
+ * ```
+ */
+function createGlide(options = {}) {
+    return {
+        headerSelector: 'table[role="grid"] thead tr th',
+        rowSelector: 'table[role="grid"] tbody tr',
+        cellSelector: 'td',
+        concurrency: 'sequential',
+        strategies: Object.assign(Object.assign({}, GlideDefaultStrategies), { viewport: (0, viewport_2.createGlideViewport)(options) })
+    };
+}
 /**
  * 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 }).
+ * For a non-64-column grid, use `createGlide({ columnCount })` instead.
  */
 const GlidePreset = {
     headerSelector: 'table[role="grid"] thead tr th',

package/dist/presets/glide/viewport.d.ts

@@ -0,0 +1,9 @@
+import { ViewportStrategy } from '../../types';
+export interface GlideViewportOptions {
+    /**
+     * Milliseconds to wait for a cell/row to appear in the DOM after a scroll.
+     * Default: 3000.
+     */
+    attachTimeout?: number;
+}
+export declare const createGlideViewport: (options?: GlideViewportOptions) => ViewportStrategy;

package/dist/presets/glide/viewport.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlideViewport = void 0;
+/**
+ * Viewport strategy for Glide Data Grid.
+ *
+ * Glide renders an ARIA accessibility table (`table[role="grid"]`) alongside its
+ * canvas. Rows and cells are virtualized: only the currently visible window of
+ * `tbody tr` / `td[aria-colindex]` elements exists in the DOM at any moment.
+ *
+ * This strategy:
+ * - `getVisibleColumnRange` — reads `aria-colindex` values from the first visible row
+ * - `getVisibleRowRange`   — reads `aria-rowindex` values from visible rows (2-based: header = 1)
+ * - `scrollToColumn`       — sets `.dvn-scroller.scrollLeft` via ratio derived from header count, waits for cell mount
+ * - `scrollToRow`          — sets `.dvn-scroller.scrollTop` via measured row height, waits for row mount
+ */
+const sanitize = (value, fallback) => {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+const createGlideViewport = (options = {}) => {
+    const attachTimeout = sanitize(options.attachTimeout, 3000);
+    return {
+        getVisibleColumnRange: async ({ page }) => {
+            const indices = await page
+                .locator('table[role="grid"] tbody tr')
+                .first()
+                .locator('td[aria-colindex]')
+                .evaluateAll((tds) => tds.map((td) => parseInt(td.getAttribute('aria-colindex') || '1') - 1));
+            if (!indices.length)
+                return { first: 0, last: 0 };
+            return { first: Math.min(...indices), last: Math.max(...indices) };
+        },
+        getVisibleRowRange: async ({ page }) => {
+            // aria-rowindex is 1-based; header row = 1, so data row 0 → aria-rowindex="2"
+            const indices = await page
+                .locator('table[role="grid"] tbody tr[aria-rowindex]')
+                .evaluateAll((trs) => trs.map((tr) => parseInt(tr.getAttribute('aria-rowindex') || '2') - 2));
+            if (!indices.length)
+                return { first: 0, last: 0 };
+            return { first: Math.min(...indices), last: Math.max(...indices) };
+        },
+        scrollToColumn: async (context, colIndex) => {
+            var _a, _b;
+            const { page } = context;
+            const scroller = page.locator('.dvn-scroller').first();
+            // Derive total column count from the initialized header map (available post-init).
+            // Falls back to a ratio seek only by position if headers are unavailable.
+            const headers = await ((_a = context.getHeaders) === null || _a === void 0 ? void 0 : _a.call(context));
+            const totalColumns = (_b = headers === null || headers === void 0 ? void 0 : headers.length) !== null && _b !== void 0 ? _b : 0;
+            if (totalColumns > 0) {
+                await scroller.evaluate((el, { idx, count }) => {
+                    const max = Math.max(0, el.scrollWidth - el.clientWidth);
+                    const ratio = Math.min(1, Math.max(0, (idx + 0.5) / count));
+                    el.scrollLeft = Math.floor(ratio * max);
+                }, { idx: colIndex, count: totalColumns });
+            }
+            const target = page
+                .locator(`table[role="grid"] tbody tr td[aria-colindex="${colIndex + 1}"]`)
+                .first();
+            // Wait for the cell to attach. The first probe is short (800ms fast path); after
+            // any nudge the probe uses the full remaining budget so Glide has time to re-render.
+            // Total ceiling = 800ms + attachTimeout, matching the original two-phase behaviour.
+            const deadline = Date.now() + 800 + attachTimeout;
+            let nudged = false;
+            while (true) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    throw Object.assign(new Error(`Timed out after ${attachTimeout}ms waiting for aria-colindex="${colIndex + 1}" to attach`), { name: 'TimeoutError' });
+                try {
+                    await target.waitFor({ state: 'attached', timeout: nudged ? remaining : Math.min(800, remaining) });
+                    break;
+                }
+                catch (err) {
+                    if (!(err instanceof Error) || err.name !== 'TimeoutError')
+                        throw err;
+                    await scroller.evaluate((el) => {
+                        el.scrollLeft = Math.min(el.scrollLeft + el.clientWidth, el.scrollWidth);
+                    });
+                    nudged = true;
+                }
+            }
+        },
+        scrollToRow: async ({ page }, rowIndex) => {
+            const scroller = page.locator('.dvn-scroller').first();
+            // aria-rowindex is 2-based for data rows (header = 1)
+            const ariaRowIndex = rowIndex + 2;
+            const rowSel = `table[role="grid"] tbody tr[aria-rowindex="${ariaRowIndex}"]`;
+            // If the row is already mounted, scroll it into view directly.
+            const isAttached = await page.locator(rowSel).count() > 0;
+            if (isAttached) {
+                await page.locator(rowSel).first().scrollIntoViewIfNeeded();
+            }
+            else {
+                // Measure actual row height from the DOM; fall back to Glide's default (34px).
+                const rowHeight = await page
+                    .locator('table[role="grid"] tbody tr')
+                    .first()
+                    .evaluate((el) => el.getBoundingClientRect().height)
+                    .catch(() => 34);
+                const height = rowHeight > 0 ? rowHeight : 34;
+                await scroller.evaluate((el, { idx, height: h }) => {
+                    const targetTop = idx * h;
+                    el.scrollTop = Math.max(0, targetTop - Math.floor(el.clientHeight / 2));
+                }, { idx: rowIndex, height });
+                await page
+                    .locator(rowSel)
+                    .waitFor({ state: 'attached', timeout: attachTimeout });
+            }
+        },
+    };
+};
+exports.createGlideViewport = createGlideViewport;

package/dist/presets/index.d.ts

@@ -1,3 +1,4 @@
 export { muiTable, muiDataGrid } from './mui';
 export { RDG as rdg } from './rdg';
-export { Glide as glide } from './glide';
+export { Glide as glide, createGlide, createGlideViewport } from './glide';
+export type { GlideOptions, GlideViewportOptions } from './glide';

package/dist/presets/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.glide = exports.rdg = exports.muiDataGrid = exports.muiTable = void 0;
+exports.createGlideViewport = exports.createGlide = exports.glide = exports.rdg = exports.muiDataGrid = exports.muiTable = void 0;
 var mui_1 = require("./mui");
 Object.defineProperty(exports, "muiTable", { enumerable: true, get: function () { return mui_1.muiTable; } });
 Object.defineProperty(exports, "muiDataGrid", { enumerable: true, get: function () { return mui_1.muiDataGrid; } });
@@ -8,3 +8,5 @@ var rdg_1 = require("./rdg");
 Object.defineProperty(exports, "rdg", { enumerable: true, get: function () { return rdg_1.RDG; } });
 var glide_1 = require("./glide");
 Object.defineProperty(exports, "glide", { enumerable: true, get: function () { return glide_1.Glide; } });
+Object.defineProperty(exports, "createGlide", { enumerable: true, get: function () { return glide_1.createGlide; } });
+Object.defineProperty(exports, "createGlideViewport", { enumerable: true, get: function () { return glide_1.createGlideViewport; } });

package/dist/presets/mui.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.muiDataGrid = exports.muiTable = void 0;
+const debugUtils_1 = require("../utils/debugUtils");
 /**
  * Safely wait for MUI pagination to stabilize.
  * Polls for displayed row text changes and waits for loading overlays to disappear.
@@ -86,13 +87,25 @@ exports.muiTable = {
                 const root = await getPaginationRoot(context);
                 const prevBtn = root.locator('button[aria-label="Go to previous page"]');
                 const displayedRows = root.locator('.MuiTablePagination-displayedRows');
-                let maxRetries = 50;
                 let clicked = false;
-                while (maxRetries-- > 0 && await prevBtn.count() > 0 && !(await prevBtn.isDisabled())) {
+                let noProgressCount = 0;
+                const NO_PROGRESS_LIMIT = 3;
+                while (await prevBtn.count() > 0 && !(await prevBtn.isDisabled())) {
                     const oldText = await displayedRows.innerText().catch(() => '');
                     await prevBtn.click();
                     await waitForMuiPaginationStabilization(context, displayedRows, oldText);
                     clicked = true;
+                    const newText = await displayedRows.innerText().catch(() => '');
+                    if (newText === oldText) {
+                        noProgressCount++;
+                        if (noProgressCount >= NO_PROGRESS_LIMIT) {
+                            (0, debugUtils_1.logDebug)(context.config, 'error', `goToFirst: no pagination progress after ${NO_PROGRESS_LIMIT} consecutive clicks — aborting to avoid infinite loop`);
+                            return false;
+                        }
+                    }
+                    else {
+                        noProgressCount = 0;
+                    }
                 }
                 return clicked;
             }