@civic/auth 0.0.1-beta.18 → 0.0.1-beta.2

package/dist/react.d.ts

@@ -1,10 +1,20 @@
-import { U as UserContextType, A as AuthContextType } from './index-DTimUlkB.js';
-import { F as ForwardedTokens, C as Config, S as SessionData, b as EmptyObject, U as User, D as DisplayMode } from './types-HdCjGldB.js';
-import { O as OAuthTokens } from './types-b4c1koXj.js';
-import { ReactNode, RefObject, Dispatch, SetStateAction } from 'react';
+import { JWT } from 'oslo/jwt';
+import { D as DisplayMode, U as User, F as ForwardedTokens, A as AuthSessionService, E as Endpoints, b as UserInfoService, S as SessionData, a as UnknownObject, O as OIDCTokenResponseBody, P as ParsedTokens, C as Config } from './index-DoDoIY_K.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import 'oslo/jwt';
-import 'oslo/oauth2';
+import { ReactNode } from 'react';
+import { OAuth2Client } from 'oslo/oauth2';
+
+type AuthContextType = {
+    signIn: (displayMode?: DisplayMode) => Promise<void>;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    signOut: () => Promise<void>;
+};
+
+type UserContextType$1<T extends Record<string, unknown> & JWT["payload"] = Record<string, unknown> & JWT["payload"]> = {
+    user: User<T> | null;
+} & Omit<AuthContextType, "isAuthenticated">;
 
 type TokenContextType = {
     accessToken: string | null;
@@ -15,8 +25,45 @@ type TokenContextType = {
     error: Error | null;
 };
 
-interface PKCEConsumer {
-    getCodeChallenge(): Promise<string>;
+declare class AuthSessionServiceImpl implements AuthSessionService {
+    readonly clientId: string;
+    readonly redirectUrl: string;
+    readonly oauthServer: string;
+    readonly inputEndpoints?: Partial<Endpoints> | undefined;
+    private endpoints;
+    private oauth2Client;
+    private userInfoService;
+    private codeVerifier;
+    private refreshTokenTimeout;
+    constructor(clientId: string, redirectUrl: string, oauthServer: string, inputEndpoints?: Partial<Endpoints> | undefined);
+    protected getCodeVerifier(): string;
+    getUserInfoService(): Promise<UserInfoService>;
+    protected getEndpoints(): Promise<Endpoints>;
+    protected getOauth2Client(): Promise<OAuth2Client>;
+    getSessionData(): SessionData;
+    updateSessionData(data: Partial<SessionData>): void;
+    getUser(): User<UnknownObject> | null;
+    setUser(data: User<UnknownObject> | null): void;
+    clearSessionData(): void;
+    getAuthorizationUrlWithChallenge(state: string, scopes: string[]): Promise<URL>;
+    getAuthorizationUrl(scopes: string[], displayMode: DisplayMode, nonce?: string): Promise<string>;
+    loadAuthorizationUrl(authorizationURL: string, displayMode: DisplayMode): void;
+    init(): Promise<this>;
+    logout(): Promise<void>;
+    determineDisplayMode(displayMode: DisplayMode): DisplayMode;
+    signIn(displayMode: DisplayMode, scopes: string[], nonce: string): Promise<void>;
+    tokenExchange(responseUrl: string): Promise<SessionData>;
+    private setupTokenRefresh;
+    refreshToken(): Promise<SessionData>;
+    getUserInfo<T extends UnknownObject>(): Promise<User<T> | null>;
+    /**
+     * Uses the jose library to validate a JWT token using the OAuth JWKS endpoint
+     * @returns {Promise<jose.JWTPayload>}
+     * @throws {Error} if the token is invalid
+     * @param tokens
+     */
+    validateTokens(tokens: OIDCTokenResponseBody): Promise<ParsedTokens>;
+    validateExistingSession(): Promise<SessionData>;
 }
 
 type AuthProviderProps = {
@@ -27,20 +74,23 @@ type AuthProviderProps = {
     config?: Config;
     onSignIn?: (error?: Error) => void;
     onSignOut?: () => void;
-    pkceConsumer?: PKCEConsumer;
-    modalIframe?: boolean;
-    sessionData?: SessionData;
+    authServiceImpl?: AuthSessionServiceImpl;
+    serverSideTokenExchange?: boolean;
 };
 
-type CivicAuthProviderProps = Omit<AuthProviderProps, "pkceConsumer">;
+type CivicAuthProviderProps = Omit<AuthProviderProps, "authServiceImpl" | "serverSideTokenExchange">;
 declare const CivicAuthProvider: ({ children, ...props }: CivicAuthProviderProps) => react_jsx_runtime.JSX.Element;
 
+type UserContextType = {
+    user: User<UnknownObject> | null;
+};
 type NextCivicAuthProviderProps = Omit<AuthProviderProps, "clientId">;
 declare const CivicNextAuthProvider: ({ children, ...props }: NextCivicAuthProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useNextUser: () => UserContextType;
 
-declare const useUser: <T extends Record<string, unknown> = Record<string, never>>() => UserContextType<T>;
+declare const useUser: <T extends Record<string, unknown> = Record<string, never>>() => UserContextType$1<T>;
 
-declare const useUserCookie: <T extends EmptyObject>() => User<T> | null;
+declare const useUserCookie: () => any;
 
 declare const useToken: () => TokenContextType;
 
@@ -48,30 +98,6 @@ declare const useAuth: () => AuthContextType;
 
 declare const useSession: () => SessionData;
 
-type ConfigProviderOutput = {
-    config: Config;
-    redirectUrl: string;
-    modalIframe: boolean;
-    serverTokenExchange: boolean;
-};
-
-declare const useConfig: () => ConfigProviderOutput;
-
-declare const useTokenCookie: (tokenName: OAuthTokens) => string | null;
-
-type IframeProviderOutput = {
-    iframeRef: RefObject<HTMLIFrameElement> | null;
-    setAuthResponseUrl: Dispatch<SetStateAction<string | null>>;
-};
-
-declare const useIframe: () => IframeProviderOutput;
-
-type CivicAuthIframeContainerProps = {
-    onClose?: () => void;
-    closeOnRedirect?: boolean;
-};
-declare const CivicAuthIframeContainer: ({ onClose, closeOnRedirect, }: CivicAuthIframeContainerProps) => react_jsx_runtime.JSX.Element;
-
 declare const UserButton: ({ displayMode, className, }: {
     displayMode?: DisplayMode;
     className?: string;
@@ -90,4 +116,4 @@ declare const NextLogOut: ({ children }: {
     children: ReactNode;
 }) => react_jsx_runtime.JSX.Element;
 
-export { AuthContextType, CivicAuthIframeContainer, CivicAuthProvider, type CivicAuthProviderProps, CivicNextAuthProvider, type NextCivicAuthProviderProps, NextLogOut, SignInButton, SignOutButton, type TokenContextType, UserButton, UserContextType, useAuth, useConfig, useIframe, useSession, useToken, useTokenCookie, useUser, useUserCookie };
+export { type AuthContextType, CivicAuthProvider, CivicNextAuthProvider, NextLogOut, SignInButton, SignOutButton, type TokenContextType, UserButton, type UserContextType$1 as UserContextType, useAuth, useNextUser, useSession, useToken, useUser, useUserCookie };