@rickcedwhat/playwright-smart-table 6.9.0 → 6.10.1

package/dist/useTable.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -56,7 +47,38 @@ const useTable = (rootLocator, configOptions = {}) => {
             isHeaderLoading: loading_1.LoadingStrategies.Headers.stable(200)
         }
     };
-    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: () => __awaiter(void 0, void 0, void 0, function* () { }) }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
+    const config = Object.assign(Object.assign({ rowSelector: "tbody tr", headerSelector: "thead th", cellSelector: "td", maxPages: 1, headerTransformer: ({ text }) => text, autoScroll: true, onReset: async () => { } }, configOptions), { strategies: Object.assign(Object.assign({}, defaultStrategies), configOptions.strategies) });
+    // Automatically memoize viewport range oracles so user-provided functions are
+    // pure DOM queries with no cache bookkeeping. Invalidated after each scroll call.
+    if (config.strategies.viewport && !config.strategies.viewport.disableCache) {
+        const vp = config.strategies.viewport;
+        let colRangeCache = null;
+        let rowRangeCache = null;
+        config.strategies.viewport = Object.assign(Object.assign({}, vp), { getVisibleColumnRange: vp.getVisibleColumnRange
+                ? async (ctx) => {
+                    if (!colRangeCache)
+                        colRangeCache = await vp.getVisibleColumnRange(ctx);
+                    return colRangeCache;
+                }
+                : undefined, getVisibleRowRange: vp.getVisibleRowRange
+                ? async (ctx) => {
+                    if (!rowRangeCache)
+                        rowRangeCache = await vp.getVisibleRowRange(ctx);
+                    return rowRangeCache;
+                }
+                : undefined, scrollToColumn: vp.scrollToColumn
+                ? async (ctx, colIndex) => {
+                    colRangeCache = null;
+                    rowRangeCache = null;
+                    await vp.scrollToColumn(ctx, colIndex);
+                }
+                : undefined, scrollToRow: vp.scrollToRow
+                ? async (ctx, rowIndex) => {
+                    rowRangeCache = null;
+                    await vp.scrollToRow(ctx, rowIndex);
+                }
+                : undefined });
+    }
     const resolve = (item, parent) => {
         if (typeof item === 'string')
             return parent.locator(item);
@@ -102,7 +124,7 @@ const useTable = (rootLocator, configOptions = {}) => {
     const rowFinder = new rowFinder_1.RowFinder(rootLocator, config, resolve, filterEngine, tableMapper, _makeSmart, tableState);
     /** Builds a full TableContext/StrategyContext with getHeaderCell, getHeaders, scrollToColumn. Set after result is created. */
     let createStrategyContext = () => ({ root: rootLocator, config, page: rootLocator.page(), resolve });
-    const _getCleanHtml = (loc) => __awaiter(void 0, void 0, void 0, function* () {
+    const _getCleanHtml = async (loc) => {
         return loc.evaluate((el) => {
             const clone = el.cloneNode(true);
             const removeSelectors = 'script, style, svg, path, circle, rect, noscript, [hidden]';
@@ -123,33 +145,33 @@ const useTable = (rootLocator, configOptions = {}) => {
             }
             return clone.outerHTML;
         });
-    });
-    const _handlePrompt = (promptName, content) => __awaiter(void 0, void 0, void 0, function* () {
+    };
+    const _handlePrompt = async (promptName, content) => {
         let finalPrompt = content;
         finalPrompt += `\n\n👇 Useful TypeScript Definitions 👇\n\`\`\`typescript\n${minimalConfigContext_1.MINIMAL_CONFIG_CONTEXT}\n\`\`\`\n`;
         console.log(`⚠️ Throwing error to display [${promptName}] cleanly...`);
         throw new Error(finalPrompt);
-    });
-    const _autoInit = () => __awaiter(void 0, void 0, void 0, function* () {
-        yield tableMapper.getMap();
-    });
+    };
+    const _autoInit = async () => {
+        await tableMapper.getMap();
+    };
     // Default: goNext (one page). Pass useBulk true to prefer goNextBulk. "How far" uses numeric return when strategy provides it.
-    const _advancePage = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (useBulk = false) {
+    const _advancePage = async (useBulk = false) => {
         const context = createStrategyContext();
         const pagination = config.strategies.pagination;
         let rawResult;
         let primitive;
         if (useBulk && (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk)) {
             primitive = 'goNextBulk';
-            rawResult = yield pagination.goNextBulk(context);
+            rawResult = await pagination.goNextBulk(context);
         }
         else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNext) {
             primitive = 'goNext';
-            rawResult = yield pagination.goNext(context);
+            rawResult = await pagination.goNext(context);
         }
         else if (pagination === null || pagination === void 0 ? void 0 : pagination.goNextBulk) {
             primitive = 'goNextBulk (fallback)';
-            rawResult = yield pagination.goNextBulk(context);
+            rawResult = await pagination.goNextBulk(context);
         }
         else {
             log('_advancePage: no pagination primitive available — returning false');
@@ -165,47 +187,91 @@ const useTable = (rootLocator, configOptions = {}) => {
             log(`_advancePage: ${primitive} returned false — end of data`);
         }
         return didAdvance;
-    });
+    };
     const result = {
         get currentPageIndex() { return tableState.currentPageIndex; },
         set currentPageIndex(v) { tableState.currentPageIndex = v; },
-        init: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        init: async (options) => {
+            var _a;
             if (tableMapper.isInitialized())
                 return result;
             (0, debugUtils_1.warnIfDebugInCI)(config);
             (0, debugUtils_1.logDebug)(config, 'info', 'Initializing table');
-            const map = yield tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
+            const map = await tableMapper.getMap(options === null || options === void 0 ? void 0 : options.timeout);
             (0, debugUtils_1.logDebug)(config, 'info', `Table initialized with ${map.size} columns`, Array.from(map.keys()));
-            yield (0, debugUtils_1.debugDelay)(config, 'default');
+            if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.detectCurrentPage) {
+                try {
+                    const detected = await config.strategies.pagination.detectCurrentPage(rootLocator);
+                    if (Number.isInteger(detected) && detected >= 0) {
+                        tableState.currentPageIndex = detected;
+                        (0, debugUtils_1.logDebug)(config, 'info', `init: detected starting page index ${detected}`);
+                    }
+                    else {
+                        tableState.currentPageIndex = 0;
+                        (0, debugUtils_1.logDebug)(config, 'error', `init: detectCurrentPage returned invalid index (${detected}); defaulting to 0`);
+                    }
+                }
+                catch (e) {
+                    tableState.currentPageIndex = 0;
+                    (0, debugUtils_1.logDebug)(config, 'error', `init: detectCurrentPage failed`, e);
+                }
+            }
+            await (0, debugUtils_1.debugDelay)(config, 'default');
             return result;
-        }),
-        scrollToColumn: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+        },
+        scrollToColumn: async (columnName) => {
+            const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map);
             // Use header cell for scrolling
             const headerCell = resolve(config.headerSelector, rootLocator).nth(idx);
-            yield headerCell.scrollIntoViewIfNeeded();
-        }),
-        getHeaders: () => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+            await headerCell.scrollIntoViewIfNeeded();
+        },
+        getHeaders: async () => {
+            const map = await tableMapper.getMap();
             return Array.from(map.keys());
-        }),
-        getHeaderCell: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-            const map = yield tableMapper.getMap();
+        },
+        getHeaderCell: async (columnName) => {
+            const map = await tableMapper.getMap();
             const idx = map.get(columnName);
             if (idx === undefined)
                 throw _createColumnError(columnName, map, 'header cell');
             return resolve(config.headerSelector, rootLocator).nth(idx);
-        }),
-        reset: () => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        countRows: async () => {
+            await _autoInit();
+            const allRows = resolve(config.rowSelector, rootLocator);
+            return allRows.count();
+        },
+        mapColumn: async (columnName, options = {}) => {
+            await _autoInit();
+            const map = await tableMapper.getMap();
+            if (!map.has(columnName))
+                throw _createColumnError(columnName, map, 'mapColumn iteration');
+            return result.map(async ({ row }) => {
+                var _a;
+                const cell = row.getCell(columnName);
+                await cell.bringIntoView();
+                const columnOverride = (_a = config.columnOverrides) === null || _a === void 0 ? void 0 : _a[columnName];
+                if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.read) {
+                    return await columnOverride.read(cell);
+                }
+                const text = await cell.innerText();
+                return (text || '').trim();
+            }, options);
+        },
+        getColumnValues: async (columnName, options = {}) => {
+            const values = await result.mapColumn(columnName, options);
+            return values.map(v => String(v));
+        },
+        reset: async () => {
             var _a;
             log("Resetting table...");
-            yield config.onReset(createStrategyContext());
+            await config.onReset(createStrategyContext());
             if ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goToFirst) {
                 log("Auto-navigating to first page...");
-                yield config.strategies.pagination.goToFirst(createStrategyContext());
+                await config.strategies.pagination.goToFirst(createStrategyContext());
             }
             else if (hasPaginationInConfig) {
                 log("No goToFirst strategy configured. Table may not be on page 1.");
@@ -214,13 +280,13 @@ const useTable = (rootLocator, configOptions = {}) => {
             tableState.currentPageIndex = 0;
             tableMapper.clear();
             log("Table reset complete. Calling autoInit to restore state.");
-            yield _autoInit();
-        }),
-        revalidate: () => __awaiter(void 0, void 0, void 0, function* () {
+            await _autoInit();
+        },
+        revalidate: async () => {
             log("Revalidating table structure...");
-            yield tableMapper.remapHeaders();
+            await tableMapper.remapHeaders();
             log("Table revalidated.");
-        }),
+        },
         getRow: (filters, options = { exact: false }) => {
             const map = tableMapper.getMapSync();
             if (!map)
@@ -237,53 +303,53 @@ const useTable = (rootLocator, configOptions = {}) => {
             const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
             return _makeSmart(rowLocator, map, index);
         },
-        findRow: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+        findRow: async (filters, options) => {
             return rowFinder.findRow(filters, options);
-        }),
-        findRows: (filters, options) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        findRows: async (filters, options) => {
             return rowFinder.findRows(filters !== null && filters !== void 0 ? filters : {}, options);
-        }),
+        },
         isInitialized: () => {
             return tableMapper.isInitialized();
         },
         sorting: {
-            apply: (columnName, direction) => __awaiter(void 0, void 0, void 0, function* () {
+            apply: async (columnName, direction) => {
                 var _a;
-                yield _autoInit();
+                await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
                 log(`Applying sort for column "${columnName}" (${direction})`);
                 const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
                 const maxRetries = 3;
                 for (let i = 0; i < maxRetries; i++) {
-                    const currentState = yield config.strategies.sorting.getSortState({ columnName, context });
+                    const currentState = await config.strategies.sorting.getSortState({ columnName, context });
                     if (currentState === direction) {
                         log(`Sort for "${columnName}" is already "${direction}".`);
                         return;
                     }
-                    yield config.strategies.sorting.doSort({ columnName, direction, context });
+                    await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        yield config.strategies.loading.isTableLoading(context);
+                        await config.strategies.loading.isTableLoading(context);
                     }
                     else {
-                        yield rootLocator.page().waitForTimeout(200);
+                        await rootLocator.page().waitForTimeout(200);
                     }
-                    yield (0, debugUtils_1.debugDelay)(config, 'default');
-                    const newState = yield config.strategies.sorting.getSortState({ columnName, context });
+                    await (0, debugUtils_1.debugDelay)(config, 'default');
+                    const newState = await config.strategies.sorting.getSortState({ columnName, context });
                     if (newState === direction) {
                         log(`Successfully sorted "${columnName}" to "${direction}".`);
                         return;
                     }
                 }
                 throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${maxRetries} attempts.`);
-            }),
-            getState: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-                yield _autoInit();
+            },
+            getState: async (columnName) => {
+                await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
                 const context = Object.assign(Object.assign({}, createStrategyContext()), { getHeaderCell: result.getHeaderCell });
                 return config.strategies.sorting.getSortState({ columnName, context });
-            })
+            }
         },
         // ─── Shared async row iterator ───────────────────────────────────────────
         [Symbol.asyncIterator]() {
@@ -318,9 +384,9 @@ const useTable = (rootLocator, configOptions = {}) => {
             });
         },
         // ─── Row iteration (delegated to engine/tableIteration) ──────────────────
-        forEach: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            yield _autoInit();
-            yield (0, tableIteration_1.runForEach)({
+        forEach: async (callback, options = {}) => {
+            await _autoInit();
+            await (0, tableIteration_1.runForEach)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
                 advancePage: _advancePage,
@@ -329,9 +395,9 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, callback, options);
-        }),
-        map: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            yield _autoInit();
+        },
+        map: async (callback, options = {}) => {
+            await _autoInit();
             return (0, tableIteration_1.runMap)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
@@ -341,9 +407,9 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, callback, options);
-        }),
-        filter: (predicate_1, ...args_1) => __awaiter(void 0, [predicate_1, ...args_1], void 0, function* (predicate, options = {}) {
-            yield _autoInit();
+        },
+        filter: async (predicate, options = {}) => {
+            await _autoInit();
             return (0, tableIteration_1.runFilter)({
                 getRowLocators: () => resolve(config.rowSelector, rootLocator),
                 getMap: () => tableMapper.getMapSync(),
@@ -353,17 +419,17 @@ const useTable = (rootLocator, configOptions = {}) => {
                 config,
                 getPage: () => rootLocator.page(),
             }, predicate, options);
-        }),
-        generateConfig: () => __awaiter(void 0, void 0, void 0, function* () {
-            const html = yield _getCleanHtml(rootLocator);
+        },
+        generateConfig: async () => {
+            const html = await _getCleanHtml(rootLocator);
             const separator = "=".repeat(50);
             const content = `\n${separator} \n🤖 COPY INTO GEMINI / ChatGPT 🤖\n${separator} \nI am using 'playwright-smart-table'.\nTarget Table Locator: ${rootLocator.toString()} \nGenerate config for: \n\`\`\`html\n${html.substring(0, 10000)} ...\n\`\`\`\n${separator}\n`;
-            yield _handlePrompt('Smart Table Config', content);
-        }),
-        generateConfigPrompt: () => __awaiter(void 0, void 0, void 0, function* () {
+            await _handlePrompt('Smart Table Config', content);
+        },
+        generateConfigPrompt: async () => {
             console.warn('⚠️ [playwright-smart-table] generateConfigPrompt() is deprecated and will be removed in v7.0.0. Please use generateConfig() instead.');
             return result.generateConfig();
-        }),
+        },
     };
     createStrategyContext = () => ({
         root: rootLocator,

package/dist/utils/debugUtils.js

@@ -1,13 +1,4 @@
 "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.getDebugDelay = getDebugDelay;
 exports.debugDelay = debugDelay;
@@ -28,13 +19,11 @@ function getDebugDelay(config, actionType) {
 /**
  * Add debug delay for specific action type
  */
-function debugDelay(config, actionType) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const delay = getDebugDelay(config, actionType);
-        if (delay > 0) {
-            yield new Promise(resolve => setTimeout(resolve, delay));
-        }
-    });
+async function debugDelay(config, actionType) {
+    const delay = getDebugDelay(config, actionType);
+    if (delay > 0) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
 }
 /**
  * Log debug message based on log level

package/dist/utils/elementTracker.js

@@ -1,13 +1,4 @@
 "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.ElementTracker = void 0;
 class ElementTracker {
@@ -19,42 +10,38 @@ class ElementTracker {
      * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
      * virtualized DOMs (by text signature if nodes are recycled).
      */
-    getUnseenIndices(locators) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield locators.evaluateAll((elements, trackerId) => {
-                const win = window;
-                if (!win[trackerId]) {
-                    win[trackerId] = new WeakMap();
+    async getUnseenIndices(locators) {
+        return await locators.evaluateAll((elements, trackerId) => {
+            const win = window;
+            if (!win[trackerId]) {
+                win[trackerId] = new WeakMap();
+            }
+            const seenMap = win[trackerId];
+            const newIndices = [];
+            elements.forEach((el, index) => {
+                // Determine a lightweight signature for the row (textContent strips HTML, fast)
+                const signature = el.textContent || '';
+                // If it's a new element, OR a recycled element with new data
+                if (seenMap.get(el) !== signature) {
+                    seenMap.set(el, signature);
+                    newIndices.push(index);
                 }
-                const seenMap = win[trackerId];
-                const newIndices = [];
-                elements.forEach((el, index) => {
-                    // Determine a lightweight signature for the row (textContent strips HTML, fast)
-                    const signature = el.textContent || '';
-                    // If it's a new element, OR a recycled element with new data
-                    if (seenMap.get(el) !== signature) {
-                        seenMap.set(el, signature);
-                        newIndices.push(index);
-                    }
-                });
-                return newIndices;
-            }, this.id);
-        });
+            });
+            return newIndices;
+        }, this.id);
     }
     /**
      * Cleans up the tracking map from the browser window object.
      */
-    cleanup(page) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield page.evaluate((trackerId) => {
-                    delete window[trackerId];
-                }, this.id);
-            }
-            catch (e) {
-                // Ignore context destroyed errors during cleanup
-            }
-        });
+    async cleanup(page) {
+        try {
+            await page.evaluate((trackerId) => {
+                delete window[trackerId];
+            }, this.id);
+        }
+        catch (e) {
+            // Ignore context destroyed errors during cleanup
+        }
     }
 }
 exports.ElementTracker = ElementTracker;

package/dist/utils/mutex.js

@@ -1,13 +1,4 @@
 "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.Mutex = void 0;
 /**
@@ -18,14 +9,12 @@ class Mutex {
     constructor() {
         this.queue = Promise.resolve();
     }
-    run(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const next = this.queue.then(() => __awaiter(this, void 0, void 0, function* () {
-                return yield action();
-            }));
-            this.queue = next.catch(() => { }); // prevent chain breakage
-            return yield next;
+    async run(action) {
+        const next = this.queue.then(async () => {
+            return await action();
         });
+        this.queue = next.catch(() => { }); // prevent chain breakage
+        return await next;
     }
 }
 exports.Mutex = Mutex;

package/dist/utils/navigationBarrier.js

@@ -1,13 +1,4 @@
 "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.NavigationBarrier = void 0;
 /**
@@ -25,34 +16,32 @@ class NavigationBarrier {
      * Synchronize all active rows at a specific column index.
      * The last row to arrive will trigger the `moveAction`.
      */
-    sync(colIndex, moveAction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.total <= 1) {
-                if (moveAction)
-                    return yield moveAction();
-                return;
+    async sync(colIndex, moveAction) {
+        if (this.total <= 1) {
+            if (moveAction)
+                return await moveAction();
+            return;
+        }
+        return new Promise((resolve) => {
+            let bucket = this.buckets.get(colIndex);
+            if (!bucket) {
+                bucket = new Set();
+                this.buckets.set(colIndex, bucket);
+            }
+            bucket.add(resolve);
+            if (bucket.size + this.finishedCount >= this.total) {
+                // Use a self-executing async function to handle the moveAction synchronously in this context
+                (async () => {
+                    let result;
+                    try {
+                        if (moveAction)
+                            result = await moveAction();
+                    }
+                    finally {
+                        this.broadcast(colIndex, result);
+                    }
+                })();
             }
-            return new Promise((resolve) => {
-                let bucket = this.buckets.get(colIndex);
-                if (!bucket) {
-                    bucket = new Set();
-                    this.buckets.set(colIndex, bucket);
-                }
-                bucket.add(resolve);
-                if (bucket.size + this.finishedCount >= this.total) {
-                    // Use a self-executing async function to handle the moveAction synchronously in this context
-                    (() => __awaiter(this, void 0, void 0, function* () {
-                        let result;
-                        try {
-                            if (moveAction)
-                                result = yield moveAction();
-                        }
-                        finally {
-                            this.broadcast(colIndex, result);
-                        }
-                    }))();
-                }
-            });
         });
     }
     /**

package/dist/utils/paginationPath.d.ts

@@ -3,6 +3,9 @@ import type { PaginationPrimitives, TableContext } from '../types';
 export type NavigationStep = {
     type: 'goToPage';
     pageIndex: number;
+} | {
+    type: 'goToLast';
+    targetIndex: number;
 } | {
     type: 'goNextBulk';
     count: number;
@@ -22,7 +25,7 @@ export type NavigationStep = {
  * single steps (goNext / goPrevious). May choose to overshoot with bulk then step back when
  * that reduces total primitive calls (e.g. page 3 → 12 with bulk 10: goNextBulk once, goPrevious once).
  */
-export declare function planNavigationPath(currentPageIndex: number, targetPageIndex: number, primitives: PaginationPrimitives): NavigationStep[];
+export declare function planNavigationPath(currentPageIndex: number, targetPageIndex: number, primitives: PaginationPrimitives, totalPages?: number): NavigationStep[];
 /**
  * Navigate to targetPageIndex when goToPage is available but may be "windowed"
  * (e.g. only works for visible page links 6–14). Tries goToPage(target); on false,