@payloadcms/ui 4.0.0-internal.2fddfc0 → 4.0.0-internal.314c594

package/dist/providers/Auth/index.d.ts

@@ -1,68 +1,12 @@
-import type { ClientUser, SanitizedPermissions, TypedUser } from 'payload';
+import type { AuthenticatedUser, SanitizedPermissions } from 'payload';
 import React from 'react';
-export type UserWithToken<T = ClientUser> = {
-    /** seconds until expiration */
-    exp: number;
-    refreshedToken?: string;
-    token?: string;
-    user: T;
-};
-export type AuthContext<T = ClientUser> = {
-    fetchFullUser: () => Promise<null | TypedUser>;
-    logOut: (options?: {
-        collection?: string;
-    }) => Promise<boolean>;
-    /**
-     * These are the permissions for the current user from a global scope.
-     *
-     * When checking for permissions on document specific level, use the `useDocumentInfo` hook instead.
-     *
-     * @example
-     *
-     * ```tsx
-     * import { useAuth } from 'payload/ui'
-     *
-     * const MyComponent: React.FC = () => {
-     *   const { permissions } = useAuth()
-     *
-     *   if (permissions?.collections?.myCollection?.create) {
-     *     // user can create documents in 'myCollection'
-     *   }
-     *
-     *   return null
-     * }
-     * ```
-     *
-     * with useDocumentInfo:
-     *
-     * ```tsx
-     * import { useDocumentInfo } from 'payload/ui'
-     *
-     * const MyComponent: React.FC = () => {
-     *  const { docPermissions } = useDocumentInfo()
-     *  if (docPermissions?.create) {
-     *   // user can create this document
-     *  }
-     *  return null
-     * } ```
-     */
-    permissions?: SanitizedPermissions;
-    refreshCookie: (forceRefresh?: boolean) => void;
-    refreshCookieAsync: () => Promise<ClientUser>;
-    refreshPermissions: () => Promise<void>;
-    setPermissions: (permissions: SanitizedPermissions) => void;
-    setUser: (user: null | UserWithToken<T>) => void;
-    strategy?: string;
-    token?: string;
-    tokenExpirationMs?: number;
-    user?: null | T;
-};
+import type { AuthContext } from './types.js';
+export type { AuthContext, AuthSession, UserWithToken } from './types.js';
 type Props = {
     children: React.ReactNode;
     permissions?: SanitizedPermissions;
-    user?: ClientUser | null;
+    user?: AuthenticatedUser | null;
 };
 export declare function AuthProvider({ children, permissions: initialPermissions, user: initialUser, }: Props): React.JSX.Element;
-export declare const useAuth: <T = ClientUser>() => AuthContext<T>;
-export {};
+export declare const useAuth: <T = AuthenticatedUser>() => AuthContext<T>;
 //# sourceMappingURL=index.d.ts.map

package/dist/providers/Auth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/Auth/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAK1E,OAAO,KAA+D,MAAM,OAAO,CAAA;AAWnF,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,UAAU,IAAI;IAC1C,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,CAAC,CAAA;CACR,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,UAAU,IAAI;IACxC,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAAA;IAC9C,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAA;IAClC,aAAa,EAAE,CAAC,YAAY,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;IAC/C,kBAAkB,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAA;IAC7C,kBAAkB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACvC,cAAc,EAAE,CAAC,WAAW,EAAE,oBAAoB,KAAK,IAAI,CAAA;IAC3D,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,IAAI,CAAC,EAAE,IAAI,GAAG,CAAC,CAAA;CAChB,CAAA;AAMD,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,WAAW,CAAC,EAAE,oBAAoB,CAAA;IAClC,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CACzB,CAAA;AAED,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,WAAW,GAClB,EAAE,KAAK,qBAyUP;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,UAAU,OAAM,WAAW,CAAC,CAAC,CAAmC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/Auth/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAKtE,OAAO,KAA+D,MAAM,OAAO,CAAA;AAInF,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,YAAY,CAAA;AAczE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAIzE,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,WAAW,CAAC,EAAE,oBAAoB,CAAA;IAClC,IAAI,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAChC,CAAA;AAsBD,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,WAAW,GAClB,EAAE,KAAK,qBAodP;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,GAAG,iBAAiB,OAAM,WAAW,CAAC,CAAC,CAAmC,CAAA"}

package/dist/providers/Auth/index.js

@@ -11,10 +11,13 @@ import { useEffectEvent } from '../../hooks/useEffectEvent.js';
 import { useTranslation } from '../../providers/Translation/index.js';
 import { requests } from '../../utilities/api.js';
 import { useConfig } from '../Config/index.js';
-import { usePathname, useRouter } from '../RouterAdapter/index.js';
+import { usePathname, useRouter, useSearchParams } from '../RouterAdapter/index.js';
 import { useRouteTransition } from '../RouteTransition/index.js';
+import { createAuthSessionRequests } from './authSessionRequests.js';
+import { TAB_SESSION_EVENT_TYPES } from './tabSessionSync/index.js';
+import { useTabSessionSync } from './tabSessionSync/useTabSessionSync.js';
+import { useAuthSessionTimers } from './useAuthSessionTimers.js';
 const Context = /*#__PURE__*/createContext({});
-const maxTimeoutMs = 2147483647;
 export function AuthProvider({
   children,
   permissions: initialPermissions,
@@ -22,6 +25,8 @@ export function AuthProvider({
 }) {
   const pathname = usePathname();
   const router = useRouter();
+  const searchParams = useSearchParams();
+  const route = `${pathname}?${searchParams.toString()}`;
   const {
     config
   } = useConfig();
@@ -30,7 +35,8 @@ export function AuthProvider({
       autoLogin,
       autoRefresh,
       routes: {
-        inactivity: logoutInactivityRoute
+        inactivity: logoutInactivityRoute,
+        login: loginRoute
       },
       user: userSlug
     },
@@ -51,14 +57,12 @@ export function AuthProvider({
   } = useRouteTransition();
   const [user, setUserInMemory] = useState(initialUser);
   const [tokenInMemory, setTokenInMemory] = useState();
-  const [tokenExpirationMs, setTokenExpirationMs] = useState();
+  const [authSession, setAuthSession] = useState();
   const [permissions, setPermissions] = useState(initialPermissions);
-  const [forceLogoutBufferMs, setForceLogoutBufferMs] = useState(120_000);
   const [fetchedUserOnMount, setFetchedUserOnMount] = useState(false);
-  const refreshTokenTimeoutRef = React.useRef(null);
-  const reminderTimeoutRef = React.useRef(null);
-  const forceLogOutTimeoutRef = React.useRef(null);
-  const id = user?.id;
+  const [authRequests] = useState(createAuthSessionRequests);
+  const userRef = React.useRef(initialUser);
+  const isAuthenticated = Boolean(user);
   const redirectToInactivityRoute = useCallback(() => {
     const baseAdminRoute = formatAdminURL({
       adminRoute,
@@ -70,116 +74,221 @@ export function AuthProvider({
     })));
     closeAllModals();
   }, [router, adminRoute, logoutInactivityRoute, closeAllModals, startRouteTransition]);
-  const revokeTokenAndExpire = useCallback(() => {
-    setUserInMemory(null);
-    setTokenInMemory(undefined);
-    setTokenExpirationMs(undefined);
-    clearTimeout(refreshTokenTimeoutRef.current);
-  }, []);
-  // Handler for reminder timeout - uses useEffectEvent to capture latest autoRefresh value
-  const handleReminderTimeout = useEffectEvent(() => {
+  const redirectToLoginRoute = useCallback(() => {
+    startRouteTransition(() => router.replace(formatAdminURL({
+      adminRoute,
+      path: loginRoute
+    })));
+    closeAllModals();
+  }, [adminRoute, closeAllModals, loginRoute, router, startRouteTransition]);
+  function onSessionActivity() {
+    setAuthSession(currentAuthSession => {
+      if (!currentAuthSession || currentAuthSession.activityRecorded) {
+        return currentAuthSession;
+      }
+      return {
+        ...currentAuthSession,
+        activityRecorded: true
+      };
+    });
+  }
+  function onSessionActivityRefresh() {
+    void refreshSession({
+      isActivityRefresh: true
+    });
+  }
+  function onSessionExpiration(expirationMs) {
+    const collection = userRef.current?.collection;
+    tabSessionSync.broadcast({
+      type: TAB_SESSION_EVENT_TYPES.EXPIRED,
+      expiredTokenAt: expirationMs
+    });
+    void logOutSession({
+      collection
+    }).then(redirectToInactivityRoute);
+  }
+  function onSessionReminder() {
     if (autoRefresh) {
-      refreshCookieEvent();
+      sessionTimers.scheduleRefresh();
     } else {
       openModal(stayLoggedInModalSlug);
     }
+  }
+  const sessionTimers = useAuthSessionTimers({
+    isAuthenticated,
+    onActivity: onSessionActivity,
+    onActivityRefresh: onSessionActivityRefresh,
+    onExpire: onSessionExpiration,
+    onReminder: onSessionReminder
   });
-  const setNewUser = useCallback(userResponse => {
-    clearTimeout(reminderTimeoutRef.current);
-    clearTimeout(forceLogOutTimeoutRef.current);
-    if (userResponse?.user) {
-      setUserInMemory(userResponse.user);
-      setTokenInMemory(userResponse.token ?? userResponse.refreshedToken);
-      setTokenExpirationMs(userResponse.exp * 1000);
-      const expiresInMs = Math.max(0, Math.min((userResponse.exp ?? 0) * 1000 - Date.now(), maxTimeoutMs));
-      if (expiresInMs) {
-        const nextForceLogoutBufferMs = Math.min(60_000, expiresInMs / 2);
-        setForceLogoutBufferMs(nextForceLogoutBufferMs);
-        reminderTimeoutRef.current = setTimeout(handleReminderTimeout, Math.max(expiresInMs - nextForceLogoutBufferMs, 0));
-        forceLogOutTimeoutRef.current = setTimeout(() => {
-          revokeTokenAndExpire();
-          redirectToInactivityRoute();
-        }, expiresInMs);
+  useEffect(() => {
+    sessionTimers.recordActivity('route');
+  }, [route, sessionTimers]);
+  const clearUserInMemory = useCallback(() => {
+    userRef.current = null;
+    setUserInMemory(null);
+    setTokenInMemory(undefined);
+    setAuthSession(undefined);
+    sessionTimers.clear();
+  }, [sessionTimers]);
+  const setLocalSession = useCallback(session => {
+    if (session?.user) {
+      const expirationMs_0 = typeof session.exp === 'number' && Number.isFinite(session.exp) ? session.exp * 1000 : undefined;
+      const nextSessionTiming = expirationMs_0 !== undefined ? sessionTimers.setExpiration(expirationMs_0) : undefined;
+      userRef.current = session.user;
+      setUserInMemory(session.user);
+      setTokenInMemory(session.token ?? session.refreshedToken);
+      if (nextSessionTiming) {
+        setAuthSession({
+          ...nextSessionTiming,
+          activityRecorded: false
+        });
       }
     } else {
-      revokeTokenAndExpire();
+      clearUserInMemory();
     }
-  }, [redirectToInactivityRoute, revokeTokenAndExpire]);
-  const refreshCookie = useCallback(forceRefresh => {
-    if (!id) {
-      return;
+  }, [clearUserInMemory, sessionTimers]);
+  const setUser = useCallback(session_0 => {
+    authRequests.discardPendingResults();
+    setLocalSession(session_0);
+  }, [authRequests, setLocalSession]);
+  const tabSessionSync = useTabSessionSync({
+    getTokenExpirationMs: sessionTimers.getCurrentExpirationMs,
+    onSessionExpired: () => {
+      const collection_0 = userRef.current?.collection;
+      void logOutSession({
+        collection: collection_0
+      }).then(redirectToInactivityRoute);
+    },
+    onSessionLoggedOut: () => {
+      const collection_1 = userRef.current?.collection;
+      void logOutSession({
+        collection: collection_1
+      }).then(redirectToLoginRoute);
+    },
+    onSessionRefreshed: session_1 => {
+      if (!authRequests.isLoggingOut()) {
+        authRequests.discardPendingResults();
+        setLocalSession(session_1);
+      }
+    },
+    onTabSessionUnauthenticated: () => {
+      redirectToInactivityRoute();
+    },
+    reconcileSession: async options => {
+      const result = await fetchFullUserResult(options);
+      if (result.status === 'authenticated' && result.expirationMs !== undefined) {
+        return {
+          expirationMs: result.expirationMs,
+          status: result.status,
+          user: result.user
+        };
+      }
+      if (result.status === 'unauthenticated') {
+        return result;
+      }
+      return {
+        status: 'indeterminate'
+      };
     }
-    const expiresInMs_0 = Math.max(0, (tokenExpirationMs ?? 0) - Date.now());
-    if (forceRefresh || tokenExpirationMs && expiresInMs_0 < forceLogoutBufferMs * 2) {
-      clearTimeout(refreshTokenTimeoutRef.current);
-      refreshTokenTimeoutRef.current = setTimeout(async () => {
-        try {
-          const request = await requests.post(formatAdminURL({
-            apiRoute,
-            path: `/${userSlug}/refresh-token?refresh`
-          }), {
-            headers: {
-              'Accept-Language': i18n.language
-            }
-          });
-          if (request.status === 200) {
-            const json = await request.json();
-            setNewUser(json);
-          } else {
-            setNewUser(null);
-            redirectToInactivityRoute();
+  });
+  const refreshSession = useCallback(({
+    isActivityRefresh
+  }) => {
+    return authRequests.refresh(async ({
+      acceptResult,
+      invalidateWhenIdle,
+      isResultStale
+    }) => {
+      if (isResultStale()) {
+        return null;
+      }
+      const handledExpiration = sessionTimers.getCurrentExpirationMs();
+      const handledUser = userRef.current;
+      try {
+        const refreshStartedAt = Date.now();
+        const request = await requests.post(formatAdminURL({
+          apiRoute,
+          path: `/${userSlug}/refresh-token${isActivityRefresh ? '?refresh' : ''}`
+        }), {
+          headers: {
+            'Accept-Language': i18n.language
           }
-        } catch (e) {
-          toast.error(e.message);
+        });
+        if (isResultStale()) {
+          return null;
         }
-      }, 1000);
-    }
-  }, [apiRoute, i18n.language, redirectToInactivityRoute, setNewUser, tokenExpirationMs, userSlug, forceLogoutBufferMs, id]);
-  const refreshCookieAsync = useCallback(async skipSetUser => {
-    try {
-      const request_0 = await requests.post(formatAdminURL({
-        apiRoute,
-        path: `/${userSlug}/refresh-token`
-      }), {
-        headers: {
-          'Accept-Language': i18n.language
+        if (request.status === 200) {
+          const json = await request.json();
+          if (!acceptResult()) {
+            return null;
+          }
+          setLocalSession(json);
+          tabSessionSync.broadcast({
+            type: TAB_SESSION_EVENT_TYPES.REFRESHED,
+            refreshStartedAt,
+            session: json
+          });
+          return json.user;
         }
-      });
-      if (request_0.status === 200) {
-        const json_0 = await request_0.json();
-        if (!skipSetUser) {
-          setNewUser(json_0);
+        if (handledUser) {
+          const invalidateSession = () => {
+            if (handledExpiration !== undefined) {
+              tabSessionSync.broadcast({
+                type: TAB_SESSION_EVENT_TYPES.EXPIRED,
+                expiredTokenAt: handledExpiration
+              });
+            }
+            setLocalSession(null);
+            redirectToInactivityRoute();
+          };
+          invalidateWhenIdle(invalidateSession);
         }
-        return json_0.user;
+      } catch (e) {
+        toast.error(`Refreshing token failed: ${e.message}`);
       }
-      if (user) {
-        setNewUser(null);
-        redirectToInactivityRoute();
-      }
-    } catch (e_0) {
-      toast.error(`Refreshing token failed: ${e_0.message}`);
-    }
-    return null;
-  }, [apiRoute, i18n.language, redirectToInactivityRoute, setNewUser, userSlug, user]);
-  const logOut = useCallback(async options => {
-    // The current client user is the default target. Callers may pass an
-    // explicit collection to log out when the client auth state has already
-    // been cleared (e.g. the logout view for a non-admin user, whose `/me`
-    // against the admin collection resolves to `null`).
-    const collection = user?.collection ?? options?.collection;
-    try {
-      if (collection) {
-        setNewUser(null);
-        await requests.post(formatAdminURL({
-          apiRoute,
-          path: `/${collection}/logout`
-        }));
+      return null;
+    });
+  }, [apiRoute, authRequests, tabSessionSync, i18n.language, redirectToInactivityRoute, sessionTimers, setLocalSession, userSlug]);
+  const refreshCookieAsync = useCallback(() => refreshSession({
+    isActivityRefresh: false
+  }), [refreshSession]);
+  const logOutSession = useCallback(({
+    collection: collection_2
+  }) => {
+    return authRequests.logOut({
+      clearSession: () => {
+        authRequests.discardPendingResults();
+        setLocalSession(null);
+      },
+      request: async () => {
+        try {
+          if (collection_2) {
+            await requests.post(formatAdminURL({
+              apiRoute,
+              path: `/${collection_2}/logout`
+            }));
+          }
+        } catch (_) {
+          // Explicit logout always clears local state, even if server revocation fails.
+        }
       }
-    } catch (_) {
-      // fail silently and log the user out in state
+    });
+  }, [apiRoute, authRequests, setLocalSession]);
+  const logOut = useCallback(async () => {
+    const logoutEvent = {
+      type: TAB_SESSION_EVENT_TYPES.LOGGED_OUT
+    };
+    const logoutPublication = tabSessionSync.broadcast(logoutEvent);
+    const collection_3 = userRef.current?.collection;
+    await logOutSession({
+      collection: collection_3
+    });
+    if (logoutPublication?.type === TAB_SESSION_EVENT_TYPES.LOGGED_OUT) {
+      tabSessionSync.broadcastLogoutSettlement(logoutPublication);
     }
     return true;
-  }, [apiRoute, setNewUser, user]);
+  }, [tabSessionSync, logOutSession]);
   const refreshPermissions = useCallback(async ({
     locale
   } = {}) => {
@@ -189,7 +298,7 @@ export function AuthProvider({
       addQueryPrefix: true
     });
     try {
-      const request_1 = await requests.get(formatAdminURL({
+      const request_0 = await requests.get(formatAdminURL({
         apiRoute,
         path: `/access${params}`
       }), {
@@ -197,42 +306,79 @@ export function AuthProvider({
           'Accept-Language': i18n.language
         }
       });
-      if (request_1.status === 200) {
-        const json_1 = await request_1.json();
-        setPermissions(json_1);
+      if (request_0.status === 200) {
+        const json_0 = await request_0.json();
+        setPermissions(json_0);
       } else {
-        throw new Error(`Fetching permissions failed with status code ${request_1.status}`);
+        throw new Error(`Fetching permissions failed with status code ${request_0.status}`);
       }
-    } catch (e_1) {
-      toast.error(`Refreshing permissions failed: ${e_1.message}`);
+    } catch (e_0) {
+      toast.error(`Refreshing permissions failed: ${e_0.message}`);
     }
   }, [apiRoute, i18n]);
-  const fetchFullUser = React.useCallback(async () => {
-    try {
-      const request_2 = await requests.get(formatAdminURL({
-        apiRoute,
-        path: `/${userSlug}/me`
-      }), {
-        credentials: 'include',
-        headers: {
-          'Accept-Language': i18n.language
+  const fetchFullUserResult = React.useCallback(({
+    isTabSessionEventStale
+  } = {}) => {
+    return authRequests.queue(async ({
+      acceptResult: acceptResult_0,
+      isResultStale: isResultStale_0
+    }) => {
+      const isResponseStale = () => isResultStale_0() || Boolean(isTabSessionEventStale?.());
+      if (isResponseStale()) {
+        return {
+          status: 'indeterminate'
+        };
+      }
+      try {
+        const request_1 = await requests.get(formatAdminURL({
+          apiRoute,
+          path: `/${userSlug}/me`
+        }), {
+          credentials: 'include',
+          headers: {
+            'Accept-Language': i18n.language
+          }
+        });
+        if (request_1.status !== 200) {
+          return {
+            status: 'indeterminate'
+          };
         }
-      });
-      if (request_2.status === 200) {
-        const json_2 = await request_2.json();
-        setNewUser(json_2);
-        return json_2?.user || null;
+        const json_1 = await request_1.json();
+        if (isResponseStale()) {
+          return {
+            status: 'indeterminate'
+          };
+        }
+        if (json_1?.user) {
+          if (!acceptResult_0()) {
+            return {
+              status: 'indeterminate'
+            };
+          }
+          setLocalSession(json_1);
+          return {
+            expirationMs: typeof json_1.exp === 'number' && Number.isFinite(json_1.exp) ? json_1.exp * 1000 : sessionTimers.getCurrentExpirationMs(),
+            status: 'authenticated',
+            user: json_1.user
+          };
+        }
+        setLocalSession(null);
+        return {
+          status: 'unauthenticated'
+        };
+      } catch (e_1) {
+        toast.error(`Fetching user failed: ${e_1.message}`);
       }
-    } catch (e_2) {
-      toast.error(`Fetching user failed: ${e_2.message}`);
-    }
-    return null;
-  }, [apiRoute, userSlug, i18n.language, setNewUser]);
-  const refreshCookieEvent = useEffectEvent(refreshCookie);
-  useEffect(() => {
-    // when location changes, refresh cookie
-    refreshCookieEvent();
-  }, [pathname]);
+      return {
+        status: 'indeterminate'
+      };
+    });
+  }, [apiRoute, authRequests, i18n.language, sessionTimers, setLocalSession, userSlug]);
+  const fetchFullUser = React.useCallback(async () => {
+    const result_0 = await fetchFullUserResult();
+    return result_0.status === 'authenticated' ? result_0.user : null;
+  }, [fetchFullUserResult]);
   const fetchFullUserEvent = useEffectEvent(fetchFullUser);
   useEffect(() => {
     async function fetchUserOnMount() {
@@ -247,26 +393,23 @@ export function AuthProvider({
     }
   }, [user, autoLogin]);
   useEffect(() => () => {
-    // remove all timeouts on unmount
-    clearTimeout(refreshTokenTimeoutRef.current);
-    clearTimeout(reminderTimeoutRef.current);
-    clearTimeout(forceLogOutTimeoutRef.current);
-  }, []);
+    authRequests.discardPendingResults();
+  }, [authRequests]);
   if (!user && !fetchedUserOnMount) {
     return null;
   }
   return /*#__PURE__*/_jsx(Context, {
     value: {
+      authSession,
       fetchFullUser,
       logOut,
       permissions,
-      refreshCookie,
+      refreshCookie: sessionTimers.scheduleRefresh,
       refreshCookieAsync,
       refreshPermissions,
       setPermissions,
-      setUser: setNewUser,
+      setUser,
       token: tokenInMemory,
-      tokenExpirationMs,
       user
     },
     children: children