@auth0/auth0-angular 2.2.3 → 2.4.0

package/esm2022/lib/auth.service.mjs

@@ -0,0 +1,296 @@
+import { Injectable, Inject } from '@angular/core';
+import { of, from, Subject, iif, defer, ReplaySubject, throwError, } from 'rxjs';
+import { concatMap, tap, map, takeUntil, catchError, switchMap, withLatestFrom, } from 'rxjs/operators';
+import { Auth0ClientService } from './auth.client';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.config";
+import * as i2 from "./abstract-navigator";
+import * as i3 from "./auth.state";
+import * as i4 from "@auth0/auth0-spa-js";
+export class AuthService {
+    constructor(auth0Client, configFactory, navigator, authState) {
+        this.auth0Client = auth0Client;
+        this.configFactory = configFactory;
+        this.navigator = navigator;
+        this.authState = authState;
+        this.appStateSubject$ = new ReplaySubject(1);
+        // https://stackoverflow.com/a/41177163
+        this.ngUnsubscribe$ = new Subject();
+        /**
+         * Emits boolean values indicating the loading state of the SDK.
+         */
+        this.isLoading$ = this.authState.isLoading$;
+        /**
+         * Emits boolean values indicating the authentication state of the user. If `true`, it means a user has authenticated.
+         * This depends on the value of `isLoading$`, so there is no need to manually check the loading state of the SDK.
+         */
+        this.isAuthenticated$ = this.authState.isAuthenticated$;
+        /**
+         * Emits details about the authenticated user, or null if not authenticated.
+         */
+        this.user$ = this.authState.user$;
+        /**
+         * Emits ID token claims when authenticated, or null if not authenticated.
+         */
+        this.idTokenClaims$ = this.authState.idTokenClaims$;
+        /**
+         * Emits errors that occur during login, or when checking for an active session on startup.
+         */
+        this.error$ = this.authState.error$;
+        /**
+         * Emits the value (if any) that was passed to the `loginWithRedirect` method call
+         * but only **after** `handleRedirectCallback` is first called
+         */
+        this.appState$ = this.appStateSubject$.asObservable();
+        const checkSessionOrCallback$ = (isCallback) => iif(() => isCallback, this.handleRedirectCallback(), defer(() => this.auth0Client.checkSession()));
+        this.shouldHandleCallback()
+            .pipe(switchMap((isCallback) => checkSessionOrCallback$(isCallback).pipe(catchError((error) => {
+            const config = this.configFactory.get();
+            this.navigator.navigateByUrl(config.errorPath || '/');
+            this.authState.setError(error);
+            return of(undefined);
+        }))), tap(() => {
+            this.authState.setIsLoading(false);
+        }), takeUntil(this.ngUnsubscribe$))
+            .subscribe();
+    }
+    /**
+     * Called when the service is destroyed
+     */
+    ngOnDestroy() {
+        // https://stackoverflow.com/a/41177163
+        this.ngUnsubscribe$.next();
+        this.ngUnsubscribe$.complete();
+    }
+    /**
+     * ```js
+     * loginWithRedirect(options);
+     * ```
+     *
+     * Performs a redirect to `/authorize` using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated.
+     *
+     * @param options The login options
+     */
+    loginWithRedirect(options) {
+        return from(this.auth0Client.loginWithRedirect(options));
+    }
+    /**
+     * ```js
+     * await loginWithPopup(options);
+     * ```
+     *
+     * Opens a popup with the `/authorize` URL using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated. If the response is successful,
+     * results will be valid according to their expiration times.
+     *
+     * IMPORTANT: This method has to be called from an event handler
+     * that was started by the user like a button click, for example,
+     * otherwise the popup will be blocked in most browsers.
+     *
+     * @param options The login options
+     * @param config Configuration for the popup window
+     */
+    loginWithPopup(options, config) {
+        return from(this.auth0Client.loginWithPopup(options, config).then(() => {
+            this.authState.refresh();
+        }));
+    }
+    /**
+     * ```js
+     * logout();
+     * ```
+     *
+     * Clears the application session and performs a redirect to `/v2/logout`, using
+     * the parameters provided as arguments, to clear the Auth0 session.
+     * If the `federated` option is specified it also clears the Identity Provider session.
+     * If the `openUrl` option is set to false, it only clears the application session.
+     * It is invalid to set both the `federated` to true and `openUrl` to `false`,
+     * and an error will be thrown if you do.
+     * [Read more about how Logout works at Auth0](https://auth0.com/docs/logout).
+     *
+     * @param options The logout options
+     */
+    logout(options) {
+        return from(this.auth0Client.logout(options).then(() => {
+            if (options?.openUrl === false || options?.openUrl) {
+                this.authState.refresh();
+            }
+        }));
+    }
+    /**
+     * ```js
+     * getAccessTokenSilently(options).subscribe(token => ...)
+     * ```
+     *
+     * If there's a valid token stored, return it. Otherwise, opens an
+     * iframe with the `/authorize` URL using the parameters provided
+     * as arguments. Random and secure `state` and `nonce` parameters
+     * will be auto-generated. If the response is successful, results
+     * will be valid according to their expiration times.
+     *
+     * If refresh tokens are used, the token endpoint is called directly with the
+     * 'refresh_token' grant. If no refresh token is available to make this call,
+     * the SDK falls back to using an iframe to the '/authorize' URL.
+     *
+     * This method may use a web worker to perform the token call if the in-memory
+     * cache is used.
+     *
+     * If an `audience` value is given to this function, the SDK always falls
+     * back to using an iframe to make the token exchange.
+     *
+     * Note that in all cases, falling back to an iframe requires access to
+     * the `auth0` cookie, and thus will not work in browsers that block third-party
+     * cookies by default (Safari, Brave, etc).
+     *
+     * @param options The options for configuring the token fetch.
+     */
+    getAccessTokenSilently(options = {}) {
+        return of(this.auth0Client).pipe(concatMap((client) => options.detailedResponse === true
+            ? client.getTokenSilently({ ...options, detailedResponse: true })
+            : client.getTokenSilently(options)), tap((token) => {
+            if (token) {
+                this.authState.setAccessToken(typeof token === 'string' ? token : token.access_token);
+            }
+        }), catchError((error) => {
+            this.authState.setError(error);
+            this.authState.refresh();
+            return throwError(error);
+        }));
+    }
+    /**
+     * ```js
+     * getTokenWithPopup(options).subscribe(token => ...)
+     * ```
+     *
+     * Get an access token interactively.
+     *
+     * Opens a popup with the `/authorize` URL using the parameters
+     * provided as arguments. Random and secure `state` and `nonce`
+     * parameters will be auto-generated. If the response is successful,
+     * results will be valid according to their expiration times.
+     */
+    getAccessTokenWithPopup(options) {
+        return of(this.auth0Client).pipe(concatMap((client) => client.getTokenWithPopup(options)), tap((token) => {
+            if (token) {
+                this.authState.setAccessToken(token);
+            }
+        }), catchError((error) => {
+            this.authState.setError(error);
+            this.authState.refresh();
+            return throwError(error);
+        }));
+    }
+    /**
+     * ```js
+     * handleRedirectCallback(url).subscribe(result => ...)
+     * ```
+     *
+     * After the browser redirects back to the callback page,
+     * call `handleRedirectCallback` to handle success and error
+     * responses from Auth0. If the response is successful, results
+     * will be valid according to their expiration times.
+     *
+     * Calling this method also refreshes the authentication and user states.
+     *
+     * @param url The URL to that should be used to retrieve the `state` and `code` values. Defaults to `window.location.href` if not given.
+     */
+    handleRedirectCallback(url) {
+        return defer(() => this.auth0Client.handleRedirectCallback(url)).pipe(withLatestFrom(this.authState.isLoading$), tap(([result, isLoading]) => {
+            if (!isLoading) {
+                this.authState.refresh();
+            }
+            const appState = result?.appState;
+            const target = appState?.target ?? '/';
+            if (appState) {
+                this.appStateSubject$.next(appState);
+            }
+            this.navigator.navigateByUrl(target);
+        }), map(([result]) => result));
+    }
+    /**
+     * ```js
+     * getDpopNonce(id).subscribe(nonce => ...)
+     * ```
+     *
+     * Gets the DPoP nonce for the specified domain or the default domain.
+     * The nonce is used in DPoP proof generation for token binding.
+     *
+     * @param id Optional identifier for the domain. If not provided, uses the default domain.
+     * @returns An Observable that emits the DPoP nonce string or undefined if not available.
+     */
+    getDpopNonce(id) {
+        return from(this.auth0Client.getDpopNonce(id));
+    }
+    /**
+     * ```js
+     * setDpopNonce(nonce, id).subscribe(() => ...)
+     * ```
+     *
+     * Sets the DPoP nonce for the specified domain or the default domain.
+     * This is typically used after receiving a new nonce from the authorization server.
+     *
+     * @param nonce The DPoP nonce value to set.
+     * @param id Optional identifier for the domain. If not provided, uses the default domain.
+     * @returns An Observable that completes when the nonce is set.
+     */
+    setDpopNonce(nonce, id) {
+        return from(this.auth0Client.setDpopNonce(nonce, id));
+    }
+    /**
+     * ```js
+     * generateDpopProof(params).subscribe(proof => ...)
+     * ```
+     *
+     * Generates a DPoP (Demonstrating Proof-of-Possession) proof JWT.
+     * This proof is used to bind access tokens to a specific client, providing
+     * an additional layer of security for token usage.
+     *
+     * @param params Configuration for generating the DPoP proof
+     * @param params.url The URL of the resource server endpoint
+     * @param params.method The HTTP method (e.g., 'GET', 'POST')
+     * @param params.nonce Optional DPoP nonce from the authorization server
+     * @param params.accessToken The access token to bind to the proof
+     * @returns An Observable that emits the generated DPoP proof as a JWT string.
+     */
+    generateDpopProof(params) {
+        return from(this.auth0Client.generateDpopProof(params));
+    }
+    /**
+     * ```js
+     * const fetcher = createFetcher(config);
+     * ```
+     *
+     * Creates a custom fetcher instance that can be used to make authenticated
+     * HTTP requests. The fetcher automatically handles token refresh and can
+     * be configured with custom request/response handling.
+     *
+     * @param config Optional configuration for the fetcher
+     * @returns A Fetcher instance configured with the Auth0 client.
+     */
+    createFetcher(config) {
+        return this.auth0Client.createFetcher(config);
+    }
+    shouldHandleCallback() {
+        return of(location.search).pipe(map((search) => {
+            const searchParams = new URLSearchParams(search);
+            return ((searchParams.has('code') || searchParams.has('error')) &&
+                searchParams.has('state') &&
+                !this.configFactory.get().skipRedirectCallback);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, deps: [{ token: Auth0ClientService }, { token: i1.AuthClientConfig }, { token: i2.AbstractNavigator }, { token: i3.AuthState }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i4.Auth0Client, decorators: [{
+                    type: Inject,
+                    args: [Auth0ClientService]
+                }] }, { type: i1.AuthClientConfig }, { type: i2.AbstractNavigator }, { type: i3.AuthState }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../projects/auth0-angular/src/lib/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, OnDestroy } from '@angular/core';\n\nimport {\n  Auth0Client,\n  PopupLoginOptions,\n  PopupConfigOptions,\n  GetTokenSilentlyOptions,\n  GetTokenWithPopupOptions,\n  RedirectLoginResult,\n  GetTokenSilentlyVerboseResponse,\n  ConnectAccountRedirectResult,\n  CustomFetchMinimalOutput,\n  Fetcher,\n  FetcherConfig,\n} from '@auth0/auth0-spa-js';\n\nimport {\n  of,\n  from,\n  Subject,\n  Observable,\n  iif,\n  defer,\n  ReplaySubject,\n  throwError,\n} from 'rxjs';\n\nimport {\n  concatMap,\n  tap,\n  map,\n  takeUntil,\n  catchError,\n  switchMap,\n  withLatestFrom,\n} from 'rxjs/operators';\n\nimport { Auth0ClientService } from './auth.client';\nimport { AbstractNavigator } from './abstract-navigator';\nimport { AuthClientConfig, AppState } from './auth.config';\nimport { AuthState } from './auth.state';\nimport { LogoutOptions, RedirectLoginOptions } from './interfaces';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AuthService<TAppState extends AppState = AppState>\n  implements OnDestroy\n{\n  private appStateSubject$ = new ReplaySubject<TAppState>(1);\n\n  // https://stackoverflow.com/a/41177163\n  private ngUnsubscribe$ = new Subject<void>();\n  /**\n   * Emits boolean values indicating the loading state of the SDK.\n   */\n  readonly isLoading$ = this.authState.isLoading$;\n\n  /**\n   * Emits boolean values indicating the authentication state of the user. If `true`, it means a user has authenticated.\n   * This depends on the value of `isLoading$`, so there is no need to manually check the loading state of the SDK.\n   */\n  readonly isAuthenticated$ = this.authState.isAuthenticated$;\n\n  /**\n   * Emits details about the authenticated user, or null if not authenticated.\n   */\n  readonly user$ = this.authState.user$;\n\n  /**\n   * Emits ID token claims when authenticated, or null if not authenticated.\n   */\n  readonly idTokenClaims$ = this.authState.idTokenClaims$;\n\n  /**\n   * Emits errors that occur during login, or when checking for an active session on startup.\n   */\n  readonly error$ = this.authState.error$;\n\n  /**\n   * Emits the value (if any) that was passed to the `loginWithRedirect` method call\n   * but only **after** `handleRedirectCallback` is first called\n   */\n  readonly appState$ = this.appStateSubject$.asObservable();\n\n  constructor(\n    @Inject(Auth0ClientService) private auth0Client: Auth0Client,\n    private configFactory: AuthClientConfig,\n    private navigator: AbstractNavigator,\n    private authState: AuthState\n  ) {\n    const checkSessionOrCallback$ = (isCallback: boolean) =>\n      iif(\n        () => isCallback,\n        this.handleRedirectCallback(),\n        defer(() => this.auth0Client.checkSession())\n      );\n\n    this.shouldHandleCallback()\n      .pipe(\n        switchMap((isCallback) =>\n          checkSessionOrCallback$(isCallback).pipe(\n            catchError((error) => {\n              const config = this.configFactory.get();\n              this.navigator.navigateByUrl(config.errorPath || '/');\n              this.authState.setError(error);\n              return of(undefined);\n            })\n          )\n        ),\n        tap(() => {\n          this.authState.setIsLoading(false);\n        }),\n        takeUntil(this.ngUnsubscribe$)\n      )\n      .subscribe();\n  }\n\n  /**\n   * Called when the service is destroyed\n   */\n  ngOnDestroy(): void {\n    // https://stackoverflow.com/a/41177163\n    this.ngUnsubscribe$.next();\n    this.ngUnsubscribe$.complete();\n  }\n\n  /**\n   * ```js\n   * loginWithRedirect(options);\n   * ```\n   *\n   * Performs a redirect to `/authorize` using the parameters\n   * provided as arguments. Random and secure `state` and `nonce`\n   * parameters will be auto-generated.\n   *\n   * @param options The login options\n   */\n  loginWithRedirect(\n    options?: RedirectLoginOptions<TAppState>\n  ): Observable<void> {\n    return from(this.auth0Client.loginWithRedirect(options));\n  }\n\n  /**\n   * ```js\n   * await loginWithPopup(options);\n   * ```\n   *\n   * Opens a popup with the `/authorize` URL using the parameters\n   * provided as arguments. Random and secure `state` and `nonce`\n   * parameters will be auto-generated. If the response is successful,\n   * results will be valid according to their expiration times.\n   *\n   * IMPORTANT: This method has to be called from an event handler\n   * that was started by the user like a button click, for example,\n   * otherwise the popup will be blocked in most browsers.\n   *\n   * @param options The login options\n   * @param config Configuration for the popup window\n   */\n  loginWithPopup(\n    options?: PopupLoginOptions,\n    config?: PopupConfigOptions\n  ): Observable<void> {\n    return from(\n      this.auth0Client.loginWithPopup(options, config).then(() => {\n        this.authState.refresh();\n      })\n    );\n  }\n\n  /**\n   * ```js\n   * logout();\n   * ```\n   *\n   * Clears the application session and performs a redirect to `/v2/logout`, using\n   * the parameters provided as arguments, to clear the Auth0 session.\n   * If the `federated` option is specified it also clears the Identity Provider session.\n   * If the `openUrl` option is set to false, it only clears the application session.\n   * It is invalid to set both the `federated` to true and `openUrl` to `false`,\n   * and an error will be thrown if you do.\n   * [Read more about how Logout works at Auth0](https://auth0.com/docs/logout).\n   *\n   * @param options The logout options\n   */\n  logout(options?: LogoutOptions): Observable<void> {\n    return from(\n      this.auth0Client.logout(options).then(() => {\n        if (options?.openUrl === false || options?.openUrl) {\n          this.authState.refresh();\n        }\n      })\n    );\n  }\n\n  /**\n   * Fetches a new access token and returns the response from the /oauth/token endpoint, omitting the refresh token.\n   *\n   * @param options The options for configuring the token fetch.\n   */\n  getAccessTokenSilently(\n    options: GetTokenSilentlyOptions & { detailedResponse: true }\n  ): Observable<GetTokenSilentlyVerboseResponse>;\n\n  /**\n   * Fetches a new access token and returns it.\n   *\n   * @param options The options for configuring the token fetch.\n   */\n  getAccessTokenSilently(options?: GetTokenSilentlyOptions): Observable<string>;\n\n  /**\n   * ```js\n   * getAccessTokenSilently(options).subscribe(token => ...)\n   * ```\n   *\n   * If there's a valid token stored, return it. Otherwise, opens an\n   * iframe with the `/authorize` URL using the parameters provided\n   * as arguments. Random and secure `state` and `nonce` parameters\n   * will be auto-generated. If the response is successful, results\n   * will be valid according to their expiration times.\n   *\n   * If refresh tokens are used, the token endpoint is called directly with the\n   * 'refresh_token' grant. If no refresh token is available to make this call,\n   * the SDK falls back to using an iframe to the '/authorize' URL.\n   *\n   * This method may use a web worker to perform the token call if the in-memory\n   * cache is used.\n   *\n   * If an `audience` value is given to this function, the SDK always falls\n   * back to using an iframe to make the token exchange.\n   *\n   * Note that in all cases, falling back to an iframe requires access to\n   * the `auth0` cookie, and thus will not work in browsers that block third-party\n   * cookies by default (Safari, Brave, etc).\n   *\n   * @param options The options for configuring the token fetch.\n   */\n  getAccessTokenSilently(\n    options: GetTokenSilentlyOptions = {}\n  ): Observable<string | GetTokenSilentlyVerboseResponse> {\n    return of(this.auth0Client).pipe(\n      concatMap((client) =>\n        options.detailedResponse === true\n          ? client.getTokenSilently({ ...options, detailedResponse: true })\n          : client.getTokenSilently(options)\n      ),\n      tap((token) => {\n        if (token) {\n          this.authState.setAccessToken(\n            typeof token === 'string' ? token : token.access_token\n          );\n        }\n      }),\n      catchError((error) => {\n        this.authState.setError(error);\n        this.authState.refresh();\n        return throwError(error);\n      })\n    );\n  }\n\n  /**\n   * ```js\n   * getTokenWithPopup(options).subscribe(token => ...)\n   * ```\n   *\n   * Get an access token interactively.\n   *\n   * Opens a popup with the `/authorize` URL using the parameters\n   * provided as arguments. Random and secure `state` and `nonce`\n   * parameters will be auto-generated. If the response is successful,\n   * results will be valid according to their expiration times.\n   */\n  getAccessTokenWithPopup(\n    options?: GetTokenWithPopupOptions\n  ): Observable<string | undefined> {\n    return of(this.auth0Client).pipe(\n      concatMap((client) => client.getTokenWithPopup(options)),\n      tap((token) => {\n        if (token) {\n          this.authState.setAccessToken(token);\n        }\n      }),\n      catchError((error) => {\n        this.authState.setError(error);\n        this.authState.refresh();\n        return throwError(error);\n      })\n    );\n  }\n\n  /**\n   * ```js\n   * handleRedirectCallback(url).subscribe(result => ...)\n   * ```\n   *\n   * After the browser redirects back to the callback page,\n   * call `handleRedirectCallback` to handle success and error\n   * responses from Auth0. If the response is successful, results\n   * will be valid according to their expiration times.\n   *\n   * Calling this method also refreshes the authentication and user states.\n   *\n   * @param url The URL to that should be used to retrieve the `state` and `code` values. Defaults to `window.location.href` if not given.\n   */\n  handleRedirectCallback(\n    url?: string\n  ): Observable<\n    RedirectLoginResult<TAppState> | ConnectAccountRedirectResult<TAppState>\n  > {\n    return defer(() =>\n      this.auth0Client.handleRedirectCallback<TAppState>(url)\n    ).pipe(\n      withLatestFrom(this.authState.isLoading$),\n      tap(([result, isLoading]) => {\n        if (!isLoading) {\n          this.authState.refresh();\n        }\n        const appState = result?.appState;\n        const target = appState?.target ?? '/';\n\n        if (appState) {\n          this.appStateSubject$.next(appState);\n        }\n\n        this.navigator.navigateByUrl(target);\n      }),\n      map(([result]) => result)\n    );\n  }\n\n  /**\n   * ```js\n   * getDpopNonce(id).subscribe(nonce => ...)\n   * ```\n   *\n   * Gets the DPoP nonce for the specified domain or the default domain.\n   * The nonce is used in DPoP proof generation for token binding.\n   *\n   * @param id Optional identifier for the domain. If not provided, uses the default domain.\n   * @returns An Observable that emits the DPoP nonce string or undefined if not available.\n   */\n  getDpopNonce(id?: string): Observable<string | undefined> {\n    return from(this.auth0Client.getDpopNonce(id));\n  }\n\n  /**\n   * ```js\n   * setDpopNonce(nonce, id).subscribe(() => ...)\n   * ```\n   *\n   * Sets the DPoP nonce for the specified domain or the default domain.\n   * This is typically used after receiving a new nonce from the authorization server.\n   *\n   * @param nonce The DPoP nonce value to set.\n   * @param id Optional identifier for the domain. If not provided, uses the default domain.\n   * @returns An Observable that completes when the nonce is set.\n   */\n  setDpopNonce(nonce: string, id?: string): Observable<void> {\n    return from(this.auth0Client.setDpopNonce(nonce, id));\n  }\n\n  /**\n   * ```js\n   * generateDpopProof(params).subscribe(proof => ...)\n   * ```\n   *\n   * Generates a DPoP (Demonstrating Proof-of-Possession) proof JWT.\n   * This proof is used to bind access tokens to a specific client, providing\n   * an additional layer of security for token usage.\n   *\n   * @param params Configuration for generating the DPoP proof\n   * @param params.url The URL of the resource server endpoint\n   * @param params.method The HTTP method (e.g., 'GET', 'POST')\n   * @param params.nonce Optional DPoP nonce from the authorization server\n   * @param params.accessToken The access token to bind to the proof\n   * @returns An Observable that emits the generated DPoP proof as a JWT string.\n   */\n  generateDpopProof(params: {\n    url: string;\n    method: string;\n    nonce?: string;\n    accessToken: string;\n  }): Observable<string> {\n    return from(this.auth0Client.generateDpopProof(params));\n  }\n\n  /**\n   * ```js\n   * const fetcher = createFetcher(config);\n   * ```\n   *\n   * Creates a custom fetcher instance that can be used to make authenticated\n   * HTTP requests. The fetcher automatically handles token refresh and can\n   * be configured with custom request/response handling.\n   *\n   * @param config Optional configuration for the fetcher\n   * @returns A Fetcher instance configured with the Auth0 client.\n   */\n  createFetcher<TOutput extends CustomFetchMinimalOutput = Response>(\n    config?: FetcherConfig<TOutput>\n  ): Fetcher<TOutput> {\n    return this.auth0Client.createFetcher(config);\n  }\n\n  private shouldHandleCallback(): Observable<boolean> {\n    return of(location.search).pipe(\n      map((search) => {\n        const searchParams = new URLSearchParams(search);\n        return (\n          (searchParams.has('code') || searchParams.has('error')) &&\n          searchParams.has('state') &&\n          !this.configFactory.get().skipRedirectCallback\n        );\n      })\n    );\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/auth.state.mjs

@@ -87,14 +87,14 @@ export class AuthState {
     setError(error) {
         this.errorSubject$.next(error);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthState, deps: [{ token: Auth0ClientService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthState, providedIn: 'root' }); }
 }
-AuthState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthState, deps: [{ token: Auth0ClientService }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthState, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthState, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthState, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i1.Auth0Client, decorators: [{
+        }], ctorParameters: () => [{ type: i1.Auth0Client, decorators: [{
                     type: Inject,
                     args: [Auth0ClientService]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.state.js","sourceRoot":"","sources":["../../../../projects/auth0-angular/src/lib/auth.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Auth0Client } from '@auth0/auth0-spa-js';\nimport {\n  BehaviorSubject,\n  defer,\n  merge,\n  of,\n  ReplaySubject,\n  Subject,\n} from 'rxjs';\nimport {\n  concatMap,\n  distinctUntilChanged,\n  filter,\n  mergeMap,\n  scan,\n  shareReplay,\n  switchMap,\n} from 'rxjs/operators';\nimport { Auth0ClientService } from './auth.client';\n\n/**\n * Tracks the Authentication State for the SDK\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthState {\n  private isLoadingSubject$ = new BehaviorSubject<boolean>(true);\n  private refresh$ = new Subject<void>();\n  private accessToken$ = new ReplaySubject<string>(1);\n  private errorSubject$ = new ReplaySubject<Error>(1);\n\n  /**\n   * Emits boolean values indicating the loading state of the SDK.\n   */\n  public readonly isLoading$ = this.isLoadingSubject$.asObservable();\n\n  /**\n   * Trigger used to pull User information from the Auth0Client.\n   * Triggers when the access token has changed.\n   */\n  private accessTokenTrigger$ = this.accessToken$.pipe(\n    scan(\n      (\n        acc: { current: string | null; previous: string | null },\n        current: string | null\n      ) => ({\n        previous: acc.current,\n        current,\n      }),\n      { current: null, previous: null }\n    ),\n    filter(({ previous, current }) => previous !== current)\n  );\n\n  /**\n   * Trigger used to pull User information from the Auth0Client.\n   * Triggers when an event occurs that needs to retrigger the User Profile information.\n   * Events: Login, Access Token change and Logout\n   */\n  private readonly isAuthenticatedTrigger$ = this.isLoading$.pipe(\n    filter((loading) => !loading),\n    distinctUntilChanged(),\n    switchMap(() =>\n      // To track the value of isAuthenticated over time, we need to merge:\n      //  - the current value\n      //  - the value whenever the access token changes. (this should always be true of there is an access token\n      //    but it is safer to pass this through this.auth0Client.isAuthenticated() nevertheless)\n      //  - the value whenever refreshState$ emits\n      merge(\n        defer(() => this.auth0Client.isAuthenticated()),\n        this.accessTokenTrigger$.pipe(\n          mergeMap(() => this.auth0Client.isAuthenticated())\n        ),\n        this.refresh$.pipe(mergeMap(() => this.auth0Client.isAuthenticated()))\n      )\n    )\n  );\n\n  /**\n   * Emits boolean values indicating the authentication state of the user. If `true`, it means a user has authenticated.\n   * This depends on the value of `isLoading$`, so there is no need to manually check the loading state of the SDK.\n   */\n  readonly isAuthenticated$ = this.isAuthenticatedTrigger$.pipe(\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  /**\n   * Emits details about the authenticated user, or null if not authenticated.\n   */\n  readonly user$ = this.isAuthenticatedTrigger$.pipe(\n    concatMap((authenticated) =>\n      authenticated ? this.auth0Client.getUser() : of(null)\n    ),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Emits ID token claims when authenticated, or null if not authenticated.\n   */\n  readonly idTokenClaims$ = this.isAuthenticatedTrigger$.pipe(\n    concatMap((authenticated) =>\n      authenticated ? this.auth0Client.getIdTokenClaims() : of(null)\n    )\n  );\n\n  /**\n   * Emits errors that occur during login, or when checking for an active session on startup.\n   */\n  public readonly error$ = this.errorSubject$.asObservable();\n\n  constructor(@Inject(Auth0ClientService) private auth0Client: Auth0Client) {}\n\n  /**\n   * Update the isLoading state using the provided value\n   *\n   * @param isLoading The new value for isLoading\n   */\n  public setIsLoading(isLoading: boolean): void {\n    this.isLoadingSubject$.next(isLoading);\n  }\n\n  /**\n   * Refresh the state to ensure the `isAuthenticated`, `user$` and `idTokenClaims$`\n   * reflect the most up-to-date values from  Auth0Client.\n   */\n  public refresh(): void {\n    this.refresh$.next();\n  }\n\n  /**\n   * Update the access token, doing so will also refresh the state.\n   *\n   * @param accessToken The new Access Token\n   */\n  public setAccessToken(accessToken: string): void {\n    this.accessToken$.next(accessToken);\n  }\n\n  /**\n   * Emits the error in the `error$` observable.\n   *\n   * @param error The new error\n   */\n  public setError(error: any): void {\n    this.errorSubject$.next(error);\n  }\n}\n"]}
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.state.js","sourceRoot":"","sources":["../../../../projects/auth0-angular/src/lib/auth.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Auth0Client } from '@auth0/auth0-spa-js';\nimport {\n  BehaviorSubject,\n  defer,\n  merge,\n  of,\n  ReplaySubject,\n  Subject,\n} from 'rxjs';\nimport {\n  concatMap,\n  distinctUntilChanged,\n  filter,\n  mergeMap,\n  scan,\n  shareReplay,\n  switchMap,\n} from 'rxjs/operators';\nimport { Auth0ClientService } from './auth.client';\n\n/**\n * Tracks the Authentication State for the SDK\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthState {\n  private isLoadingSubject$ = new BehaviorSubject<boolean>(true);\n  private refresh$ = new Subject<void>();\n  private accessToken$ = new ReplaySubject<string>(1);\n  private errorSubject$ = new ReplaySubject<Error>(1);\n\n  /**\n   * Emits boolean values indicating the loading state of the SDK.\n   */\n  public readonly isLoading$ = this.isLoadingSubject$.asObservable();\n\n  /**\n   * Trigger used to pull User information from the Auth0Client.\n   * Triggers when the access token has changed.\n   */\n  private accessTokenTrigger$ = this.accessToken$.pipe(\n    scan(\n      (\n        acc: { current: string | null; previous: string | null },\n        current: string | null\n      ) => ({\n        previous: acc.current,\n        current,\n      }),\n      { current: null, previous: null }\n    ),\n    filter(({ previous, current }) => previous !== current)\n  );\n\n  /**\n   * Trigger used to pull User information from the Auth0Client.\n   * Triggers when an event occurs that needs to retrigger the User Profile information.\n   * Events: Login, Access Token change and Logout\n   */\n  private readonly isAuthenticatedTrigger$ = this.isLoading$.pipe(\n    filter((loading) => !loading),\n    distinctUntilChanged(),\n    switchMap(() =>\n      // To track the value of isAuthenticated over time, we need to merge:\n      //  - the current value\n      //  - the value whenever the access token changes. (this should always be true of there is an access token\n      //    but it is safer to pass this through this.auth0Client.isAuthenticated() nevertheless)\n      //  - the value whenever refreshState$ emits\n      merge(\n        defer(() => this.auth0Client.isAuthenticated()),\n        this.accessTokenTrigger$.pipe(\n          mergeMap(() => this.auth0Client.isAuthenticated())\n        ),\n        this.refresh$.pipe(mergeMap(() => this.auth0Client.isAuthenticated()))\n      )\n    )\n  );\n\n  /**\n   * Emits boolean values indicating the authentication state of the user. If `true`, it means a user has authenticated.\n   * This depends on the value of `isLoading$`, so there is no need to manually check the loading state of the SDK.\n   */\n  readonly isAuthenticated$ = this.isAuthenticatedTrigger$.pipe(\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  /**\n   * Emits details about the authenticated user, or null if not authenticated.\n   */\n  readonly user$ = this.isAuthenticatedTrigger$.pipe(\n    concatMap((authenticated) =>\n      authenticated ? this.auth0Client.getUser() : of(null)\n    ),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Emits ID token claims when authenticated, or null if not authenticated.\n   */\n  readonly idTokenClaims$ = this.isAuthenticatedTrigger$.pipe(\n    concatMap((authenticated) =>\n      authenticated ? this.auth0Client.getIdTokenClaims() : of(null)\n    )\n  );\n\n  /**\n   * Emits errors that occur during login, or when checking for an active session on startup.\n   */\n  public readonly error$ = this.errorSubject$.asObservable();\n\n  constructor(@Inject(Auth0ClientService) private auth0Client: Auth0Client) {}\n\n  /**\n   * Update the isLoading state using the provided value\n   *\n   * @param isLoading The new value for isLoading\n   */\n  public setIsLoading(isLoading: boolean): void {\n    this.isLoadingSubject$.next(isLoading);\n  }\n\n  /**\n   * Refresh the state to ensure the `isAuthenticated`, `user$` and `idTokenClaims$`\n   * reflect the most up-to-date values from  Auth0Client.\n   */\n  public refresh(): void {\n    this.refresh$.next();\n  }\n\n  /**\n   * Update the access token, doing so will also refresh the state.\n   *\n   * @param accessToken The new Access Token\n   */\n  public setAccessToken(accessToken: string): void {\n    this.accessToken$.next(accessToken);\n  }\n\n  /**\n   * Emits the error in the `error$` observable.\n   *\n   * @param error The new error\n   */\n  public setError(error: any): void {\n    this.errorSubject$.next(error);\n  }\n}\n"]}

package/esm2022/lib/interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2F1dGgwLWFuZ3VsYXIvc3JjL2xpYi9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBSZWRpcmVjdExvZ2luT3B0aW9ucyBhcyBTUEFSZWRpcmVjdExvZ2luT3B0aW9ucyxcbiAgTG9nb3V0T3B0aW9ucyBhcyBTUEFMb2dvdXRPcHRpb25zLFxufSBmcm9tICdAYXV0aDAvYXV0aDAtc3BhLWpzJztcblxuZXhwb3J0IGludGVyZmFjZSBSZWRpcmVjdExvZ2luT3B0aW9uczxUQXBwU3RhdGU+XG4gIGV4dGVuZHMgT21pdDxTUEFSZWRpcmVjdExvZ2luT3B0aW9uczxUQXBwU3RhdGU+LCAnb25SZWRpcmVjdCc+IHt9XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9nb3V0T3B0aW9ucyBleHRlbmRzIE9taXQ8U1BBTG9nb3V0T3B0aW9ucywgJ29uUmVkaXJlY3QnPiB7fVxuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,16 @@
+/*
+ * Public API Surface of auth0-angular
+ */
+export * from './lib/auth.service';
+export * from './lib/auth.module';
+export * from './lib/auth.guard';
+export * from './lib/auth.interceptor';
+export * from './lib/auth.config';
+export * from './lib/auth.client';
+export * from './lib/auth.state';
+export * from './lib/interfaces';
+export * from './lib/provide';
+export * from './lib/functional';
+export * from './lib/abstract-navigator';
+export { LocalStorageCache, InMemoryCache, User, GenericError, TimeoutError, MfaRequiredError, PopupTimeoutError, AuthenticationError, PopupCancelledError, MissingRefreshTokenError, UseDpopNonceError, } from '@auth0/auth0-spa-js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2F1dGgwLWFuZ3VsYXIvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLDBCQUEwQixDQUFDO0FBRXpDLE9BQU8sRUFRTCxpQkFBaUIsRUFDakIsYUFBYSxFQUViLElBQUksRUFDSixZQUFZLEVBQ1osWUFBWSxFQUNaLGdCQUFnQixFQUNoQixpQkFBaUIsRUFDakIsbUJBQW1CLEVBQ25CLG1CQUFtQixFQUNuQix3QkFBd0IsRUFJeEIsaUJBQWlCLEdBQ2xCLE1BQU0scUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGF1dGgwLWFuZ3VsYXJcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9hdXRoLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aC5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9hdXRoLmludGVyY2VwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguY2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguc3RhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9wcm92aWRlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Z1bmN0aW9uYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYWJzdHJhY3QtbmF2aWdhdG9yJztcblxuZXhwb3J0IHtcbiAgQXV0aG9yaXphdGlvblBhcmFtcyxcbiAgUG9wdXBMb2dpbk9wdGlvbnMsXG4gIFBvcHVwQ29uZmlnT3B0aW9ucyxcbiAgR2V0VG9rZW5XaXRoUG9wdXBPcHRpb25zLFxuICBHZXRUb2tlblNpbGVudGx5T3B0aW9ucyxcbiAgSUNhY2hlLFxuICBDYWNoZWFibGUsXG4gIExvY2FsU3RvcmFnZUNhY2hlLFxuICBJbk1lbW9yeUNhY2hlLFxuICBJZFRva2VuLFxuICBVc2VyLFxuICBHZW5lcmljRXJyb3IsXG4gIFRpbWVvdXRFcnJvcixcbiAgTWZhUmVxdWlyZWRFcnJvcixcbiAgUG9wdXBUaW1lb3V0RXJyb3IsXG4gIEF1dGhlbnRpY2F0aW9uRXJyb3IsXG4gIFBvcHVwQ2FuY2VsbGVkRXJyb3IsXG4gIE1pc3NpbmdSZWZyZXNoVG9rZW5FcnJvcixcbiAgRmV0Y2hlcixcbiAgRmV0Y2hlckNvbmZpZyxcbiAgQ3VzdG9tRmV0Y2hNaW5pbWFsT3V0cHV0LFxuICBVc2VEcG9wTm9uY2VFcnJvcixcbn0gZnJvbSAnQGF1dGgwL2F1dGgwLXNwYS1qcyc7XG4iXX0=

package/{esm2020 → esm2022}/useragent.mjs

@@ -1,2 +1,2 @@
-export default { name: '@auth0/auth0-angular', version: '2.2.3' };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcmFnZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvdXNlcmFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgeyBuYW1lOiAnQGF1dGgwL2F1dGgwLWFuZ3VsYXInLCB2ZXJzaW9uOiAnMi4yLjMnIH07XG4iXX0=
+export default { name: '@auth0/auth0-angular', version: '2.4.0' };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcmFnZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvdXNlcmFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgeyBuYW1lOiAnQGF1dGgwL2F1dGgwLWFuZ3VsYXInLCB2ZXJzaW9uOiAnMi40LjAnIH07XG4iXX0=