@rickcedwhat/playwright-smart-table 6.25.0-next.c784f2c → 6.25.0-next.d8860d0

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

@@ -196,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.25.0-next.c784f2c";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.25.0-next.d8860d0";

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.25.0-next.c784f2c";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.25.0-next.d8860d0";