@iblai/web-utils 1.11.5 → 1.11.6

package/dist/index.js

@@ -9395,6 +9395,14 @@ async function validateJwtToken(storageService) {
         return false;
     }
 }
+/**
+ * How long (ms) a redirect may be "in progress" before we assume the
+ * navigation failed and allow a fresh attempt. Must be longer than the 3s
+ * safety timer in `safeRedirectToAuthSpa` so the two don't fight; this is
+ * the backstop for when that timer is lost because the page began
+ * unloading and then survived (bfcache restore, aborted navigation).
+ */
+const REDIRECT_STUCK_MS = 5000;
 function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure, redirectToAuthSpa, username, pathname, storageService, skipAuthCheck, token, enableStorageSync = true, }) {
     const [isAuthenticating, setIsAuthenticating] = React.useState(true);
     const [userIsAccessingPublicRoute, setUserIsAccessingPublicRoute] = React.useState(false);
@@ -9402,21 +9410,51 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
     const cookieCheckIntervalRef = React.useRef(null);
     const lastLogoutTimestampRef = React.useRef(null);
     const lastLoginTimestampRef = React.useRef(null);
-    // Guard to prevent poll from firing after a redirect has been initiated.
-    // Once set, no further redirects or cookie syncs will happen.
+    // Guard to prevent the poll from firing redundant redirects while a
+    // navigation to the auth SPA is already underway.
     const isRedirectingRef = React.useRef(false);
+    // Wall-clock time (ms) at which the in-progress redirect was started.
+    // Used to self-heal a stuck guard: the browser discards our 3s safety
+    // timer the instant navigation begins, so if navigation never actually
+    // completes (page restored from bfcache, redirect aborted/slow, timers
+    // throttled during unload) the boolean alone would latch ON forever and
+    // suppress every future redirect. This timestamp lets the poll detect
+    // that case and reset the guard. See `redirectInProgress`.
+    const redirectStartedAtRef = React.useRef(0);
     // RTK Query hook for refreshing JWT token
     const [refreshJwtToken] = dataLayer.useLazyRefreshJwtTokenQuery();
     /**
-     * Wrapper around redirectToAuthSpa that stops polling immediately
-     * and prevents any further redirect calls from racing.
+     * Whether a redirect is genuinely still in progress.
+     *
+     * Returns false (and resets the guard) when the redirect was started more
+     * than REDIRECT_STUCK_MS ago, since at that point the page is clearly
+     * still alive and the navigation must have failed. This is what lets the
+     * app recover on its own instead of latching the guard ON forever and
+     * needing a manual cookie clear / hard reload.
+     */
+    const redirectInProgress = () => {
+        if (!isRedirectingRef.current)
+            return false;
+        const elapsed = Date.now() - redirectStartedAtRef.current;
+        if (elapsed > REDIRECT_STUCK_MS) {
+            console.log("[AuthProvider] redirect guard stuck for", elapsed, "ms — navigation never completed, resetting so we can retry");
+            isRedirectingRef.current = false;
+            redirectStartedAtRef.current = 0;
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Wrapper around redirectToAuthSpa that prevents redundant redirect calls
+     * from racing while a navigation is already underway.
      */
     const safeRedirectToAuthSpa = (...args) => {
-        if (isRedirectingRef.current) {
+        if (redirectInProgress()) {
             console.log("[AuthProvider] Redirect already in progress, skipping");
             return;
         }
         isRedirectingRef.current = true;
+        redirectStartedAtRef.current = Date.now();
         // NOTE: we intentionally do NOT clear the interval here.
         // The isRedirectingRef guard prevents redundant redirects while navigation
         // is in progress. Clearing the interval preemptively can permanently stop
@@ -9431,6 +9469,7 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
             if (isRedirectingRef.current) {
                 console.log("[AuthProvider] safeRedirectToAuthSpa: navigation did not occur, resetting redirect guard");
                 isRedirectingRef.current = false;
+                redirectStartedAtRef.current = 0;
             }
         }, 3000);
     };
@@ -9457,6 +9496,7 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         }
         // Reset redirect guard on effect setup (new mount / dep change)
         isRedirectingRef.current = false;
+        redirectStartedAtRef.current = 0;
         // Initial sync on mount
         async function initialSync() {
             console.log("[AuthProvider] initialSync starting");
@@ -9487,8 +9527,11 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         initialSync();
         // Poll for cookie changes every 2 seconds to detect cross-SPA updates
         cookieCheckIntervalRef.current = setInterval(async () => {
-            // If a redirect is already in progress, skip entirely
-            if (isRedirectingRef.current) {
+            // If a redirect is genuinely still in progress, skip entirely.
+            // redirectInProgress() self-heals a guard that got stuck because a
+            // navigation was initiated but the page survived (bfcache, aborted
+            // redirect), so this no longer latches ON forever.
+            if (redirectInProgress()) {
                 console.log("[AuthProvider] interval: redirect already in progress, skipping");
                 return;
             }
@@ -9561,6 +9604,27 @@ function useAuthProvider({ middleware = new Map(), onAuthSuccess, onAuthFailure,
         window.addEventListener("storage", handleStorageChange);
         return () => window.removeEventListener("storage", handleStorageChange);
     }, [storageService, enableStorageSync]);
+    /**
+     * Reset the redirect guard when the page is restored from the back/forward
+     * cache (web only). When a redirect calls window.location.href the browser
+     * may freeze and bfcache the page rather than destroy it; navigating back
+     * then restores it with isRedirectingRef still latched ON and the 3s safety
+     * timer discarded. Clearing the guard here lets redirects fire again
+     * without a manual cookie clear / hard reload.
+     */
+    React.useEffect(() => {
+        if (!isWeb$1() || skipAuthCheck)
+            return;
+        const handlePageShow = (event) => {
+            if (event.persisted) {
+                console.log("[AuthProvider] pageshow from bfcache — resetting redirect guard");
+                isRedirectingRef.current = false;
+                redirectStartedAtRef.current = 0;
+            }
+        };
+        window.addEventListener("pageshow", handlePageShow);
+        return () => window.removeEventListener("pageshow", handlePageShow);
+    }, [skipAuthCheck]);
     /**
      * Performs the authentication check by:
      * 1. Validating the auth token