@auth0/auth0-angular 1.11.1 → 2.0.0

package/esm2020/lib/auth.service.mjs

@@ -0,0 +1,229 @@
+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) => 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));
+    }
+    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);
+        }));
+    }
+}
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthService, deps: [{ token: Auth0ClientService }, { token: i1.AuthClientConfig }, { token: i2.AbstractNavigator }, { token: i3.AuthState }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ 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} 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  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        this.authState.setAccessToken(\n          typeof token === 'string' ? token : token.access_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   * 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<RedirectLoginResult<TAppState>> {\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  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/lib/auth.state.mjs

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

package/esm2020/lib/interfaces.mjs

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

package/esm2020/public-api.mjs

@@ -0,0 +1,13 @@
+/*
+ * 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 { LocalStorageCache, InMemoryCache, User } from '@auth0/auth0-spa-js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2F1dGgwLWFuZ3VsYXIvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsT0FBTyxFQUdMLGlCQUFpQixFQUNqQixhQUFhLEVBRWIsSUFBSSxFQUNMLE1BQU0scUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGF1dGgwLWFuZ3VsYXJcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9hdXRoLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXV0aC5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9hdXRoLmludGVyY2VwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguY2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2F1dGguc3RhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcyc7XG5cbmV4cG9ydCB7XG4gIElDYWNoZSxcbiAgQ2FjaGVhYmxlLFxuICBMb2NhbFN0b3JhZ2VDYWNoZSxcbiAgSW5NZW1vcnlDYWNoZSxcbiAgSWRUb2tlbixcbiAgVXNlclxufSBmcm9tICdAYXV0aDAvYXV0aDAtc3BhLWpzJztcbiJdfQ==

package/{esm2015/useragent.js → esm2020/useragent.mjs}

@@ -1,2 +1,2 @@
-export default { name: '@auth0/auth0-angular', version: '1.11.1' };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcmFnZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvdXNlcmFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgeyBuYW1lOiAnQGF1dGgwL2F1dGgwLWFuZ3VsYXInLCB2ZXJzaW9uOiAnMS4xMS4xJyB9O1xuIl19
+export default { name: '@auth0/auth0-angular', version: '2.0.0' };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlcmFnZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvdXNlcmFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsRUFBRSxJQUFJLEVBQUUsc0JBQXNCLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgeyBuYW1lOiAnQGF1dGgwL2F1dGgwLWFuZ3VsYXInLCB2ZXJzaW9uOiAnMi4wLjAnIH07XG4iXX0=