antaeus.keycloak.react 2.2.3 → 2.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import React from 'react';
+import * as React$1 from 'react';
+import React__default from 'react';
 import { User, UserManagerSettings } from 'oidc-client-ts';
 export { User } from 'oidc-client-ts';
 import { useLocation } from 'react-router-dom';
@@ -113,6 +114,12 @@ interface SilentRenewConfig {
      * @default 'Refreshing session...'
      */
     loadingMessage?: string;
+    /**
+     * Enable using the refresh token grant instead of iframe silent renew when available.
+     * Keeps long-lived sessions alive even after the app is closed.
+     * @default true
+     */
+    useRefreshToken?: boolean;
 }
 /**
  * Event callbacks for authentication lifecycle
@@ -217,6 +224,40 @@ declare function getConfigPreset(preset: ConfigPreset): Partial<KeycloakConfig>;
  */
 declare function mergeWithPreset(preset: ConfigPreset, customConfig: Partial<KeycloakConfig>): Partial<KeycloakConfig>;
 
+type TokenListener = (token: string | null) => void;
+/**
+ * Minimal bridge to expose the current Keycloak access token outside React.
+ * Consumers can subscribe to token changes or fetch the latest value on demand.
+ */
+declare class TokenBridge {
+    private currentToken;
+    private listeners;
+    /**
+     * Update the tracked token and notify subscribers when it changes.
+     */
+    setToken(token: string | null): void;
+    /**
+     * Read the most recent token value.
+     */
+    getToken(): string | null;
+    /**
+     * Convenience helper for async callers.
+     */
+    getTokenAsync(): Promise<string | null>;
+    /**
+     * Subscribe to token changes. Returns an unsubscribe callback.
+     */
+    subscribe(listener: TokenListener): () => void;
+}
+/**
+ * Factory helper to create an isolated token bridge.
+ */
+declare const createTokenBridge: () => TokenBridge;
+/**
+ * Default shared bridge for simple scenarios.
+ */
+declare const defaultTokenBridge: TokenBridge;
+
 /**
  * Props for zero-config mode (simplified setup)
  */
@@ -234,10 +275,16 @@ interface KeycloakProviderZeroConfigProps {
      * @default 'default'
      */
     preset?: ConfigPreset;
+    /**
+     * Toggle to disable Keycloak integration entirely.
+     * When false, children render with a stub auth context.
+     * @default true
+     */
+    enabled?: boolean;
     /**
      * Child components to render
      */
-    children: React.ReactNode;
+    children: React__default.ReactNode;
     /**
      * Enable debug logging to console
      * @default false
@@ -248,6 +295,10 @@ interface KeycloakProviderZeroConfigProps {
      * Use this to customize preset or zero-config defaults
      */
     config?: Partial<Omit<KeycloakConfig, 'authority' | 'clientId'>>;
+    /**
+     * Optional token bridge instance for exposing tokens outside React.
+     */
+    tokenBridge?: TokenBridge;
 }
 /**
  * Props for full-config mode (advanced setup)
@@ -257,15 +308,25 @@ interface KeycloakProviderFullConfigProps {
      * Full Keycloak configuration object
      */
     config: KeycloakConfig;
+    /**
+     * Toggle to disable Keycloak integration entirely.
+     * When false, children render with a stub auth context.
+     * @default true
+     */
+    enabled?: boolean;
     /**
      * Child components to render
      */
-    children: React.ReactNode;
+    children: React__default.ReactNode;
     /**
      * Enable debug logging to console
      * @default false
      */
     debug?: boolean;
+    /**
+     * Optional token bridge instance for exposing tokens outside React.
+     */
+    tokenBridge?: TokenBridge;
 }
 /**
  * Combined props type
@@ -318,6 +379,7 @@ type KeycloakProviderProps = KeycloakProviderZeroConfigProps | KeycloakProviderF
  *     silentRenew: {
  *       maxRefreshTokenLifetime: 604800, // Override: 7 days instead of 30
  *       showLoadingIndicator: true,
+ *       useRefreshToken: true, // Explicitly ensure refresh tokens are used when available
  *     }
  *   }}
  *   debug={true}
@@ -361,6 +423,7 @@ type KeycloakProviderProps = KeycloakProviderZeroConfigProps | KeycloakProviderF
  *       enabled: true,
  *       refreshStrategy: 'both',
  *       maxRefreshTokenLifetime: 2592000,
+ *       useRefreshToken: true,
  *     },
  *     events: {
  *       onLogin: (user) => console.log('User logged in', user),
@@ -380,6 +443,7 @@ type KeycloakProviderProps = KeycloakProviderZeroConfigProps | KeycloakProviderF
  * - ✅ Token lifecycle management (refresh on app startup)
  * - ✅ Session monitoring UI (countdown timer)
  * - ✅ Silent renew (background token refresh)
+ * - ✅ Refresh token grant fallback on app restart
  * - ✅ Error notifications (user-friendly messages)
  * - ✅ 401 retry logic (automatic token refresh on API errors)
  * - ✅ Maximum refresh token lifetime (security control)
@@ -387,7 +451,7 @@ type KeycloakProviderProps = KeycloakProviderZeroConfigProps | KeycloakProviderF
  *
  * All features can be disabled or customized via configuration overrides.
  */
-declare const KeycloakProvider: React.FC<KeycloakProviderProps>;
+declare const KeycloakProvider: React__default.FC<KeycloakProviderProps>;
 
 /**
  * Context object passed to custom policy function
@@ -410,7 +474,7 @@ interface ProtectedRouteProps {
     /**
      * Child components to render when user is authorized
      */
-    children: React.ReactNode;
+    children: React__default.ReactNode;
     /**
      * Required realm roles (OR logic - user needs at least one)
      */
@@ -437,11 +501,11 @@ interface ProtectedRouteProps {
     /**
      * Custom loading component to display while checking authentication
      */
-    loadingComponent?: React.ReactNode;
+    loadingComponent?: React__default.ReactNode;
     /**
      * Custom unauthorized component to display when user lacks required permissions
      */
-    unauthorizedComponent?: React.ReactNode;
+    unauthorizedComponent?: React__default.ReactNode;
     /**
      * Path to redirect to if not authenticated
      * @default '/login'
@@ -568,14 +632,14 @@ interface ProtectedRouteProps {
  * </ProtectedRoute>
  * ```
  */
-declare const ProtectedRoute: React.FC<ProtectedRouteProps>;
+declare const ProtectedRoute: React__default.FC<ProtectedRouteProps>;
 
 interface LoginButtonProps {
     /**
      * Button text
      * @default 'Login'
      */
-    children?: React.ReactNode;
+    children?: React__default.ReactNode;
     /**
      * Additional CSS class names
      */
@@ -602,7 +666,7 @@ interface LoginButtonProps {
     /**
      * Custom inline styles
      */
-    style?: React.CSSProperties;
+    style?: React__default.CSSProperties;
     /**
      * Disable the button
      */
@@ -642,14 +706,14 @@ interface LoginButtonProps {
  * />
  * ```
  */
-declare const LoginButton: React.FC<LoginButtonProps>;
+declare const LoginButton: React__default.FC<LoginButtonProps>;
 
 interface LogoutButtonProps {
     /**
      * Button text
      * @default 'Logout'
      */
-    children?: React.ReactNode;
+    children?: React__default.ReactNode;
     /**
      * Additional CSS class names
      */
@@ -676,7 +740,7 @@ interface LogoutButtonProps {
     /**
      * Custom inline styles
      */
-    style?: React.CSSProperties;
+    style?: React__default.CSSProperties;
     /**
      * Disable the button
      */
@@ -719,7 +783,7 @@ interface LogoutButtonProps {
  * />
  * ```
  */
-declare const LogoutButton: React.FC<LogoutButtonProps>;
+declare const LogoutButton: React__default.FC<LogoutButtonProps>;
 
 interface UserProfileProps {
     /**
@@ -749,7 +813,7 @@ interface UserProfileProps {
     /**
      * Custom inline styles
      */
-    style?: React.CSSProperties;
+    style?: React__default.CSSProperties;
     /**
      * Callback when profile is clicked
      */
@@ -793,7 +857,7 @@ interface UserProfileProps {
  * />
  * ```
  */
-declare const UserProfile: React.FC<UserProfileProps>;
+declare const UserProfile: React__default.FC<UserProfileProps>;
 
 interface SessionMonitorProps {
     /**
@@ -845,7 +909,7 @@ interface SessionMonitorProps {
     /**
      * Custom inline styles
      */
-    style?: React.CSSProperties;
+    style?: React__default.CSSProperties;
 }
 /**
  * Session monitoring component with countdown timer
@@ -888,7 +952,7 @@ interface SessionMonitorProps {
  * />
  * ```
  */
-declare const SessionMonitor: React.FC<SessionMonitorProps>;
+declare const SessionMonitor: React__default.FC<SessionMonitorProps>;
 
 interface DeviceLoginProps {
     /**
@@ -921,7 +985,7 @@ interface DeviceLoginProps {
     /**
      * Custom inline styles
      */
-    style?: React.CSSProperties;
+    style?: React__default.CSSProperties;
 }
 /**
  * Device flow login component
@@ -956,7 +1020,7 @@ interface DeviceLoginProps {
  * />
  * ```
  */
-declare const DeviceLogin: React.FC<DeviceLoginProps>;
+declare const DeviceLogin: React__default.FC<DeviceLoginProps>;
 
 interface TokenLifecycleManagerProps {
     /**
@@ -966,7 +1030,7 @@ interface TokenLifecycleManagerProps {
     /**
      * Child components to render
      */
-    children: React.ReactNode;
+    children: React__default.ReactNode;
     /**
      * Enable debug logging
      * @default false
@@ -988,7 +1052,19 @@ interface TokenLifecycleManagerProps {
  * </TokenLifecycleManager>
  * ```
  */
-declare const TokenLifecycleManager: React.FC<TokenLifecycleManagerProps>;
+declare const TokenLifecycleManager: React__default.FC<TokenLifecycleManagerProps>;
+
+interface TokenBridgeProps {
+    /**
+     * Optional custom bridge instance. Defaults to the shared global bridge.
+     */
+    bridge?: TokenBridge;
+}
+/**
+ * Synchronises the current Keycloak access token into an imperative TokenBridge.
+ * Place this component inside your application tree (after KeycloakProvider).
+ */
+declare const TokenBridgeSync: React.FC<TokenBridgeProps>;
 
 /**
  * Main authentication hook for accessing Keycloak authentication state and methods
@@ -1397,6 +1473,24 @@ declare class KeycloakConfigBuilder {
  */
 declare function getConfigFromEnv(): Partial<KeycloakConfig>;
 
+type KeycloakDisabledReason = 'disabled' | 'missing-config';
+interface KeycloakStatus {
+    /**
+     * Whether the Keycloak integration is enabled by configuration.
+     */
+    isEnabled: boolean;
+    /**
+     * Whether the minimum configuration (authority + clientId) is present.
+     */
+    isConfigured: boolean;
+    /**
+     * Provides additional context when integration is disabled.
+     */
+    reason?: KeycloakDisabledReason;
+}
+declare const KeycloakStatusProvider: React$1.Provider<KeycloakStatus>;
+declare const useKeycloakStatus: () => KeycloakStatus;
+
 /**
  * Device authorization response from Keycloak
  */
@@ -1508,4 +1602,4 @@ declare function pollForToken(apiBaseUrl: string, deviceCode: string): Promise<T
  */
 declare function fetchUserInfo(apiBaseUrl: string, accessToken: string): Promise<any>;
 
-export { type AdvancedOidcOptions, CONFIG_PRESETS, type ConfigPreset, type DeviceAuthorizationResponse, type DeviceFlowError, DeviceLogin, type DeviceLoginProps, type EventCallbacks, type FeatureFlags, type KeycloakConfig, KeycloakConfigBuilder, KeycloakProvider, type KeycloakProviderFullConfigProps, type KeycloakProviderProps, type KeycloakProviderZeroConfigProps, LoginButton, type LoginButtonProps, LogoutButton, type LogoutButtonProps, type PolicyContext, type PolicyFunction, ProtectedRoute, type ProtectedRouteProps, SessionMonitor, type SessionMonitorProps, type SilentRenewConfig, TokenLifecycleManager, type TokenLifecycleManagerProps, type TokenResponse, type UseProtectedFetchOptions, type UseProtectedFetchReturn, type UseRolesReturn, type UseScopesReturn, type UseTokenLifecycleOptions, type UseTokenLifecycleReturn, UserProfile, type UserProfileProps, defaultConfig, fetchUserInfo, getConfigFromEnv, getConfigPreset, mergeWithPreset, pollForToken, requestDeviceCode, useAuth, useProtectedFetch, useRoles, useScopes, useTokenLifecycle };
+export { type AdvancedOidcOptions, CONFIG_PRESETS, type ConfigPreset, type DeviceAuthorizationResponse, type DeviceFlowError, DeviceLogin, type DeviceLoginProps, type EventCallbacks, type FeatureFlags, type KeycloakConfig, KeycloakConfigBuilder, type KeycloakDisabledReason, KeycloakProvider, type KeycloakProviderFullConfigProps, type KeycloakProviderProps, type KeycloakProviderZeroConfigProps, type KeycloakStatus, KeycloakStatusProvider, LoginButton, type LoginButtonProps, LogoutButton, type LogoutButtonProps, type PolicyContext, type PolicyFunction, ProtectedRoute, type ProtectedRouteProps, SessionMonitor, type SessionMonitorProps, type SilentRenewConfig, TokenBridge, type TokenBridgeProps, TokenBridgeSync, TokenLifecycleManager, type TokenLifecycleManagerProps, type TokenListener, type TokenResponse, type UseProtectedFetchOptions, type UseProtectedFetchReturn, type UseRolesReturn, type UseScopesReturn, type UseTokenLifecycleOptions, type UseTokenLifecycleReturn, UserProfile, type UserProfileProps, createTokenBridge, defaultConfig, defaultTokenBridge, fetchUserInfo, getConfigFromEnv, getConfigPreset, mergeWithPreset, pollForToken, requestDeviceCode, useAuth, useKeycloakStatus, useProtectedFetch, useRoles, useScopes, useTokenLifecycle };

package/dist/index.js

@@ -30,7 +30,8 @@ var defaultConfig = {
     maxRefreshTokenLifetime: 2592e3,
     // 30 days in seconds
     showLoadingIndicator: false,
-    loadingMessage: "Refreshing session..."
+    loadingMessage: "Refreshing session...",
+    useRefreshToken: true
   },
   advanced: {
     responseType: "code",
@@ -56,6 +57,7 @@ var KeycloakConfigBuilder = class {
     const config = this.mergeWithDefaults(userConfig);
     const storageType = config.advanced.storageType || "session";
     const storage = storageType === "local" ? window.localStorage : window.sessionStorage;
+    const { useRefreshToken } = config.silentRenew;
     const oidcSettings = {
       authority: config.authority,
       client_id: config.clientId,
@@ -73,6 +75,9 @@ var KeycloakConfigBuilder = class {
         response_mode: "query"
       }
     };
+    if (useRefreshToken !== void 0) {
+      oidcSettings.useRefreshToken = useRefreshToken;
+    }
     return oidcSettings;
   }
   /**
@@ -160,6 +165,7 @@ function useTokenLifecycle(options) {
   const [isRefreshing, setIsRefreshing] = react.useState(false);
   const [isRefreshTokenExpired, setIsRefreshTokenExpired] = react.useState(false);
   const hasCheckedOnStartup = react.useRef(false);
+  const supportsRefreshTokens = config.silentRenew?.useRefreshToken !== false;
   const log = react.useCallback(
     (message, ...args) => {
       if (debug) {
@@ -296,24 +302,49 @@ function useTokenLifecycle(options) {
   react.useEffect(() => {
     const strategy = config.silentRenew?.refreshStrategy || "both";
     const shouldCheckOnStartup = strategy === "startup" || strategy === "both";
+    const hasRefreshToken = Boolean(auth.user?.refresh_token);
     if (!shouldCheckOnStartup || hasCheckedOnStartup.current) {
       return;
     }
-    if (!auth.isAuthenticated || auth.isLoading) {
+    if (auth.isLoading) {
       return;
     }
+    if (!auth.isAuthenticated) {
+      if (!supportsRefreshTokens) {
+        return;
+      }
+      if (!auth.user || !hasRefreshToken) {
+        return;
+      }
+    }
     hasCheckedOnStartup.current = true;
-    log("Running startup token check with strategy:", strategy);
+    log(
+      "Running startup token check with strategy:",
+      strategy,
+      "using refresh token:",
+      !auth.isAuthenticated && supportsRefreshTokens
+    );
     checkAndRefreshTokens().catch((error) => {
       log("Startup token check failed:", error);
     });
   }, [
     auth.isAuthenticated,
     auth.isLoading,
+    auth.user,
     config.silentRenew?.refreshStrategy,
+    supportsRefreshTokens,
     checkAndRefreshTokens,
     log
   ]);
+  react.useEffect(() => {
+    if (hasCheckedOnStartup.current) {
+      const hasUser = Boolean(auth.user);
+      const hasRefreshToken = Boolean(auth.user?.refresh_token);
+      if (auth.isLoading || !auth.isAuthenticated && (!supportsRefreshTokens || !hasUser || !hasRefreshToken)) {
+        hasCheckedOnStartup.current = false;
+      }
+    }
+  }, [auth.isAuthenticated, auth.isLoading, auth.user, supportsRefreshTokens]);
   react.useEffect(() => {
     if (auth.user && !auth.isLoading) {
       storeFirstLoginTime();
@@ -628,6 +659,71 @@ var SessionMonitor = ({
   ] });
 };
 
+// src/utils/tokenBridge.ts
+var TokenBridge = class {
+  constructor() {
+    this.currentToken = null;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Update the tracked token and notify subscribers when it changes.
+   */
+  setToken(token) {
+    if (this.currentToken === token) {
+      return;
+    }
+    this.currentToken = token;
+    for (const listener of this.listeners) {
+      try {
+        listener(token);
+      } catch (error) {
+        console.error("[TokenBridge] Listener threw error:", error);
+      }
+    }
+  }
+  /**
+   * Read the most recent token value.
+   */
+  getToken() {
+    return this.currentToken;
+  }
+  /**
+   * Convenience helper for async callers.
+   */
+  async getTokenAsync() {
+    return this.currentToken;
+  }
+  /**
+   * Subscribe to token changes. Returns an unsubscribe callback.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.currentToken);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+};
+var createTokenBridge = () => new TokenBridge();
+var defaultTokenBridge = createTokenBridge();
+
+// src/components/TokenBridge.tsx
+var TokenBridgeSync = ({
+  bridge = defaultTokenBridge
+}) => {
+  const auth = useAuth();
+  react.useEffect(() => {
+    const token = auth.user?.access_token ?? null;
+    bridge.setToken(token);
+  }, [auth.user, bridge]);
+  react.useEffect(() => {
+    if (!auth.isAuthenticated) {
+      bridge.setToken(null);
+    }
+  }, [auth.isAuthenticated, bridge]);
+  return null;
+};
+
 // src/config/presets.ts
 var CONFIG_PRESETS = {
   /**
@@ -846,11 +942,97 @@ var StorageConfigProvider = ({ storageType, children }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(StorageConfigContext.Provider, { value: { storageType, storage }, children });
 };
 var useStorageConfig = () => react.useContext(StorageConfigContext);
+var defaultStatus = {
+  isEnabled: true,
+  isConfigured: true
+};
+var KeycloakStatusContext = react.createContext(defaultStatus);
+var KeycloakStatusProvider = KeycloakStatusContext.Provider;
+var useKeycloakStatus = () => react.useContext(KeycloakStatusContext);
+var createDisabledEvents = () => {
+  const noop = () => void 0;
+  const noopSubscription = () => () => void 0;
+  const noopAsync = async () => void 0;
+  const events = {
+    addAccessTokenExpiring: noopSubscription,
+    removeAccessTokenExpiring: noop,
+    addAccessTokenExpired: noopSubscription,
+    removeAccessTokenExpired: noop,
+    addSilentRenewError: noopSubscription,
+    removeSilentRenewError: noop,
+    addUserLoaded: noopSubscription,
+    removeUserLoaded: noop,
+    addUserUnloaded: noopSubscription,
+    removeUserUnloaded: noop,
+    addUserSignedIn: noopSubscription,
+    removeUserSignedIn: noop,
+    addUserSignedOut: noopSubscription,
+    removeUserSignedOut: noop,
+    addUserSessionChanged: noopSubscription,
+    removeUserSessionChanged: noop,
+    load: noopAsync,
+    unload: noopAsync
+  };
+  return events;
+};
+var disabledEvents = createDisabledEvents();
+var disabledSettings = {
+  authority: "",
+  client_id: "",
+  redirect_uri: "http://localhost/disabled",
+  response_type: "code",
+  scope: ""
+};
+var disabledError = () => new Error("Keycloak integration is disabled for this environment.");
+var disabledAsync = async () => {
+  throw disabledError();
+};
+var disabledAuthContext = {
+  settings: disabledSettings,
+  events: disabledEvents,
+  clearStaleState: async () => void 0,
+  removeUser: async () => void 0,
+  signinPopup: (_args) => disabledAsync(),
+  signinSilent: async (_args) => null,
+  signinRedirect: (_args) => disabledAsync(),
+  signinResourceOwnerCredentials: (_args) => disabledAsync(),
+  signoutRedirect: async (_args) => void 0,
+  signoutPopup: async (_args) => void 0,
+  signoutSilent: async (_args) => void 0,
+  querySessionStatus: async (_args) => null,
+  revokeTokens: async (_types) => void 0,
+  startSilentRenew: () => void 0,
+  stopSilentRenew: () => void 0,
+  user: null,
+  isLoading: false,
+  isAuthenticated: false,
+  activeNavigator: void 0,
+  error: void 0
+};
 function isZeroConfig(props) {
   return "authority" in props && "clientId" in props;
 }
 var KeycloakProvider = (props) => {
   const { children, debug = false } = props;
+  const status = react.useMemo(() => {
+    const enabledFlag = props.enabled ?? true;
+    const hasAuthority = isZeroConfig(props) ? Boolean(props.authority) : Boolean(props.config.authority);
+    const hasClientId = isZeroConfig(props) ? Boolean(props.clientId) : Boolean(props.config.clientId);
+    return {
+      isEnabled: enabledFlag,
+      isConfigured: hasAuthority && hasClientId,
+      reason: !enabledFlag ? "disabled" : !hasAuthority || !hasClientId ? "missing-config" : void 0
+    };
+  }, [props]);
+  const effectiveEnabled = status.isEnabled && status.isConfigured;
+  react.useEffect(() => {
+    if (!effectiveEnabled && props.tokenBridge) {
+      props.tokenBridge.setToken(null);
+    }
+  }, [effectiveEnabled, props.tokenBridge]);
+  if (!effectiveEnabled) {
+    return /* @__PURE__ */ jsxRuntime.jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsxRuntime.jsx(reactOidcContext.AuthContext.Provider, { value: disabledAuthContext, children: /* @__PURE__ */ jsxRuntime.jsx(StorageConfigProvider, { storageType: "session", children }) }) });
+  }
   const config = isZeroConfig(props) ? buildZeroConfig(props) : props.config;
   const oidcConfig = KeycloakConfigBuilder.build(config);
   const log = react.useCallback(
@@ -892,7 +1074,7 @@ var KeycloakProvider = (props) => {
   }, [log]);
   const showSessionMonitor = config.features?.sessionMonitor !== false;
   const storageType = config.advanced?.storageType || "session";
-  return /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ jsxRuntime.jsx(KeycloakStatusProvider, { value: status, children: /* @__PURE__ */ jsxRuntime.jsx(
     reactOidcContext.AuthProvider,
     {
       ...oidcConfig,
@@ -900,11 +1082,12 @@ var KeycloakProvider = (props) => {
       onSignoutCallback,
       onRemoveUser,
       children: /* @__PURE__ */ jsxRuntime.jsx(StorageConfigProvider, { storageType, children: /* @__PURE__ */ jsxRuntime.jsxs(TokenLifecycleManager, { config, debug, children: [
+        props.tokenBridge && /* @__PURE__ */ jsxRuntime.jsx(TokenBridgeSync, { bridge: props.tokenBridge }),
         showSessionMonitor && /* @__PURE__ */ jsxRuntime.jsx(SessionMonitor, {}),
         children
       ] }) })
     }
-  );
+  ) });
 };
 function buildZeroConfig(props) {
   const { authority, clientId, preset = "default", config: overrides = {} } = props;
@@ -1612,13 +1795,18 @@ exports.CONFIG_PRESETS = CONFIG_PRESETS;
 exports.DeviceLogin = DeviceLogin;
 exports.KeycloakConfigBuilder = KeycloakConfigBuilder;
 exports.KeycloakProvider = KeycloakProvider;
+exports.KeycloakStatusProvider = KeycloakStatusProvider;
 exports.LoginButton = LoginButton;
 exports.LogoutButton = LogoutButton;
 exports.ProtectedRoute = ProtectedRoute;
 exports.SessionMonitor = SessionMonitor;
+exports.TokenBridge = TokenBridge;
+exports.TokenBridgeSync = TokenBridgeSync;
 exports.TokenLifecycleManager = TokenLifecycleManager;
 exports.UserProfile = UserProfile;
+exports.createTokenBridge = createTokenBridge;
 exports.defaultConfig = defaultConfig;
+exports.defaultTokenBridge = defaultTokenBridge;
 exports.fetchUserInfo = fetchUserInfo;
 exports.getConfigFromEnv = getConfigFromEnv;
 exports.getConfigPreset = getConfigPreset;
@@ -1626,6 +1814,7 @@ exports.mergeWithPreset = mergeWithPreset;
 exports.pollForToken = pollForToken;
 exports.requestDeviceCode = requestDeviceCode;
 exports.useAuth = useAuth;
+exports.useKeycloakStatus = useKeycloakStatus;
 exports.useProtectedFetch = useProtectedFetch;
 exports.useRoles = useRoles;
 exports.useScopes = useScopes;