@rickcedwhat/playwright-smart-table 6.24.0 → 6.25.0-next.1e71a54

package/dist/engine/scanPages.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanPages = scanPages;
 const debugUtils_1 = require("../utils/debugUtils");
+function throwIfAborted(env, label, signal) {
+    if (!(signal === null || signal === void 0 ? void 0 : signal.aborted))
+        return;
+    (0, debugUtils_1.logDebug)(env.config, 'info', `${label}: aborted via AbortSignal at page ${env.getCurrentPageIndex()}`);
+    throw signal.reason;
+}
 async function scanPages(env, onPage, options) {
     var _a, _b;
     const maxPages = options.maxPages;
@@ -12,14 +18,17 @@ async function scanPages(env, onPage, options) {
     let reachedEnd = false;
     (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: starting (maxPages=${maxPages}, useBulk=${useBulk}, finalScanOnEof=${finalScanOnEof})`);
     while (true) {
+        throwIfAborted(env, label, options.signal);
         if (env.waitForReady) {
             await env.waitForReady();
+            throwIfAborted(env, label, options.signal);
         }
         const decision = await onPage({
             pagesScanned,
             pageIndex: env.getCurrentPageIndex(),
             isFinalScan: reachedEnd,
         });
+        throwIfAborted(env, label, options.signal);
         if (decision === 'stop') {
             (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: onPage returned stop at page ${env.getCurrentPageIndex()}`);
             break;
@@ -27,8 +36,10 @@ async function scanPages(env, onPage, options) {
         if (pagesScanned >= maxPages || reachedEnd) {
             break;
         }
+        throwIfAborted(env, label, options.signal);
         const prevPage = env.getCurrentPageIndex();
         const didAdvance = await env.advancePage(useBulk);
+        throwIfAborted(env, label, options.signal);
         if (!didAdvance) {
             if (finalScanOnEof) {
                 (0, debugUtils_1.logDebug)(env.config, 'verbose', `${label}: pagination returned false — final scan`);

package/dist/engine/sorting.d.ts

@@ -0,0 +1,11 @@
+import type { Page } from '@playwright/test';
+import type { FinalTableConfig, StrategyContext } from '../types';
+export interface SortingEnv<T = any> {
+    config: FinalTableConfig<T>;
+    getPage: () => Page;
+    /** Strategy context including `getHeaderCell`. */
+    getContext: () => StrategyContext;
+}
+/** Drives the sorting strategy until `columnName` reports `direction`, retrying up to 3 times. */
+export declare function applySort<T>(env: SortingEnv<T>, columnName: string, direction: 'asc' | 'desc'): Promise<void>;
+export declare function getSortState<T>(env: SortingEnv<T>, columnName: string): Promise<'asc' | 'desc' | 'none'>;

package/dist/engine/sorting.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySort = applySort;
+exports.getSortState = getSortState;
+const debugUtils_1 = require("../utils/debugUtils");
+const loadingWait_1 = require("../utils/loadingWait");
+const MAX_SORT_ATTEMPTS = 3;
+function requireSorting(config) {
+    if (!config.strategies.sorting)
+        throw new Error('No sorting strategy has been configured.');
+    return config.strategies.sorting;
+}
+/** Waits for the table to settle after `doSort`: `isTableLoading` when configured, otherwise a fixed delay. */
+async function waitForSortToSettle(env, context) {
+    var _a, _b, _c, _d;
+    const loading = env.config.strategies.loading;
+    if (loading === null || loading === void 0 ? void 0 : loading.isTableLoading) {
+        const timeout = (_b = (_a = loading.sortStabilizationTimeout) !== null && _a !== void 0 ? _a : loading.loadingTimeout) !== null && _b !== void 0 ? _b : 10000;
+        const pollInterval = (_c = loading.sortStabilizationPollInterval) !== null && _c !== void 0 ? _c : 100;
+        await (0, loadingWait_1.waitWhileTableLoading)(env.config, context, env.getPage(), 'sorting.apply', { timeout, pollInterval });
+    }
+    else {
+        await env.getPage().waitForTimeout((_d = loading === null || loading === void 0 ? void 0 : loading.sortStabilizationFallbackDelay) !== null && _d !== void 0 ? _d : 200);
+    }
+}
+/** Drives the sorting strategy until `columnName` reports `direction`, retrying up to 3 times. */
+async function applySort(env, columnName, direction) {
+    const sorting = requireSorting(env.config);
+    (0, debugUtils_1.logDebug)(env.config, 'verbose', `Applying sort for column "${columnName}" (${direction})`);
+    const context = env.getContext();
+    for (let i = 0; i < MAX_SORT_ATTEMPTS; i++) {
+        const currentState = await sorting.getSortState({ columnName, context });
+        if (currentState === direction) {
+            (0, debugUtils_1.logDebug)(env.config, 'verbose', `Sort for "${columnName}" is already "${direction}".`);
+            return;
+        }
+        await sorting.doSort({ columnName, direction, context });
+        await waitForSortToSettle(env, context);
+        await (0, debugUtils_1.debugDelay)(env.config, 'default');
+        const newState = await sorting.getSortState({ columnName, context });
+        if (newState === direction) {
+            (0, debugUtils_1.logDebug)(env.config, 'verbose', `Successfully sorted "${columnName}" to "${direction}".`);
+            return;
+        }
+    }
+    throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${MAX_SORT_ATTEMPTS} attempts.`);
+}
+async function getSortState(env, columnName) {
+    const sorting = requireSorting(env.config);
+    return sorting.getSortState({ columnName, context: env.getContext() });
+}

package/dist/engine/tableIteration.js

@@ -45,8 +45,9 @@ async function runMap(env, callback, options = {}, label = 'map') {
         let rowIndex = 0;
         let stopped = false;
         let stoppedIndex = Infinity;
+        // In parallel/synchronized mode rows can call stop() out of order; the earliest row wins.
         const stop = (idx) => {
-            if (!stopped) {
+            if (idx < stoppedIndex) {
                 log(env.config, `${label}: stop() called at row ${idx} — halting`);
                 stopped = true;
                 stoppedIndex = idx;
@@ -195,6 +196,7 @@ async function runMap(env, callback, options = {}, label = 'map') {
             useBulk,
             label,
             finalScanOnEof: true,
+            signal: options.signal,
         });
         log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
     }

package/dist/engine/tableMapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableMapper = void 0;
 const headers_1 = require("../strategies/headers");
 const debugUtils_1 = require("../utils/debugUtils");
+const deadline_1 = require("../utils/deadline");
 class TableMapper {
     constructor(rootLocator, config, resolve) {
         this._headerMap = null;
@@ -21,9 +22,11 @@ class TableMapper {
         this.log('Mapping headers...');
         const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
         const startTime = Date.now();
+        const deadline = startTime + headerTimeout;
+        const remaining = () => Math.max(0, deadline - Date.now());
         if (this.config.autoScroll) {
             try {
-                await this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
+                await (0, deadline_1.withinDeadline)(() => this.rootLocator.scrollIntoViewIfNeeded({ timeout: Math.max(1, Math.min(1000, remaining())) }), deadline, undefined);
             }
             catch (e) { }
         }
@@ -39,22 +42,29 @@ class TableMapper {
         while (Date.now() - startTime < headerTimeout) {
             // 1. Wait for visibility
             try {
-                await headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
+                await (0, deadline_1.withinDeadline)(() => headerLoc.first().waitFor({ state: 'visible', timeout: Math.max(1, Math.min(200, remaining())) }), deadline, undefined);
             }
             catch (e) {
                 // Continue to check existing/loading state even if not strictly "visible" yet
             }
+            if (remaining() <= 0)
+                break;
             // 2. Check Smart Loading State
             if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
-                const isStable = !(await this.config.strategies.loading.isHeaderLoading(context));
+                const isStable = !(await (0, deadline_1.withinDeadline)(() => this.config.strategies.loading.isHeaderLoading(context), deadline, true));
                 if (!isStable) {
                     this.log('Headers are loading/unstable... waiting');
-                    await new Promise(r => setTimeout(r, 100));
+                    if (remaining() > 0)
+                        await new Promise(r => setTimeout(r, Math.min(100, remaining())));
                     continue;
                 }
             }
             // 3. Attempt Scan
+            if (remaining() <= 0)
+                break;
             try {
+                // Preserve long-running discovery strategies (e.g. horizontal header scans).
+                // The deadline bounds readiness and retries, not a strategy's own operation.
                 const rawHeaders = await strategy(context);
                 const entries = await this.processHeaders(rawHeaders);
                 // Success — validate before caching so a collision doesn't leave stale state
@@ -72,7 +82,8 @@ class TableMapper {
             catch (e) {
                 lastError = e;
                 this.log(`Header mapping failed. Attempt ${Math.floor((Date.now() - startTime) / 100)}: ${e.message}`);
-                await new Promise(r => setTimeout(r, 100));
+                if (remaining() > 0)
+                    await new Promise(r => setTimeout(r, Math.min(100, remaining())));
             }
         }
         throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);

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, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
+export type { TableConfig, TableResult, SmartRow, SmartCell, Selector, TableSelector, FilterValue, PaginationPrimitives, SortingStrategy, FillOptions, RowIterationContext, RowIterationOptions, TableContext, StrategyContext, BeforeCellReadFn, GetCellLocatorFn, GetActiveCellFn, DebugConfig, SyntheticColumnDef, ColumnOverride, ColumnOverrideReadContext, TableStrategies, LoadingStrategy, ViewportStrategy, FilterStrategy, NavigationPrimitives, DedupeStrategy, ContentReadyStrategy, RowReadyPredicate, FillStrategy, PaginationStrategy, HeaderStrategy, } from './types';
 export { Strategies } from './strategies';
 export * as presets from './presets';
 /**

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.24.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.1e71a54";

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.24.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.1e71a54";

package/dist/presets/glide/index.js

@@ -102,7 +102,6 @@ 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.

package/dist/presets/rdg.js

@@ -99,7 +99,6 @@ const RDGDefaultStrategies = {
     pagination: rdgPaginationStrategy
 };
 /** Full strategies for React Data Grid. Use when you want to supply your own selectors: `strategies: presets.rdg.Strategies` */
-// fallow-ignore-next-line unused-export
 exports.RDGStrategies = RDGDefaultStrategies;
 /**
  * Full preset for React Data Grid (selectors + default strategies).
@@ -174,7 +173,6 @@ const rdg2DViewportStrategy = {
 };
 /** Default strategies for the RDG2D preset (extends RDG with viewport recovery). */
 const RDG2DDefaultStrategies = Object.assign(Object.assign({}, RDGDefaultStrategies), { viewport: rdg2DViewportStrategy });
-// fallow-ignore-next-line unused-export
 exports.RDG2DStrategies = RDG2DDefaultStrategies;
 /**
  * Full preset for React Data Grid with 2D virtualization (rows + columns both virtualized).