@rickcedwhat/playwright-smart-table 6.16.0 → 6.17.1

package/dist/utils/navigationBarrier.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NavigationBarrier = void 0;
-/**
- * A synchronization barrier that allows multiple parallel row processors
- * to coordinate their navigation actions.
- */
+const mutex_1 = require("./mutex");
 class NavigationBarrier {
     constructor(total) {
         this.finishedCount = 0;
-        // Map of colIndex -> Set of waiting resolvers
         this.buckets = new Map();
+        this.recoveryMutex = null;
         this.total = total;
     }
     /** True when more than one row shares this barrier (scrollToRow would evict peers). */
@@ -18,7 +15,7 @@ class NavigationBarrier {
     }
     /**
      * Synchronize all active rows at a specific column index.
-     * The last row to arrive will trigger the `moveAction`.
+     * The last row to arrive (or the last markFinished call) triggers the `moveAction`.
      */
     async sync(colIndex, moveAction) {
         if (this.total <= 1) {
@@ -26,50 +23,82 @@ class NavigationBarrier {
                 return await moveAction();
             return;
         }
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             let bucket = this.buckets.get(colIndex);
             if (!bucket) {
                 bucket = new Set();
                 this.buckets.set(colIndex, bucket);
             }
-            bucket.add(resolve);
+            bucket.add({ resolve, reject, moveAction });
             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);
-                    }
-                })();
+                this.triggerBucket(colIndex);
             }
         });
     }
     /**
      * Mark a row as finished (no more cells to process).
-     * This ensures the barrier doesn't wait for rows that have exited the loop.
+     * This ensures the barrier doesn't wait for rows that have exited the loop,
+     * and runs the pending move action so waiting peers are not starved.
      */
     markFinished() {
         this.finishedCount++;
-        // Check all buckets - any bucket that was waiting for this row might now be ready
         for (const colIndex of Array.from(this.buckets.keys())) {
             const bucket = this.buckets.get(colIndex);
             if (bucket.size + this.finishedCount >= this.total) {
-                this.broadcast(colIndex);
+                this.triggerBucket(colIndex);
             }
         }
     }
-    broadcast(colIndex, result) {
+    /**
+     * Run a recovery action exclusively — serialized so concurrent rows don't race
+     * on scrollTop after a horizontal scroll evicts rows from the vertical viewport.
+     * The fn receives a fresh `targetReached` check; if the previous row's scroll
+     * already brought this row into view, fn can no-op immediately.
+     */
+    async runExclusiveRecovery(fn) {
+        if (!this.recoveryMutex)
+            this.recoveryMutex = new mutex_1.Mutex();
+        return this.recoveryMutex.run(fn);
+    }
+    /**
+     * Detach the bucket for `colIndex`, run the first available moveAction,
+     * then resolve or reject all captured waiters.
+     *
+     * Detaching before the await prevents a concurrent markFinished() from
+     * broadcasting the same bucket a second time while the action is in-flight.
+     */
+    triggerBucket(colIndex) {
         const bucket = this.buckets.get(colIndex);
-        if (bucket) {
-            for (const resolve of bucket) {
-                resolve(result);
+        if (!bucket)
+            return;
+        const waiters = Array.from(bucket);
+        this.buckets.delete(colIndex);
+        (async () => {
+            var _a;
+            let result;
+            let err;
+            try {
+                // Find the first waiter that supplied a moveAction — the last arrival may be
+                // a no-op (fast-path) row with no action, but an earlier waiter's action must
+                // still run, otherwise the column scroll is silently skipped.
+                const action = (_a = waiters.find(w => w.moveAction)) === null || _a === void 0 ? void 0 : _a.moveAction;
+                if (action)
+                    result = await action();
             }
-            this.buckets.delete(colIndex);
-        }
+            catch (e) {
+                err = e;
+            }
+            finally {
+                if (err !== undefined) {
+                    for (const { reject } of waiters)
+                        reject(err);
+                }
+                else {
+                    for (const { resolve } of waiters)
+                        resolve(result);
+                }
+            }
+        })();
     }
 }
 exports.NavigationBarrier = NavigationBarrier;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.16.0",
+  "version": "6.17.1",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",