@rickcedwhat/playwright-smart-table 6.12.0 → 6.14.0

package/README.md

@@ -4,6 +4,7 @@
 
 [![npm version](https://img.shields.io/github/package-json/v/rickcedwhat/playwright-smart-table?label=npm&color=blue&t=2)](https://www.npmjs.com/package/@rickcedwhat/playwright-smart-table)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CodeRabbit Reviews](https://img.shields.io/coderabbit/prs/github/rickcedwhat/playwright-smart-table?utm_source=oss&utm_medium=github&utm_campaign=rickcedwhat%2Fplaywright-smart-table&labelColor=171717&color=FF570A&link=https%3A%2F%2Fcoderabbit.ai&label=CodeRabbit+Reviews)](https://coderabbit.ai)
 
 ## 📚 [Full Documentation →](https://rickcedwhat.github.io/playwright-smart-table/)
 
@@ -45,6 +46,7 @@ await table.forEach(async ({ row }) => {
 npm install @rickcedwhat/playwright-smart-table
 ```
 
+
 ## Quick Start
 
 ```typescript

package/dist/engine/rowFinder.d.ts

@@ -14,7 +14,6 @@ export declare class RowFinder<T = any> {
     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;

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();
@@ -45,11 +42,11 @@ 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 () => {
-                var _a, _b;
+                var _a, _b, _c, _d, _e;
                 let rowLocators = this.resolve(this.config.rowSelector, this.rootLocator);
                 // Only apply filters if we have them
                 if (Object.keys(filtersRecord).length > 0) {
@@ -59,17 +56,47 @@ class RowFinder {
                 const newIndices = await tracker.getUnseenIndices(rowLocators);
                 const currentRows = await rowLocators.all();
                 const isRowLoading = (_b = this.config.strategies.loading) === null || _b === void 0 ? void 0 : _b.isRowLoading;
+                const rawRowTimeout = (_c = this.config.strategies.loading) === null || _c === void 0 ? void 0 : _c.rowLoadingTimeout;
+                // undefined = unset (legacy skip); 0 = no wait (immediate check); >0 = wait up to N ms
+                // Non-finite values are treated as unset (defensive guard against Infinity/NaN)
+                const rowLoadingTimeout = rawRowTimeout !== undefined && Number.isFinite(rawRowTimeout) && rawRowTimeout >= 0
+                    ? rawRowTimeout
+                    : undefined;
+                const onRowLoadingTimeout = (_e = (_d = this.config.strategies.loading) === null || _d === void 0 ? void 0 : _d.onRowLoadingTimeout) !== null && _e !== void 0 ? _e : 'read-as-is';
                 let added = 0;
                 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)`);
-                        continue;
+                        if (rowLoadingTimeout === undefined) {
+                            // No timeout configured (or invalid value) — legacy skip behavior
+                            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: page ${this.tableState.currentPageIndex} — row skipped (isRowLoading=true, no timeout)`);
+                            continue;
+                        }
+                        // Wait up to rowLoadingTimeout ms (0 = one immediate re-check, no polling)
+                        (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — waiting up to ${rowLoadingTimeout}ms for row to load`);
+                        const deadline = Date.now() + rowLoadingTimeout;
+                        let resolved = !(await isRowLoading(smartRow)); // immediate check (handles timeout=0)
+                        while (!resolved && Date.now() < deadline) {
+                            await currentRows[idx].page().waitForTimeout(100);
+                            resolved = !(await isRowLoading(smartRow));
+                        }
+                        if (!resolved) {
+                            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — still loading after ${rowLoadingTimeout}ms, action: ${onRowLoadingTimeout}`);
+                            if (onRowLoadingTimeout === 'skip')
+                                continue;
+                            if (onRowLoadingTimeout === 'throw') {
+                                throw new Error(`[SmartTable] Row ${allRows.length} did not finish loading within ${rowLoadingTimeout}ms`);
+                            }
+                            // 'read-as-is': fall through and add the row
+                        }
+                        else {
+                            (0, debugUtils_1.logDebug)(this.config, 'verbose', `findRows: row ${allRows.length} — finished loading`);
+                        }
                     }
                     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();
@@ -90,25 +117,26 @@ class RowFinder {
                     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 = {}) {
@@ -116,7 +144,7 @@ class RowFinder {
         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) {
@@ -127,7 +155,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;
                 }
@@ -135,7 +163,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 {
@@ -154,7 +182,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,
@@ -171,7 +199,7 @@ class RowFinder {
                     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');
@@ -179,10 +207,12 @@ 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;

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).
@@ -67,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) {
@@ -86,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.12.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.14.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.12.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.14.0";

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
     },
@@ -102,11 +97,29 @@ const GlideDefaultStrategies = {
     getActiveCell: glideGetActiveCell
 };
 /** Strategies only for Glide Data Grid. Includes fillSimple; use when you want to supply your own selectors or override fill. */
+// fallow-ignore-next-line unused-export
 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/rdg.js

@@ -100,6 +100,7 @@ const RDGDefaultStrategies = {
     pagination: rdgPaginationStrategy
 };
 /** Full strategies for React Data Grid. Use when you want to supply your own selectors: strategies: Plugins.RDG.Strategies */
+// fallow-ignore-next-line unused-export
 exports.RDGStrategies = RDGDefaultStrategies;
 /**
  * Full preset for React Data Grid (selectors + default strategies).