@rickcedwhat/playwright-smart-table 6.23.1 → 6.24.0-next.82106e1

package/dist/strategies/headers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HeaderStrategies = void 0;
 const debugUtils_1 = require("../utils/debugUtils");
+const headerScroll_1 = require("../utils/headerScroll");
 exports.HeaderStrategies = {
     /**
      * Default strategy: Returns only the headers currently visible in the DOM.
@@ -30,62 +31,18 @@ exports.HeaderStrategies = {
      */
     horizontalScroll: (options) => {
         return async (context) => {
-            var _a, _b;
-            const { resolve, config, root, page } = context;
-            const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 20;
-            const scrollAmount = (_b = options === null || options === void 0 ? void 0 : options.scrollAmount) !== null && _b !== void 0 ? _b : 300;
-            const collectedHeaders = new Set();
-            const getVisible = async () => {
-                const headerLoc = resolve(config.headerSelector, root);
-                const texts = await headerLoc.allInnerTexts();
-                return texts.map(t => t.trim());
-            };
-            let currentHeaders = await getVisible();
-            currentHeaders.forEach(h => collectedHeaders.add(h));
             const selector = options === null || options === void 0 ? void 0 : options.selector;
             if (!selector) {
-                (0, debugUtils_1.logDebug)(config, 'info', 'HeaderStrategies.horizontalScroll: no selector provided — returning visible headers only. Pass { selector } for the scroll container (e.g. ".dvn-scroller").');
-                return Array.from(collectedHeaders);
+                (0, debugUtils_1.logDebug)(context.config, 'info', 'HeaderStrategies.horizontalScroll: no selector provided — returning visible headers only. Pass { selector } for the scroll container (e.g. ".dvn-scroller").');
+                return (0, headerScroll_1.readVisibleHeaders)(context);
             }
-            const scrollerHandle = await root.evaluateHandle((el, sel) => {
-                if (el.matches(sel))
-                    return el;
-                const ancestor = el.closest(sel);
-                if (ancestor)
-                    return ancestor;
-                const child = el.querySelector(sel);
-                if (child)
-                    return child;
-                return null;
-            }, selector);
-            const isScrollerFound = await scrollerHandle.evaluate(el => !!el);
-            if (isScrollerFound) {
-                await scrollerHandle.evaluate(el => el.scrollLeft = 0);
-                await page.waitForTimeout(200);
-                for (let i = 0; i < limit; i++) {
-                    const sizeBefore = collectedHeaders.size;
-                    await scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
-                    await page.waitForTimeout(300);
-                    const newHeaders = await getVisible();
-                    newHeaders.forEach(h => collectedHeaders.add(h));
-                    if (collectedHeaders.size === sizeBefore) {
-                        await scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
-                        await page.waitForTimeout(300);
-                        const retryHeaders = await getVisible();
-                        retryHeaders.forEach(h => collectedHeaders.add(h));
-                        if (collectedHeaders.size === sizeBefore)
-                            break;
-                    }
-                }
-            }
-            else {
-                (0, debugUtils_1.logDebug)(config, 'info', `HeaderStrategies.horizontalScroll: Could not find scroller matching "${selector}". Returning visible headers.`);
-            }
-            if (isScrollerFound) {
-                await scrollerHandle.evaluate(el => el.scrollLeft = 0);
-                await page.waitForTimeout(200);
-            }
-            return Array.from(collectedHeaders);
+            // Self, then ancestor, then descendant — scoped to the table, never document-wide.
+            const findScroller = () => context.root.evaluateHandle((el, sel) => { var _a; return el.matches(sel) ? el : (_a = el.closest(sel)) !== null && _a !== void 0 ? _a : el.querySelector(sel); }, selector);
+            return (0, headerScroll_1.scrollAndCollectHeaders)(context, findScroller, {
+                limit: options === null || options === void 0 ? void 0 : options.limit,
+                scrollAmount: options === null || options === void 0 ? void 0 : options.scrollAmount,
+                notFoundMessage: `HeaderStrategies.horizontalScroll: Could not find scroller matching "${selector}". Returning visible headers.`,
+            });
         };
     }
 };

package/dist/strategies/index.d.ts

@@ -3,7 +3,6 @@ export * from './sorting';
 export * from './columns';
 export * from './headers';
 export * from './fill';
-export type { ColumnResolutionStrategy } from './resolution';
 export * from './dedupe';
 export * from './loading';
 export * from './stabilization';
@@ -29,13 +28,13 @@ export declare const Strategies: {
         }, options?: {
             nextBulkPages?: number;
             previousBulkPages?: number;
-            numberOfPages?: number | ((root: import("@playwright/test").Locator) => number | Promise<number>);
-            detectCurrentPage?: (root: import("@playwright/test").Locator) => number | Promise<number>;
+            numberOfPages?: number | ((root: import('@playwright/test').Locator) => number | Promise<number>);
+            detectCurrentPage?: (root: import('@playwright/test').Locator) => number | Promise<number>;
             stabilization?: import("./stabilization").StabilizationStrategy;
             timeout?: number;
         }) => import("..").PaginationStrategy;
         infiniteScroll: (options?: {
-            action?: "scroll" | "js-scroll";
+            action?: 'scroll' | 'js-scroll';
             scrollTarget?: import("..").Selector;
             scrollAmount?: number;
             stabilization?: import("./stabilization").StabilizationStrategy;
@@ -81,7 +80,7 @@ export declare const Strategies: {
     };
     Stabilization: {
         contentChanged: (options?: {
-            scope?: "all" | "first";
+            scope?: 'all' | 'first';
             timeout?: number;
         }) => import("./stabilization").StabilizationStrategy;
         rowCountIncreased: (options?: {
@@ -102,10 +101,10 @@ export declare const Strategies: {
         textStable: (options?: {
             timeout?: number;
             interval?: number;
-        }) => import("./contentReady").ContentReadyStrategy;
+        }) => import("..").ContentReadyStrategy;
         mutationSettled: (options?: {
             timeout?: number;
             quietPeriod?: number;
-        }) => import("./contentReady").ContentReadyStrategy;
+        }) => import("..").ContentReadyStrategy;
     };
 };

package/dist/strategies/pagination.d.ts

@@ -19,8 +19,8 @@ export declare const PaginationStrategies: {
     }, options?: {
         nextBulkPages?: number;
         previousBulkPages?: number;
-        numberOfPages?: number | ((root: import("@playwright/test").Locator) => number | Promise<number>);
-        detectCurrentPage?: (root: import("@playwright/test").Locator) => number | Promise<number>;
+        numberOfPages?: number | ((root: import('@playwright/test').Locator) => number | Promise<number>);
+        detectCurrentPage?: (root: import('@playwright/test').Locator) => number | Promise<number>;
         stabilization?: StabilizationStrategy;
         timeout?: number;
     }) => PaginationStrategy;
@@ -30,13 +30,16 @@ export declare const PaginationStrategies: {
      *
      * @param options.action 'scroll' (mouse wheel) or 'js-scroll' (direct scrollTop).
      * @param options.scrollTarget Selector for the scroll container (defaults to table root).
-     * @param options.scrollAmount Amount to scroll in pixels (default 500).
+     * @param options.scrollAmount Amount to scroll in pixels. Defaults to 80% of the scroll target's
+     *        visible height, so a step never jumps past the rendered window of a virtualized list.
+     *        An explicit value larger than the visible height logs a one-time warning, because
+     *        virtualizers never mount the rows that get skipped.
      * @param options.stabilization Strategy to determine if new content loaded.
      *        Defaults to `rowCountIncreased` (simple append).
      *        Use `contentChanged` for virtualization.
      */
     infiniteScroll: (options?: {
-        action?: "scroll" | "js-scroll";
+        action?: 'scroll' | 'js-scroll';
         scrollTarget?: Selector;
         scrollAmount?: number;
         stabilization?: StabilizationStrategy;

package/dist/strategies/pagination.js

@@ -67,23 +67,46 @@ exports.PaginationStrategies = {
      *
      * @param options.action 'scroll' (mouse wheel) or 'js-scroll' (direct scrollTop).
      * @param options.scrollTarget Selector for the scroll container (defaults to table root).
-     * @param options.scrollAmount Amount to scroll in pixels (default 500).
+     * @param options.scrollAmount Amount to scroll in pixels. Defaults to 80% of the scroll target's
+     *        visible height, so a step never jumps past the rendered window of a virtualized list.
+     *        An explicit value larger than the visible height logs a one-time warning, because
+     *        virtualizers never mount the rows that get skipped.
      * @param options.stabilization Strategy to determine if new content loaded.
      *        Defaults to `rowCountIncreased` (simple append).
      *        Use `contentChanged` for virtualization.
      */
     infiniteScroll: (options = {}) => {
-        var _a, _b;
+        var _a;
         // Default stabilization: Wait for row count to increase (Append mode)
         const stabilization = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.rowCountIncreased({ timeout: options.timeout });
-        const amount = (_b = options.scrollAmount) !== null && _b !== void 0 ? _b : 500;
+        let warnedOversizedStep = false;
         const createScroller = (directionMultiplier) => {
             return async (context) => {
                 const { root, resolve, page } = context;
                 const scrollTarget = options.scrollTarget
                     ? resolve(options.scrollTarget, root)
                     : root;
-                const beforeScrollTop = await scrollTarget.evaluate((el) => el.scrollTop);
+                const metrics = await scrollTarget.evaluate((el) => {
+                    const viewportHeight = window.innerHeight || document.documentElement.clientHeight;
+                    return {
+                        scrollTop: el.scrollTop,
+                        // A non-scrolling target scrolls the page, so the window bounds what is rendered.
+                        visibleHeight: el.clientHeight > 0 ? Math.min(el.clientHeight, viewportHeight) : viewportHeight,
+                        isScrollContainer: el.scrollHeight > el.clientHeight + 1,
+                    };
+                });
+                const beforeScrollTop = metrics.scrollTop;
+                let amount;
+                if (options.scrollAmount !== undefined) {
+                    amount = options.scrollAmount;
+                    if (!warnedOversizedStep && metrics.isScrollContainer && amount > metrics.visibleHeight) {
+                        warnedOversizedStep = true;
+                        console.warn(`[SmartTable] infiniteScroll scrollAmount (${amount}px) is larger than the scroll target's visible height (${Math.round(metrics.visibleHeight)}px). Virtualized lists only render rows near the viewport, so rows between steps are never mounted and will be silently skipped. Omit scrollAmount to step by the visible height, or pass a smaller value.`);
+                    }
+                }
+                else {
+                    amount = Math.floor(metrics.visibleHeight * 0.8) || 500;
+                }
                 const doScroll = async () => {
                     const box = await scrollTarget.boundingBox();
                     const scrollValue = amount * directionMultiplier;

package/dist/strategies/resolution.d.ts

@@ -1,4 +1,5 @@
 import { StrategyContext } from '../types';
+/** @deprecated Not used by the library. Will be removed in v7. */
 export interface ColumnResolutionStrategy {
     /**
      * Resolves a column name (string or Regex) to a column index.
@@ -17,6 +18,3 @@ export interface ColumnResolutionStrategy {
         headerMap: Map<string, number>;
     }): string;
 }
-export declare const ResolutionStrategies: {
-    default: ColumnResolutionStrategy;
-};

package/dist/strategies/resolution.js

@@ -1,30 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResolutionStrategies = void 0;
-exports.ResolutionStrategies = {
-    default: {
-        resolveIndex: ({ query, headerMap }) => {
-            // 1. Exact / String Match
-            if (typeof query === 'string') {
-                if (headerMap.has(query))
-                    return headerMap.get(query);
-            }
-            // 2. Regex Match
-            if (query instanceof RegExp) {
-                for (const [colName, idx] of headerMap.entries()) {
-                    if (query.test(colName))
-                        return idx;
-                }
-                return undefined;
-            }
-            // 3. (Optional) Fuzzy String Match fallback could go here
-            // But for strict default strategy, we might want to keep it simple first
-            // The original code didn't do fuzzy *resolution* logic inside the get(), it just did strict get().
-            // The fuzzy logic was only for *suggestions* on error.
-            return undefined;
-        },
-        resolveName: ({ query }) => {
-            return query.toString();
-        }
-    }
-};

package/dist/strategies/sorting.js

@@ -12,7 +12,7 @@ exports.SortingStrategies = {
      */
     AriaSort: () => {
         return {
-            async doSort({ columnName, direction, context }) {
+            async doSort({ columnName, context }) {
                 // getHeaderCell is always present on TableContext after table is initialized
                 const targetHeader = await context.getHeaderCell(columnName);
                 // The table engine handles verify-and-retry. We only provide the trigger here.

package/dist/strategies/stabilization.d.ts

@@ -9,7 +9,7 @@ export declare const StabilizationStrategies: {
      * Waits for the visible text of the table rows to change.
      */
     contentChanged: (options?: {
-        scope?: "all" | "first";
+        scope?: 'all' | 'first';
         timeout?: number;
     }) => StabilizationStrategy;
     /**

package/dist/strategies/viewport.d.ts

@@ -50,6 +50,38 @@ export type DataAttributeViewportOptions = {
      */
     columnOffset?: number;
 };
+/**
+ * Viewport strategies for tables where row and cell elements carry a DOM attribute
+ * equal to their index (e.g. Braintrust logs table, TanStack-style grids).
+ *
+ * Derives selectors from the table config so no duplication is needed:
+ *   - getVisibleColumnRange — reads column attribute from cells in the first visible row
+ *   - getVisibleRowRange   — reads row attribute from all visible row elements
+ *   - scrollToColumn       — aligns header's left edge to container left, waits for cell mount
+ *   - scrollToRow          — scrolls row into view, waits for row mount
+ *
+ * **Important:** `rowAttribute` must be present on the elements matched by `rowSelector`,
+ * not on child cells. If row elements lack the attribute, `getVisibleRowRange` returns
+ * `{first:0, last:0}` and logs a warning at the `error` log level.
+ *
+ * @example
+ * // TanStack / Braintrust — pass your scroll container explicitly (no Tailwind default)
+ * viewport: Strategies.Viewport.dataAttribute({
+ *   scrollContainer: 'div[class*="overflow-auto"]',
+ * })
+ *
+ * @example
+ * // ARIA grid (aria-rowindex / aria-colindex, 1-based)
+ * viewport: Strategies.Viewport.dataAttribute({
+ *   scrollContainer: '.MuiDataGrid-virtualScroller',
+ *   rowAttribute: 'aria-rowindex',
+ *   columnAttribute: 'aria-colindex',
+ *   rowOffset: 1,
+ *   columnOffset: 1,
+ * })
+ */
+declare const dataAttribute: (options?: DataAttributeViewportOptions) => ViewportStrategy;
 export declare const ViewportStrategies: {
-    dataAttribute: (options?: DataAttributeViewportOptions) => ViewportStrategy;
+    dataAttribute: typeof dataAttribute;
 };
+export {};

package/dist/useTable.js

@@ -38,7 +38,7 @@ const smartRowInternals_1 = require("./utils/smartRowInternals");
 // Helper to safely serialize objects containing functions for logging
 const safeStringify = (obj) => {
     try {
-        return JSON.stringify(obj, (key, value) => {
+        return JSON.stringify(obj, (_key, value) => {
             if (typeof value === 'function') {
                 return '[Function]';
             }
@@ -319,13 +319,14 @@ const useTable = (rootLocator, configOptions = {}) => {
             return resolve(config.headerSelector, rootLocator).nth(idx);
         },
         countRows: async (filters, options) => {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d;
+            var _e;
             if (tableState.empty)
                 return 0;
             await _autoInit();
             const filtersRecord = (filters !== null && filters !== void 0 ? filters : {});
             const hasFilters = Object.keys(filtersRecord).length > 0;
-            const effectiveMaxPages = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
+            const effectiveMaxPages = (_e = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _e !== void 0 ? _e : config.maxPages;
             const pag = config.strategies.pagination;
             const hasPagination = effectiveMaxPages > 1 && !!((pag === null || pag === void 0 ? void 0 : pag.goNext) || (pag === null || pag === void 0 ? void 0 : pag.goNextBulk));
             const domFilters = {};
@@ -333,10 +334,10 @@ const useTable = (rootLocator, configOptions = {}) => {
             const syntheticFilters = {};
             if (hasFilters) {
                 for (const [key, value] of Object.entries(filtersRecord)) {
-                    if ((_b = config.syntheticColumns) === null || _b === void 0 ? void 0 : _b[key]) {
+                    if ((_a = config.syntheticColumns) === null || _a === void 0 ? void 0 : _a[key]) {
                         syntheticFilters[key] = value;
                     }
-                    else if ((_d = (_c = config.columnOverrides) === null || _c === void 0 ? void 0 : _c[key]) === null || _d === void 0 ? void 0 : _d.read) {
+                    else if ((_c = (_b = config.columnOverrides) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.read) {
                         overrideFilters[key] = value;
                     }
                     else {
@@ -378,7 +379,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 return count;
             };
             // Wait for table to finish loading before counting
-            const isTableLoading = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.isTableLoading;
+            const isTableLoading = (_d = config.strategies.loading) === null || _d === void 0 ? void 0 : _d.isTableLoading;
             if (isTableLoading) {
                 const ctx = createStrategyContext();
                 await (0, loadingWait_1.waitWhileTableLoading)(config, ctx, rootLocator.page(), 'countRows');
@@ -597,7 +598,8 @@ const useTable = (rootLocator, configOptions = {}) => {
         },
         sorting: {
             apply: async (columnName, direction) => {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b;
+                var _c, _d, _e, _f;
                 await _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
@@ -612,15 +614,15 @@ const useTable = (rootLocator, configOptions = {}) => {
                     }
                     await config.strategies.sorting.doSort({ columnName, direction, context });
                     if ((_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading) {
-                        const timeout = (_c = (_b = config.strategies.loading.sortStabilizationTimeout) !== null && _b !== void 0 ? _b : config.strategies.loading.loadingTimeout) !== null && _c !== void 0 ? _c : 10000;
-                        const poll = (_d = config.strategies.loading.sortStabilizationPollInterval) !== null && _d !== void 0 ? _d : 100;
+                        const timeout = (_d = (_c = config.strategies.loading.sortStabilizationTimeout) !== null && _c !== void 0 ? _c : config.strategies.loading.loadingTimeout) !== null && _d !== void 0 ? _d : 10000;
+                        const poll = (_e = config.strategies.loading.sortStabilizationPollInterval) !== null && _e !== void 0 ? _e : 100;
                         await (0, loadingWait_1.waitWhileTableLoading)(config, context, rootLocator.page(), 'sorting.apply', {
                             timeout,
                             pollInterval: poll,
                         });
                     }
                     else {
-                        const fallback = (_f = (_e = config.strategies.loading) === null || _e === void 0 ? void 0 : _e.sortStabilizationFallbackDelay) !== null && _f !== void 0 ? _f : 200;
+                        const fallback = (_f = (_b = config.strategies.loading) === null || _b === void 0 ? void 0 : _b.sortStabilizationFallbackDelay) !== null && _f !== void 0 ? _f : 200;
                         await rootLocator.page().waitForTimeout(fallback);
                     }
                     await (0, debugUtils_1.debugDelay)(config, 'default');

package/dist/utils/debugUtils.js

@@ -8,7 +8,8 @@ exports.warnIfDebugInCI = warnIfDebugInCI;
  * Get delay for specific action type
  */
 function getDebugDelay(config, actionType) {
-    var _a, _b, _c;
+    var _a;
+    var _b, _c;
     if (!((_a = config.debug) === null || _a === void 0 ? void 0 : _a.slow))
         return 0;
     if (typeof config.debug.slow === 'number') {
@@ -29,7 +30,8 @@ async function debugDelay(config, actionType) {
  * Log debug message based on log level
  */
 function logDebug(config, level, message, data) {
-    var _a, _b;
+    var _a;
+    var _b;
     const logLevel = (_b = (_a = config.debug) === null || _a === void 0 ? void 0 : _a.logLevel) !== null && _b !== void 0 ? _b : 'none';
     const levels = { none: 0, error: 1, info: 2, verbose: 3 };
     if (levels[logLevel] >= levels[level]) {

package/dist/utils/headerScroll.d.ts

@@ -0,0 +1,13 @@
+import type { JSHandle } from '@playwright/test';
+import type { StrategyContext } from '../types';
+export declare const readVisibleHeaders: ({ resolve, config, root }: StrategyContext) => Promise<string[]>;
+/**
+ * Horizontal header discovery shared by `HeaderStrategies.horizontalScroll` and the Glide preset:
+ * reset the scroller to the left, step right collecting headers until two consecutive steps add
+ * nothing (or `limit` is hit), then scroll back. Callers differ only in how they find the scroller.
+ */
+export declare function scrollAndCollectHeaders(context: StrategyContext, findScroller: () => Promise<JSHandle<Element | null>>, options: {
+    limit?: number;
+    scrollAmount?: number;
+    notFoundMessage: string;
+}): Promise<string[]>;

package/dist/utils/headerScroll.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readVisibleHeaders = void 0;
+exports.scrollAndCollectHeaders = scrollAndCollectHeaders;
+const debugUtils_1 = require("./debugUtils");
+const readVisibleHeaders = async ({ resolve, config, root }) => {
+    const texts = await resolve(config.headerSelector, root).allInnerTexts();
+    return texts.map(t => t.trim());
+};
+exports.readVisibleHeaders = readVisibleHeaders;
+/**
+ * Horizontal header discovery shared by `HeaderStrategies.horizontalScroll` and the Glide preset:
+ * reset the scroller to the left, step right collecting headers until two consecutive steps add
+ * nothing (or `limit` is hit), then scroll back. Callers differ only in how they find the scroller.
+ */
+async function scrollAndCollectHeaders(context, findScroller, options) {
+    var _a, _b;
+    const { config, page } = context;
+    const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 20;
+    const scrollAmount = (_b = options.scrollAmount) !== null && _b !== void 0 ? _b : 300;
+    const collectedHeaders = new Set(await (0, exports.readVisibleHeaders)(context));
+    const scrollerHandle = await findScroller();
+    const isScrollerFound = await scrollerHandle.evaluate(el => !!el);
+    if (!isScrollerFound) {
+        (0, debugUtils_1.logDebug)(config, 'info', options.notFoundMessage);
+        return Array.from(collectedHeaders);
+    }
+    const collectAfterStep = async () => {
+        await scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+        await page.waitForTimeout(300);
+        (await (0, exports.readVisibleHeaders)(context)).forEach(h => collectedHeaders.add(h));
+    };
+    await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+    await page.waitForTimeout(200);
+    for (let i = 0; i < limit; i++) {
+        const sizeBefore = collectedHeaders.size;
+        await collectAfterStep();
+        if (collectedHeaders.size === sizeBefore) {
+            await collectAfterStep();
+            if (collectedHeaders.size === sizeBefore)
+                break;
+        }
+    }
+    await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+    await page.waitForTimeout(200);
+    return Array.from(collectedHeaders);
+}

package/dist/utils/loadingWait.js

@@ -12,7 +12,8 @@ const debugUtils_1 = require("./debugUtils");
  * 3. 10_000 ms default
  */
 async function waitWhileTableLoading(config, context, page, label, options) {
-    var _a, _b, _c, _d, _e;
+    var _a;
+    var _b, _c, _d, _e;
     const isTableLoading = (_a = config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isTableLoading;
     if (!isTableLoading)
         return;

package/dist/utils/mergeTableConfig.js

@@ -22,7 +22,8 @@ exports.mergeTableConfig = mergeTableConfig;
  * });
  */
 function mergeTableConfig(base, overrides) {
-    var _a, _b, _c, _d;
+    var _a, _b;
+    var _c, _d;
     const result = Object.assign(Object.assign({}, base), overrides);
     // Deep-merge strategies one level down
     if (base.strategies || overrides.strategies) {
@@ -31,12 +32,12 @@ function mergeTableConfig(base, overrides) {
         // so that e.g. base.strategies.loading and overrides.strategies.loading are combined.
         // Function values (pagination, header, dedupe, getCellLocator, etc.) are replaced, not merged.
         const strategyKeys = new Set([
-            ...Object.keys((_a = base.strategies) !== null && _a !== void 0 ? _a : {}),
-            ...Object.keys((_b = overrides.strategies) !== null && _b !== void 0 ? _b : {}),
+            ...Object.keys((_c = base.strategies) !== null && _c !== void 0 ? _c : {}),
+            ...Object.keys((_d = overrides.strategies) !== null && _d !== void 0 ? _d : {}),
         ]);
         for (const key of strategyKeys) {
-            const baseVal = (_c = base.strategies) === null || _c === void 0 ? void 0 : _c[key];
-            const overrideVal = (_d = overrides.strategies) === null || _d === void 0 ? void 0 : _d[key];
+            const baseVal = (_a = base.strategies) === null || _a === void 0 ? void 0 : _a[key];
+            const overrideVal = (_b = overrides.strategies) === null || _b === void 0 ? void 0 : _b[key];
             if (baseVal !== undefined &&
                 overrideVal !== undefined &&
                 typeof baseVal === 'object' &&

package/dist/utils/navigationBarrier.d.ts

@@ -4,8 +4,6 @@ export declare class NavigationBarrier {
     private buckets;
     private recoveryMutex;
     constructor(total: number);
-    /** True when more than one row shares this barrier (scrollToRow would evict peers). */
-    isParallel(): boolean;
     /**
      * Synchronize all active rows at a specific column index.
      * The last row to arrive (or the last markFinished call) triggers the `moveAction`.

package/dist/utils/navigationBarrier.js

@@ -9,10 +9,6 @@ class NavigationBarrier {
         this.recoveryMutex = null;
         this.total = total;
     }
-    /** True when more than one row shares this barrier (scrollToRow would evict peers). */
-    isParallel() {
-        return this.total > 1;
-    }
     /**
      * Synchronize all active rows at a specific column index.
      * The last row to arrive (or the last markFinished call) triggers the `moveAction`.
@@ -55,6 +51,7 @@ class NavigationBarrier {
      * The fn receives a fresh `targetReached` check; if the previous row's scroll
      * already brought this row into view, fn can no-op immediately.
      */
+    // fallow-ignore-next-line unused-class-member
     async runExclusiveRecovery(fn) {
         if (!this.recoveryMutex)
             this.recoveryMutex = new mutex_1.Mutex();

package/dist/utils/resolveCellLocator.js

@@ -7,10 +7,11 @@ exports.resolveCellLocatorForFilter = resolveCellLocatorForFilter;
  * otherwise `cellSelector` + `.nth(columnIndex)`.
  */
 function resolveCellLocator(args) {
-    var _a, _b;
+    var _a;
+    var _b;
     const { config, resolve, row, root, columnName, columnIndex, rowIndex } = args;
-    const page = (_a = args.page) !== null && _a !== void 0 ? _a : root.page();
-    if ((_b = config.strategies) === null || _b === void 0 ? void 0 : _b.getCellLocator) {
+    const page = (_b = args.page) !== null && _b !== void 0 ? _b : root.page();
+    if ((_a = config.strategies) === null || _a === void 0 ? void 0 : _a.getCellLocator) {
         return config.strategies.getCellLocator({
             row,
             root,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.23.1",
+  "version": "6.24.0-next.82106e1",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -18,7 +18,6 @@
     "dist"
   ],
   "scripts": {
-    "generate-types": "node scripts/embed-types.mjs",
     "generate-config-types": "node scripts/embed-config-types.mjs",
     "generate-docs": "node scripts/generate-readme.mjs",
     "generate-all-api-docs": "node scripts/generate-all-api-docs.mjs",
@@ -29,7 +28,7 @@
     "docs:verify-links": "node scripts/verify-vitepress-links.mjs",
     "embed-version": "node scripts/embed-version.mjs",
     "generate-og": "node scripts/generate-og.mjs",
-    "build": "pnpm run embed-version && pnpm run generate-types && pnpm run generate-config-types && pnpm run generate-docs && pnpm run generate-all-api-docs && pnpm run update-all-api-signatures && tsc && node scripts/check-no-runtime-playwright.mjs",
+    "build": "pnpm run embed-version && pnpm run generate-config-types && pnpm run generate-docs && pnpm run generate-all-api-docs && pnpm run update-all-api-signatures && tsc && node scripts/check-no-runtime-playwright.mjs",
     "prepublishOnly": "pnpm run build",
     "clean-port": "lsof -ti:3000 | xargs kill -9 || true",
     "pretest": "pnpm run clean-port",
@@ -38,6 +37,7 @@
     "test:unit": "vitest run --coverage --reporter=verbose --reporter=html",
     "test:unit:ui": "vitest --ui",
     "test:mutate": "pnpm exec stryker run",
+    "fallow": "fallow dead-code",
     "pretest:e2e": "pnpm run clean-port",
     "posttest:e2e": "pnpm run clean-port",
     "test:e2e": "pnpm exec playwright test",
@@ -53,9 +53,7 @@
     },
     "./types": {
       "types": "./dist/types.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "default": "./dist/index.js"
+      "default": "./dist/types.js"
     },
     "./presets": {
       "types": "./dist/presets/index.d.ts",
@@ -121,12 +119,13 @@
     "@playwright/test": "^1.59.1",
     "@stryker-mutator/core": "^9.6.0",
     "@stryker-mutator/vitest-runner": "^9.6.0",
-    "@types/node": "^25.5.2",
+    "@types/node": "^26.6.2",
     "@vitest/coverage-v8": "^3.2.6",
     "@vitest/ui": "^3.2.6",
+    "fallow": "3.31.0",
     "happy-dom": "^20.10.6",
     "husky": "^9.1.7",
-    "typescript": "^6.0.2",
+    "typescript": "^7.0.2",
     "vitepress": "^1.6.4",
     "vitepress-plugin-tabs": "^0.9.0",
     "vitest": "^3.2.6"