Function SessionProvider

packages/auth-client/src/client/index.tsx:365–505

(props: SessionProviderProps)

 *
 */
export function SessionProvider(props: SessionProviderProps) {
  if (!SessionContext) {
    throw new Error('React Context is unavailable in Server Components');
  }

  const { children, basePath, refetchInterval, refetchWhenOffline } = props;

  if (basePath) __LINEN_AUTH.basePath = basePath;

  /**
   * If session was `null`, there was an attempt to fetch it,
   * but it failed, but we still treat it as a valid initial value.
   */
  const hasInitialSession = props.session !== undefined;

  /** If session was passed, initialize as already synced */
  __LINEN_AUTH._lastSync = hasInitialSession ? now() : 0;

  const [session, setSession] = React.useState(() => {
    if (hasInitialSession) __LINEN_AUTH._session = props.session;
    return props.session;
  });

  /** If session was passed, initialize as not loading */
  const [loading, setLoading] = React.useState(!hasInitialSession);

  React.useEffect(() => {
    __LINEN_AUTH._getSession = async ({ event }: any = {}) => {
      try {
        const storageEvent = event === 'storage';
        // We should always update if we don't have a client session yet
        // or if there are events from other tabs/windows
        if (storageEvent || __LINEN_AUTH._session === undefined) {
          __LINEN_AUTH._lastSync = now();
          __LINEN_AUTH._session = await getSession({
            broadcast: !storageEvent,
          });
          setSession(__LINEN_AUTH._session);
          return;
        }

        if (
          // If there is no time defined for when a session should be considered
          // stale, then it's okay to use the value we have until an event is
          // triggered which updates it
          !event ||
          // If the client doesn't have a session then we don't need to call
          // the server to check if it does (if they have signed in via another
          // tab or window that will come through as a "storage" event
          // event anyway)
          __LINEN_AUTH._session === null ||
          // Bail out early if the client session is not stale yet
          now() < __LINEN_AUTH._lastSync
        ) {
          return;
        }

        // An event or session staleness occurred, update the client session.