@koenvanbelle/cypress-soft-assertions 2.4.3 → 2.4.4

package/dist/index.js

@@ -81,7 +81,13 @@ function patchChaiAssertions() {
     assertionProto.assert = patchedAssertionAssert;
 }
 function resolveStableToken(assertionContext, args) {
-    return (0, utils_1.resolveToken)((0, utils_1.getAssertionToken)(assertionContext, args), getRetryableCommandId(), args);
+    const assertionToken = (0, utils_1.getAssertionToken)(assertionContext, args);
+    if (assertionToken)
+        return assertionToken;
+    const commandId = getRetryableCommandId();
+    if (commandId)
+        return (0, utils_1.resolveToken)('', commandId, args);
+    return '';
 }
 function isRunningHookContext() {
     var _a;
@@ -95,23 +101,24 @@ function isRunningHookContext() {
     }
 }
 function patchedAssertionAssert(...args) {
+    var _a;
     if (!originalChaiAssert)
         return;
+    // Fast path for non-soft tests: avoid try/catch and token logic entirely.
+    if (!isInSoftTest) {
+        return originalChaiAssert.apply(this, args);
+    }
     try {
         const result = originalChaiAssert.apply(this, args);
         // Assertion passed — clear any staged failure for this token.
-        if (isInSoftTest) {
-            const token = resolveStableToken(this, args);
-            if (token) {
-                retryAssertionFailures.delete(token);
-                retryFirstSeen.delete(token);
-            }
+        const token = resolveStableToken(this, args);
+        if (token) {
+            retryAssertionFailures.delete(token);
+            retryFirstSeen.delete(token);
         }
         return result;
     }
     catch (error) {
-        if (!isInSoftTest)
-            throw error;
         if (isRunningHookContext())
             throw error;
         const errorEntry = {
@@ -120,22 +127,30 @@ function patchedAssertionAssert(...args) {
         };
         const token = resolveStableToken(this, args);
         if (token) {
-            // Track when we first saw this failure.
-            if (!retryFirstSeen.has(token)) {
-                retryFirstSeen.set(token, Date.now());
-            }
             // Stage the failure so it can be cleared if a later retry succeeds.
             retryAssertionFailures.set(token, errorEntry);
-            // Check if the retry window has expired. Swallow slightly before
-            // Cypress's own timeout to prevent it from firing the fail event.
-            // Cypress retries every ~50ms, so subtracting 100ms ensures we
-            // catch at least 1-2 more retries before the deadline.
-            const elapsed = Date.now() - retryFirstSeen.get(token);
+            const current = cy.state('current');
+            const wallClockStartedAt = (_a = current === null || current === void 0 ? void 0 : current.get) === null || _a === void 0 ? void 0 : _a.call(current, 'wallClockStartedAt');
             const timeout = getEffectiveTimeout();
-            const swallowAt = Math.max(timeout - 100, timeout * 0.9);
-            if (elapsed < swallowAt) {
-                // Still within the retry window — rethrow so Cypress retries.
-                throw error;
+            if (typeof wallClockStartedAt === 'number') {
+                const totalElapsed = Date.now() - wallClockStartedAt;
+                // Swallow only when very close to the actual command timeout.
+                // A 20ms buffer maximizes retry attempts while still preventing
+                // Cypress's global fail handler from aborting the test queue.
+                if (totalElapsed < timeout - 20) {
+                    throw error;
+                }
+            }
+            else {
+                // Fallback for cases where wallClockStartedAt is missing.
+                if (!retryFirstSeen.has(token)) {
+                    retryFirstSeen.set(token, Date.now());
+                }
+                const elapsed = Date.now() - retryFirstSeen.get(token);
+                const swallowAt = Math.max(timeout - 100, timeout * 0.9);
+                if (elapsed < swallowAt) {
+                    throw error;
+                }
             }
             // Retry window expired. Swallow the error: Cypress considers the
             // assertion "passed", the command resolves, and the queue continues.

package/dist/utils.js

@@ -84,10 +84,11 @@ function appendUniqueError(errors, message, stack) {
  */
 function mergeRetryFailures(softErrors, retryFailures) {
     const result = [...softErrors];
+    const seenMessages = new Set(result.map(e => e.message));
     for (const entry of retryFailures.values()) {
-        const isDuplicate = result.some(e => e.message === entry.message);
-        if (!isDuplicate) {
+        if (!seenMessages.has(entry.message)) {
             result.push(entry);
+            seenMessages.add(entry.message);
         }
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koenvanbelle/cypress-soft-assertions",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "A Cypress plugin that provides soft_it() for soft assertions - all assertions continue on failure and are reported together",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",