antaeus.keycloak.react 2.4.0 → 2.5.0

package/dist/index.mjs

@@ -149,6 +149,14 @@ var useAuth = useAuth$1;
 
 // src/hooks/useTokenLifecycle.ts
 var STORAGE_KEY_PREFIX = "keycloak_first_login_";
+var isNavigatorOffline = () => typeof navigator !== "undefined" && "onLine" in navigator && navigator.onLine === false;
+var isTransientNetworkError = (error) => {
+  const message = error.message?.toLowerCase?.() ?? "";
+  if (!message) {
+    return false;
+  }
+  return message.includes("network") || message.includes("failed to fetch") || message.includes("fetch") || message.includes("timeout") || message.includes("temporarily unavailable") || message.includes("dns") || message.includes("offline");
+};
 function useTokenLifecycle(options) {
   const {
     config,
@@ -163,6 +171,11 @@ function useTokenLifecycle(options) {
   const [isRefreshTokenExpired, setIsRefreshTokenExpired] = useState(false);
   const hasCheckedOnStartup = useRef(false);
   const supportsRefreshTokens = config.silentRenew?.useRefreshToken !== false;
+  const [pendingRetry, setPendingRetry] = useState(null);
+  const deferredRefreshReasonRef = useRef(null);
+  const enqueueRetry = useCallback((reason) => {
+    setPendingRetry((current) => current === reason ? current : reason);
+  }, []);
   const log = useCallback(
     (message, ...args) => {
       if (debug) {
@@ -213,6 +226,7 @@ function useTokenLifecycle(options) {
       return;
     }
     setIsRefreshing(true);
+    deferredRefreshReasonRef.current = null;
     try {
       if (checkRefreshTokenLifetime()) {
         log("Refresh token exceeded max lifetime, cannot refresh");
@@ -220,6 +234,12 @@ function useTokenLifecycle(options) {
         onRefreshTokenExpired?.();
         return;
       }
+      if (isNavigatorOffline()) {
+        log("Device offline, deferring token refresh until connection is restored");
+        deferredRefreshReasonRef.current = "offline";
+        enqueueRetry("offline");
+        return;
+      }
       onRefreshStart?.();
       log("Starting token refresh");
       await auth.signinSilent();
@@ -227,6 +247,21 @@ function useTokenLifecycle(options) {
       onRefreshSuccess?.();
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
+      if (isTransientNetworkError(err)) {
+        const reason = isNavigatorOffline() ? "offline" : "network";
+        deferredRefreshReasonRef.current = reason;
+        if (reason === "offline") {
+          log("Token refresh deferred because device is offline");
+        } else {
+          log(
+            "Token refresh failed due to transient network issue, will retry automatically:",
+            err.message
+          );
+        }
+        enqueueRetry(reason);
+        onRefreshError?.(err);
+        return;
+      }
       log("Token refresh failed:", err.message);
       onRefreshError?.(err);
       throw err;
@@ -241,6 +276,7 @@ function useTokenLifecycle(options) {
     onRefreshSuccess,
     onRefreshError,
     onRefreshTokenExpired,
+    enqueueRetry,
     log
   ]);
   const checkAndRefreshTokens = useCallback(async () => {
@@ -279,6 +315,14 @@ function useTokenLifecycle(options) {
     if (timeUntilExpiry <= threshold) {
       try {
         await refreshToken();
+        if (deferredRefreshReasonRef.current) {
+          log(
+            "Token refresh was deferred due to pending retry:",
+            deferredRefreshReasonRef.current
+          );
+          deferredRefreshReasonRef.current = null;
+          return false;
+        }
         return true;
       } catch (error) {
         log("Failed to refresh tokens:", error);
@@ -296,6 +340,55 @@ function useTokenLifecycle(options) {
     getStorageKey,
     log
   ]);
+  useEffect(() => {
+    if (pendingRetry === null) {
+      return;
+    }
+    if (typeof window === "undefined") {
+      return;
+    }
+    let cancelled = false;
+    const executeRetry = () => {
+      if (cancelled) {
+        return;
+      }
+      if (isRefreshing) {
+        log("Skipping scheduled token refresh retry because a refresh is already in progress");
+        return;
+      }
+      refreshToken().catch((err) => {
+        log("Scheduled token refresh retry failed:", err);
+      });
+    };
+    if (pendingRetry === "offline") {
+      log("Waiting for online event to retry token refresh");
+      const handleOnline = () => {
+        if (cancelled) {
+          return;
+        }
+        log("Online event detected, retrying deferred token refresh");
+        setPendingRetry(null);
+        executeRetry();
+      };
+      window.addEventListener("online", handleOnline, { once: true });
+      return () => {
+        cancelled = true;
+        window.removeEventListener("online", handleOnline);
+      };
+    }
+    const timeoutId = window.setTimeout(() => {
+      if (cancelled) {
+        return;
+      }
+      log("Retrying token refresh after transient network failure delay");
+      setPendingRetry(null);
+      executeRetry();
+    }, 5e3);
+    return () => {
+      cancelled = true;
+      window.clearTimeout(timeoutId);
+    };
+  }, [pendingRetry, refreshToken, isRefreshing, log]);
   useEffect(() => {
     const strategy = config.silentRenew?.refreshStrategy || "both";
     const shouldCheckOnStartup = strategy === "startup" || strategy === "both";