antaeus.keycloak.react 1.0.6 → 2.0.0

package/dist/index.js

@@ -23,8 +23,14 @@ var defaultConfig = {
   silentRenew: {
     enabled: true,
     silentRedirectUri: typeof window !== "undefined" ? window.location.origin + "/silent-renew.html" : "/silent-renew.html",
-    thresholdSeconds: 300
+    thresholdSeconds: 300,
     // 5 minutes
+    refreshStrategy: "both",
+    // Check on startup AND retry on 401
+    maxRefreshTokenLifetime: 2592e3,
+    // 30 days in seconds
+    showLoadingIndicator: false,
+    loadingMessage: "Refreshing session..."
   },
   advanced: {
     responseType: "code",
@@ -128,16 +134,693 @@ function getConfigFromEnv() {
     }
   };
 }
-var KeycloakProvider = ({
+var useAuth = reactOidcContext.useAuth;
+
+// src/hooks/useTokenLifecycle.ts
+var STORAGE_KEY_PREFIX = "keycloak_first_login_";
+function useTokenLifecycle(options) {
+  const {
+    config,
+    debug = false,
+    onRefreshStart,
+    onRefreshSuccess,
+    onRefreshError,
+    onRefreshTokenExpired
+  } = options;
+  const auth = useAuth();
+  const [isRefreshing, setIsRefreshing] = react.useState(false);
+  const [isRefreshTokenExpired, setIsRefreshTokenExpired] = react.useState(false);
+  const hasCheckedOnStartup = react.useRef(false);
+  const log = react.useCallback(
+    (message, ...args) => {
+      if (debug) {
+        console.log("[TokenLifecycle]", message, ...args);
+      }
+    },
+    [debug]
+  );
+  const getStorageKey = react.useCallback(() => {
+    const authority = config.authority;
+    const clientId = config.clientId;
+    return `${STORAGE_KEY_PREFIX}${authority}_${clientId}`;
+  }, [config.authority, config.clientId]);
+  const storeFirstLoginTime = react.useCallback(() => {
+    const key = getStorageKey();
+    const existingTime = localStorage.getItem(key);
+    if (!existingTime) {
+      const now = Date.now();
+      localStorage.setItem(key, now.toString());
+      log("Stored first login time:", new Date(now).toISOString());
+    }
+  }, [getStorageKey, log]);
+  const checkRefreshTokenLifetime = react.useCallback(() => {
+    const maxLifetime = config.silentRenew?.maxRefreshTokenLifetime;
+    if (!maxLifetime || maxLifetime <= 0) {
+      return false;
+    }
+    const key = getStorageKey();
+    const firstLoginStr = localStorage.getItem(key);
+    if (!firstLoginStr) {
+      storeFirstLoginTime();
+      return false;
+    }
+    const firstLoginTime = parseInt(firstLoginStr, 10);
+    const now = Date.now();
+    const elapsedSeconds = (now - firstLoginTime) / 1e3;
+    log("Refresh token lifetime check:", {
+      firstLogin: new Date(firstLoginTime).toISOString(),
+      elapsedSeconds,
+      maxLifetime,
+      isExpired: elapsedSeconds >= maxLifetime
+    });
+    return elapsedSeconds >= maxLifetime;
+  }, [config.silentRenew?.maxRefreshTokenLifetime, getStorageKey, log, storeFirstLoginTime]);
+  const refreshToken = react.useCallback(async () => {
+    if (isRefreshing) {
+      log("Refresh already in progress, skipping");
+      return;
+    }
+    if (checkRefreshTokenLifetime()) {
+      log("Refresh token exceeded max lifetime, cannot refresh");
+      setIsRefreshTokenExpired(true);
+      onRefreshTokenExpired?.();
+      return;
+    }
+    try {
+      setIsRefreshing(true);
+      onRefreshStart?.();
+      log("Starting token refresh");
+      await auth.signinSilent();
+      log("Token refresh successful");
+      onRefreshSuccess?.();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      log("Token refresh failed:", err.message);
+      onRefreshError?.(err);
+      throw err;
+    } finally {
+      setIsRefreshing(false);
+    }
+  }, [
+    isRefreshing,
+    auth,
+    checkRefreshTokenLifetime,
+    onRefreshStart,
+    onRefreshSuccess,
+    onRefreshError,
+    onRefreshTokenExpired,
+    log
+  ]);
+  const checkAndRefreshTokens = react.useCallback(async () => {
+    if (!auth.user) {
+      log("No user session, skipping token check");
+      return false;
+    }
+    if (checkRefreshTokenLifetime()) {
+      log("Refresh token exceeded max lifetime");
+      setIsRefreshTokenExpired(true);
+      onRefreshTokenExpired?.();
+      const key = getStorageKey();
+      localStorage.removeItem(key);
+      await auth.removeUser();
+      return false;
+    }
+    const expiresAt = auth.user.expires_at;
+    if (!expiresAt) {
+      log("No expiration time found, skipping token check");
+      return false;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const threshold = config.silentRenew?.thresholdSeconds || 300;
+    const timeUntilExpiry = expiresAt - now;
+    log("Token expiration check:", {
+      expiresAt: new Date(expiresAt * 1e3).toISOString(),
+      now: new Date(now * 1e3).toISOString(),
+      timeUntilExpiry,
+      threshold,
+      needsRefresh: timeUntilExpiry <= threshold
+    });
+    if (timeUntilExpiry <= threshold) {
+      try {
+        await refreshToken();
+        return true;
+      } catch (error) {
+        log("Failed to refresh tokens:", error);
+        return false;
+      }
+    }
+    log("Tokens are still valid, no refresh needed");
+    return false;
+  }, [
+    auth,
+    config.silentRenew?.thresholdSeconds,
+    checkRefreshTokenLifetime,
+    refreshToken,
+    onRefreshTokenExpired,
+    getStorageKey,
+    log
+  ]);
+  react.useEffect(() => {
+    const strategy = config.silentRenew?.refreshStrategy || "both";
+    const shouldCheckOnStartup = strategy === "startup" || strategy === "both";
+    if (!shouldCheckOnStartup || hasCheckedOnStartup.current) {
+      return;
+    }
+    if (!auth.isAuthenticated || auth.isLoading) {
+      return;
+    }
+    hasCheckedOnStartup.current = true;
+    log("Running startup token check with strategy:", strategy);
+    checkAndRefreshTokens().catch((error) => {
+      log("Startup token check failed:", error);
+    });
+  }, [
+    auth.isAuthenticated,
+    auth.isLoading,
+    config.silentRenew?.refreshStrategy,
+    checkAndRefreshTokens,
+    log
+  ]);
+  react.useEffect(() => {
+    if (auth.user && !auth.isLoading) {
+      storeFirstLoginTime();
+    }
+  }, [auth.user, auth.isLoading, storeFirstLoginTime]);
+  react.useEffect(() => {
+    if (!auth.isAuthenticated || auth.isLoading) {
+      return;
+    }
+    const maxLifetime = config.silentRenew?.maxRefreshTokenLifetime;
+    if (!maxLifetime || maxLifetime <= 0) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      if (checkRefreshTokenLifetime()) {
+        log("Refresh token expired during periodic check");
+        setIsRefreshTokenExpired(true);
+        onRefreshTokenExpired?.();
+        const key = getStorageKey();
+        localStorage.removeItem(key);
+        auth.removeUser();
+      }
+    }, 5 * 60 * 1e3);
+    return () => clearInterval(intervalId);
+  }, [
+    auth,
+    config.silentRenew?.maxRefreshTokenLifetime,
+    checkRefreshTokenLifetime,
+    onRefreshTokenExpired,
+    getStorageKey,
+    log
+  ]);
+  return {
+    isRefreshing,
+    isRefreshTokenExpired,
+    refreshToken,
+    checkAndRefreshTokens
+  };
+}
+var TokenLifecycleManager = ({
   config,
   children,
   debug = false
 }) => {
+  const [showLoading, setShowLoading] = react.useState(false);
+  const handleRefreshStart = react.useCallback(() => {
+    if (config.silentRenew?.showLoadingIndicator) {
+      setShowLoading(true);
+    }
+  }, [config.silentRenew?.showLoadingIndicator]);
+  const handleRefreshSuccess = react.useCallback(() => {
+    setShowLoading(false);
+  }, []);
+  const handleRefreshError = react.useCallback((error) => {
+    setShowLoading(false);
+    if (debug) {
+      console.error("[TokenLifecycleManager] Token refresh failed:", error);
+    }
+    config.events?.onSilentRenewError?.(error);
+  }, [config.events, debug]);
+  const handleRefreshTokenExpired = react.useCallback(() => {
+    setShowLoading(false);
+    if (debug) {
+      console.warn("[TokenLifecycleManager] Refresh token exceeded max lifetime");
+    }
+    config.events?.onTokenExpired?.();
+  }, [config.events, debug]);
+  const { isRefreshing, isRefreshTokenExpired } = useTokenLifecycle({
+    config,
+    debug,
+    onRefreshStart: handleRefreshStart,
+    onRefreshSuccess: handleRefreshSuccess,
+    onRefreshError: handleRefreshError,
+    onRefreshTokenExpired: handleRefreshTokenExpired
+  });
+  if (isRefreshTokenExpired) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          height: "100vh",
+          fontFamily: "system-ui, -apple-system, sans-serif",
+          backgroundColor: "#f5f5f5",
+          padding: "20px",
+          textAlign: "center"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              backgroundColor: "white",
+              padding: "40px",
+              borderRadius: "8px",
+              boxShadow: "0 2px 8px rgba(0,0,0,0.1)",
+              maxWidth: "400px"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("h2", { style: { margin: "0 0 16px 0", color: "#333" }, children: "Session Expired" }),
+              /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: "0 0 24px 0", color: "#666" }, children: "Your session has been inactive for too long. Please sign in again to continue." }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  onClick: () => window.location.reload(),
+                  style: {
+                    padding: "12px 24px",
+                    backgroundColor: "#007bff",
+                    color: "white",
+                    border: "none",
+                    borderRadius: "4px",
+                    fontSize: "16px",
+                    cursor: "pointer",
+                    fontWeight: "500"
+                  },
+                  children: "Sign In Again"
+                }
+              )
+            ]
+          }
+        )
+      }
+    );
+  }
+  if (showLoading && isRefreshing) {
+    const message = config.silentRenew?.loadingMessage || "Refreshing session...";
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          height: "100vh",
+          fontFamily: "system-ui, -apple-system, sans-serif",
+          backgroundColor: "#f5f5f5"
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              style: {
+                display: "flex",
+                flexDirection: "column",
+                alignItems: "center",
+                gap: "16px"
+              },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    style: {
+                      width: "40px",
+                      height: "40px",
+                      border: "4px solid #e0e0e0",
+                      borderTop: "4px solid #007bff",
+                      borderRadius: "50%",
+                      animation: "spin 1s linear infinite"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, color: "#666", fontSize: "16px" }, children: message })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+            @keyframes spin {
+              0% { transform: rotate(0deg); }
+              100% { transform: rotate(360deg); }
+            }
+          ` })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+};
+var SessionMonitor = ({
+  position = "top-right",
+  warningThreshold = 300,
+  // 5 minutes
+  criticalThreshold = 60,
+  // 1 minute
+  showProgressBar = true,
+  minimizable = true,
+  startMinimized = false,
+  className = "",
+  onWarning,
+  onCritical,
+  onExpired,
+  style
+}) => {
+  const auth = useAuth();
+  const [timeRemaining, setTimeRemaining] = react.useState(null);
+  const [minimized, setMinimized] = react.useState(startMinimized);
+  const [warningTriggered, setWarningTriggered] = react.useState(false);
+  const [criticalTriggered, setCriticalTriggered] = react.useState(false);
+  react.useEffect(() => {
+    if (!auth.isAuthenticated || !auth.user?.expires_at) {
+      setTimeRemaining(null);
+      return;
+    }
+    const updateTimeRemaining = () => {
+      const expiresAt = auth.user.expires_at;
+      const now = Math.floor(Date.now() / 1e3);
+      const remaining = expiresAt - now;
+      if (remaining <= 0) {
+        setTimeRemaining(0);
+        onExpired?.();
+        setTimeout(() => {
+          auth.signoutRedirect();
+        }, 2e3);
+      } else {
+        setTimeRemaining(remaining);
+        if (remaining <= criticalThreshold && !criticalTriggered) {
+          setCriticalTriggered(true);
+          onCritical?.(remaining);
+        } else if (remaining <= warningThreshold && !warningTriggered) {
+          setWarningTriggered(true);
+          onWarning?.(remaining);
+        }
+      }
+    };
+    updateTimeRemaining();
+    const interval = setInterval(updateTimeRemaining, 1e3);
+    return () => clearInterval(interval);
+  }, [
+    auth,
+    warningThreshold,
+    criticalThreshold,
+    warningTriggered,
+    criticalTriggered,
+    onWarning,
+    onCritical,
+    onExpired
+  ]);
+  react.useEffect(() => {
+    if (timeRemaining && timeRemaining > warningThreshold) {
+      setWarningTriggered(false);
+      setCriticalTriggered(false);
+    }
+  }, [timeRemaining, warningThreshold]);
+  const formatTime = react.useCallback((seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  }, []);
+  const getStatusClass = react.useCallback(() => {
+    if (!timeRemaining) return "normal";
+    if (timeRemaining <= criticalThreshold) return "critical";
+    if (timeRemaining <= warningThreshold) return "warning";
+    return "normal";
+  }, [timeRemaining, warningThreshold, criticalThreshold]);
+  const getProgress = react.useCallback(() => {
+    if (!timeRemaining || !auth.user?.expires_in) return 100;
+    return timeRemaining / auth.user.expires_in * 100;
+  }, [timeRemaining, auth.user]);
+  if (!auth.isAuthenticated || timeRemaining === null) {
+    return null;
+  }
+  const baseClass = "kc-session-monitor";
+  const positionClass = `kc-session-monitor--${position}`;
+  const statusClass = `kc-session-monitor--${getStatusClass()}`;
+  const minimizedClass = minimized ? "kc-session-monitor--minimized" : "";
+  const classes = `${baseClass} ${positionClass} ${statusClass} ${minimizedClass} ${className}`.trim();
+  const progress = getProgress();
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classes, style, children: [
+    minimizable && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        className: "kc-session-monitor__toggle",
+        onClick: () => setMinimized(!minimized),
+        "aria-label": minimized ? "Expand session monitor" : "Minimize session monitor",
+        title: minimized ? "Expand" : "Minimize",
+        children: minimized ? "\u25B2" : "\u25BC"
+      }
+    ),
+    !minimized && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kc-session-monitor__content", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kc-session-monitor__label", children: timeRemaining === 0 ? "Session expired" : "Session expires in:" }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kc-session-monitor__time", children: formatTime(timeRemaining) })
+      ] }),
+      showProgressBar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kc-session-monitor__progress-bar", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "kc-session-monitor__progress-fill",
+          style: { width: `${progress}%` },
+          role: "progressbar",
+          "aria-valuenow": progress,
+          "aria-valuemin": 0,
+          "aria-valuemax": 100
+        }
+      ) })
+    ] })
+  ] });
+};
+
+// src/config/presets.ts
+var CONFIG_PRESETS = {
+  /**
+   * Default preset - Balanced configuration for most applications
+   *
+   * Features:
+   * - 30-day refresh token lifetime
+   * - Proactive token refresh on startup + reactive on 401
+   * - Silent background token refresh
+   * - Session monitoring enabled
+   * - Auto token refresh enabled
+   *
+   * Best for: Most web applications, dashboards, internal tools
+   */
+  default: {
+    scope: "openid profile email offline_access",
+    features: {
+      autoRefresh: true,
+      sessionMonitor: true,
+      deviceFlow: false
+    },
+    silentRenew: {
+      enabled: true,
+      thresholdSeconds: 300,
+      // 5 minutes
+      refreshStrategy: "both",
+      maxRefreshTokenLifetime: 2592e3,
+      // 30 days
+      showLoadingIndicator: false,
+      loadingMessage: "Refreshing session..."
+    },
+    advanced: {
+      responseType: "code",
+      codeChallengeMethod: "S256",
+      loadUserInfo: true,
+      automaticSilentSignIn: false
+    }
+  },
+  /**
+   * Mobile/PWA preset - Optimized for mobile and progressive web apps
+   *
+   * Features:
+   * - 30-day refresh token lifetime
+   * - Proactive startup refresh (apps close frequently)
+   * - Loading indicator during refresh (better UX for app reopening)
+   * - Session monitoring enabled
+   *
+   * Best for: Mobile apps, PWAs, apps that frequently close/reopen
+   */
+  mobile: {
+    scope: "openid profile email offline_access",
+    features: {
+      autoRefresh: true,
+      sessionMonitor: true,
+      deviceFlow: false
+    },
+    silentRenew: {
+      enabled: true,
+      thresholdSeconds: 300,
+      refreshStrategy: "startup",
+      // Focus on startup refresh
+      maxRefreshTokenLifetime: 2592e3,
+      // 30 days
+      showLoadingIndicator: true,
+      // Show loading for better UX
+      loadingMessage: "Restoring your session..."
+    },
+    advanced: {
+      responseType: "code",
+      codeChallengeMethod: "S256",
+      loadUserInfo: true,
+      automaticSilentSignIn: false
+    }
+  },
+  /**
+   * High Security preset - Strict security for sensitive applications
+   *
+   * Features:
+   * - 24-hour forced re-authentication
+   * - Proactive + reactive token refresh
+   * - 10-minute refresh threshold (earlier refresh)
+   * - Silent refresh (no UI hints about security measures)
+   * - Session monitoring enabled
+   *
+   * Best for: Banking, healthcare, admin panels, sensitive data applications
+   */
+  "high-security": {
+    scope: "openid profile email offline_access",
+    features: {
+      autoRefresh: true,
+      sessionMonitor: true,
+      deviceFlow: false
+    },
+    silentRenew: {
+      enabled: true,
+      thresholdSeconds: 600,
+      // 10 minutes (more aggressive)
+      refreshStrategy: "both",
+      maxRefreshTokenLifetime: 86400,
+      // 24 hours only
+      showLoadingIndicator: false,
+      // Silent for security
+      loadingMessage: "Validating session..."
+    },
+    advanced: {
+      responseType: "code",
+      codeChallengeMethod: "S256",
+      loadUserInfo: true,
+      automaticSilentSignIn: false
+    }
+  },
+  /**
+   * Long-Running preset - Optimized for desktop apps and long sessions
+   *
+   * Features:
+   * - 7-day refresh token lifetime
+   * - Proactive + reactive token refresh
+   * - Silent background refresh
+   * - Session monitoring enabled
+   *
+   * Best for: Desktop applications, monitoring dashboards, always-on tools
+   */
+  "long-running": {
+    scope: "openid profile email offline_access",
+    features: {
+      autoRefresh: true,
+      sessionMonitor: true,
+      deviceFlow: false
+    },
+    silentRenew: {
+      enabled: true,
+      thresholdSeconds: 300,
+      refreshStrategy: "both",
+      maxRefreshTokenLifetime: 604800,
+      // 7 days
+      showLoadingIndicator: false,
+      loadingMessage: "Refreshing session..."
+    },
+    advanced: {
+      responseType: "code",
+      codeChallengeMethod: "S256",
+      loadUserInfo: true,
+      automaticSilentSignIn: false
+    }
+  },
+  /**
+   * Development preset - Convenient settings for development
+   *
+   * Features:
+   * - No refresh token lifetime limit (never expires)
+   * - Proactive + reactive token refresh
+   * - Loading indicators visible (easier debugging)
+   * - Session monitoring enabled
+   * - More verbose feedback
+   *
+   * Best for: Local development, testing, debugging
+   * WARNING: Do not use in production!
+   */
+  development: {
+    scope: "openid profile email offline_access",
+    features: {
+      autoRefresh: true,
+      sessionMonitor: true,
+      deviceFlow: false
+    },
+    silentRenew: {
+      enabled: true,
+      thresholdSeconds: 300,
+      refreshStrategy: "both",
+      maxRefreshTokenLifetime: 0,
+      // No limit (for convenience)
+      showLoadingIndicator: true,
+      // Show for debugging
+      loadingMessage: "[DEV] Refreshing tokens..."
+    },
+    advanced: {
+      responseType: "code",
+      codeChallengeMethod: "S256",
+      loadUserInfo: true,
+      automaticSilentSignIn: false
+    }
+  }
+};
+function getConfigPreset(preset) {
+  return CONFIG_PRESETS[preset];
+}
+function mergeWithPreset(preset, customConfig) {
+  const presetConfig = getConfigPreset(preset);
+  return {
+    ...presetConfig,
+    ...customConfig,
+    features: {
+      ...presetConfig.features,
+      ...customConfig.features
+    },
+    silentRenew: {
+      ...presetConfig.silentRenew,
+      ...customConfig.silentRenew
+    },
+    advanced: {
+      ...presetConfig.advanced,
+      ...customConfig.advanced
+    },
+    events: {
+      ...presetConfig.events,
+      ...customConfig.events
+    }
+  };
+}
+function isZeroConfig(props) {
+  return "authority" in props && "clientId" in props;
+}
+var KeycloakProvider = (props) => {
+  const { children, debug = false } = props;
+  const config = isZeroConfig(props) ? buildZeroConfig(props) : props.config;
   const oidcConfig = KeycloakConfigBuilder.build(config);
   const log = react.useCallback(
     (level, message, ...args) => {
       if (debug) {
-        const prefix = "[Keycloak]";
+        const prefix = "[KeycloakProvider]";
         switch (level) {
           case "info":
             console.log(prefix, message, ...args);
@@ -165,11 +848,13 @@ var KeycloakProvider = ({
   );
   const onSignoutCallback = react.useCallback(() => {
     log("info", "Sign out successful");
+    window.history.replaceState({}, document.title, window.location.pathname);
     config.events?.onLogout?.();
   }, [config.events, log]);
   const onRemoveUser = react.useCallback(() => {
-    log("info", "User removed");
+    log("warn", "User removed from storage - token validation likely failed");
   }, [log]);
+  const showSessionMonitor = config.features?.sessionMonitor !== false;
   return /* @__PURE__ */ jsxRuntime.jsx(
     reactOidcContext.AuthProvider,
     {
@@ -177,11 +862,26 @@ var KeycloakProvider = ({
       onSigninCallback,
       onSignoutCallback,
       onRemoveUser,
-      children
+      children: /* @__PURE__ */ jsxRuntime.jsxs(TokenLifecycleManager, { config, debug, children: [
+        showSessionMonitor && /* @__PURE__ */ jsxRuntime.jsx(SessionMonitor, {}),
+        children
+      ] })
     }
   );
 };
-var useAuth = reactOidcContext.useAuth;
+function buildZeroConfig(props) {
+  const { authority, clientId, preset = "default", config: overrides = {} } = props;
+  const presetConfig = mergeWithPreset(preset, overrides);
+  const fullConfig = {
+    ...defaultConfig,
+    ...presetConfig,
+    authority,
+    clientId,
+    redirectUri: presetConfig.redirectUri || (typeof window !== "undefined" ? window.location.origin + "/" : "/"),
+    postLogoutRedirectUri: presetConfig.postLogoutRedirectUri || (typeof window !== "undefined" ? window.location.origin + "/" : "/")
+  };
+  return fullConfig;
+}
 function useRoles() {
   const auth = useAuth();
   const roles = react.useMemo(() => {
@@ -509,125 +1209,6 @@ function getInitials(name) {
   }
   return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
 }
-var SessionMonitor = ({
-  position = "top-right",
-  warningThreshold = 300,
-  // 5 minutes
-  criticalThreshold = 60,
-  // 1 minute
-  showProgressBar = true,
-  minimizable = true,
-  startMinimized = false,
-  className = "",
-  onWarning,
-  onCritical,
-  onExpired,
-  style
-}) => {
-  const auth = useAuth();
-  const [timeRemaining, setTimeRemaining] = react.useState(null);
-  const [minimized, setMinimized] = react.useState(startMinimized);
-  const [warningTriggered, setWarningTriggered] = react.useState(false);
-  const [criticalTriggered, setCriticalTriggered] = react.useState(false);
-  react.useEffect(() => {
-    if (!auth.isAuthenticated || !auth.user?.expires_at) {
-      setTimeRemaining(null);
-      return;
-    }
-    const updateTimeRemaining = () => {
-      const expiresAt = auth.user.expires_at;
-      const now = Math.floor(Date.now() / 1e3);
-      const remaining = expiresAt - now;
-      if (remaining <= 0) {
-        setTimeRemaining(0);
-        onExpired?.();
-        setTimeout(() => {
-          auth.signoutRedirect();
-        }, 2e3);
-      } else {
-        setTimeRemaining(remaining);
-        if (remaining <= criticalThreshold && !criticalTriggered) {
-          setCriticalTriggered(true);
-          onCritical?.(remaining);
-        } else if (remaining <= warningThreshold && !warningTriggered) {
-          setWarningTriggered(true);
-          onWarning?.(remaining);
-        }
-      }
-    };
-    updateTimeRemaining();
-    const interval = setInterval(updateTimeRemaining, 1e3);
-    return () => clearInterval(interval);
-  }, [
-    auth,
-    warningThreshold,
-    criticalThreshold,
-    warningTriggered,
-    criticalTriggered,
-    onWarning,
-    onCritical,
-    onExpired
-  ]);
-  react.useEffect(() => {
-    if (timeRemaining && timeRemaining > warningThreshold) {
-      setWarningTriggered(false);
-      setCriticalTriggered(false);
-    }
-  }, [timeRemaining, warningThreshold]);
-  const formatTime = react.useCallback((seconds) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}:${secs.toString().padStart(2, "0")}`;
-  }, []);
-  const getStatusClass = react.useCallback(() => {
-    if (!timeRemaining) return "normal";
-    if (timeRemaining <= criticalThreshold) return "critical";
-    if (timeRemaining <= warningThreshold) return "warning";
-    return "normal";
-  }, [timeRemaining, warningThreshold, criticalThreshold]);
-  const getProgress = react.useCallback(() => {
-    if (!timeRemaining || !auth.user?.expires_in) return 100;
-    return timeRemaining / auth.user.expires_in * 100;
-  }, [timeRemaining, auth.user]);
-  if (!auth.isAuthenticated || timeRemaining === null) {
-    return null;
-  }
-  const baseClass = "kc-session-monitor";
-  const positionClass = `kc-session-monitor--${position}`;
-  const statusClass = `kc-session-monitor--${getStatusClass()}`;
-  const minimizedClass = minimized ? "kc-session-monitor--minimized" : "";
-  const classes = `${baseClass} ${positionClass} ${statusClass} ${minimizedClass} ${className}`.trim();
-  const progress = getProgress();
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classes, style, children: [
-    minimizable && /* @__PURE__ */ jsxRuntime.jsx(
-      "button",
-      {
-        className: "kc-session-monitor__toggle",
-        onClick: () => setMinimized(!minimized),
-        "aria-label": minimized ? "Expand session monitor" : "Minimize session monitor",
-        title: minimized ? "Expand" : "Minimize",
-        children: minimized ? "\u25B2" : "\u25BC"
-      }
-    ),
-    !minimized && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "kc-session-monitor__content", children: [
-        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kc-session-monitor__label", children: timeRemaining === 0 ? "Session expired" : "Session expires in:" }),
-        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "kc-session-monitor__time", children: formatTime(timeRemaining) })
-      ] }),
-      showProgressBar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "kc-session-monitor__progress-bar", children: /* @__PURE__ */ jsxRuntime.jsx(
-        "div",
-        {
-          className: "kc-session-monitor__progress-fill",
-          style: { width: `${progress}%` },
-          role: "progressbar",
-          "aria-valuenow": progress,
-          "aria-valuemin": 0,
-          "aria-valuemax": 100
-        }
-      ) })
-    ] })
-  ] });
-};
 
 // src/utils/deviceFlow.ts
 async function requestDeviceCode(apiBaseUrl) {
@@ -935,6 +1516,7 @@ function useProtectedFetch(options = {}) {
   };
 }
 
+exports.CONFIG_PRESETS = CONFIG_PRESETS;
 exports.DeviceLogin = DeviceLogin;
 exports.KeycloakConfigBuilder = KeycloakConfigBuilder;
 exports.KeycloakProvider = KeycloakProvider;
@@ -942,15 +1524,19 @@ exports.LoginButton = LoginButton;
 exports.LogoutButton = LogoutButton;
 exports.ProtectedRoute = ProtectedRoute;
 exports.SessionMonitor = SessionMonitor;
+exports.TokenLifecycleManager = TokenLifecycleManager;
 exports.UserProfile = UserProfile;
 exports.defaultConfig = defaultConfig;
 exports.fetchUserInfo = fetchUserInfo;
 exports.getConfigFromEnv = getConfigFromEnv;
+exports.getConfigPreset = getConfigPreset;
+exports.mergeWithPreset = mergeWithPreset;
 exports.pollForToken = pollForToken;
 exports.requestDeviceCode = requestDeviceCode;
 exports.useAuth = useAuth;
 exports.useProtectedFetch = useProtectedFetch;
 exports.useRoles = useRoles;
 exports.useScopes = useScopes;
+exports.useTokenLifecycle = useTokenLifecycle;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map