@auth0/auth0-angular 1.11.1 → 2.0.0-beta.0

package/README.md

@@ -2,6 +2,8 @@
 
 A library for integrating [Auth0](https://auth0.com) into an Angular application.
 
+> :warning: Please be aware that v2 is currently in [**Beta**](https://auth0.com/docs/troubleshoot/product-lifecycle/product-release-stages). Whilst we encourage you to test the update within your applications, we do no recommend using this version in production yet. Please follow the [migration guide](./MIGRATION_GUIDE.md) when updating your application.
+
 ![Release](https://img.shields.io/npm/v/@auth0/auth0-angular)
 [![Codecov](https://img.shields.io/codecov/c/github/auth0/auth0-angular)](https://codecov.io/gh/auth0/auth0-angular)
 ![Downloads](https://img.shields.io/npm/dw/@auth0/auth0-angular)
@@ -29,13 +31,13 @@ This project only supports the [actively supported versions of Angular as stated
 Using npm:
 
 ```sh
-npm install @auth0/auth0-angular
+npm install @auth0/auth0-angular@beta
 ```
 
 We also have `ng-add` support, so the library can also be installed using the Angular CLI:
 
 ```sh
-ng add @auth0/auth0-angular
+ng add @auth0/auth0-angular@beta
 ```
 
 ### Configure Auth0

package/{esm2015/lib/abstract-navigator.js → esm2020/lib/abstract-navigator.mjs}

@@ -8,11 +8,12 @@ export class AbstractNavigator {
         try {
             this.router = injector.get(Router);
         }
-        catch (_a) { }
+        catch { }
     }
     /**
      * Navigates to the specified url. The router will be used if one is available, otherwise it falls back
      * to `window.history.replaceState`.
+     *
      * @param url The url to navigate to
      */
     navigateByUrl(url) {
@@ -23,12 +24,12 @@ export class AbstractNavigator {
         this.location.replaceState(url);
     }
 }
-AbstractNavigator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractNavigator, deps: [{ token: i1.Location }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-AbstractNavigator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractNavigator, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AbstractNavigator, decorators: [{
+AbstractNavigator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractNavigator, deps: [{ token: i1.Location }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractNavigator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractNavigator, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractNavigator, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.Location }, { type: i0.Injector }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbmF2aWdhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvbGliL2Fic3RyYWN0LW5hdmlnYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7O0FBTXpDLE1BQU0sT0FBTyxpQkFBaUI7SUFHNUIsWUFBb0IsUUFBa0IsRUFBRSxRQUFrQjtRQUF0QyxhQUFRLEdBQVIsUUFBUSxDQUFVO1FBQ3BDLElBQUk7WUFDRixJQUFJLENBQUMsTUFBTSxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7U0FDcEM7UUFBQyxNQUFNLEdBQUU7SUFDWixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxhQUFhLENBQUMsR0FBVztRQUN2QixJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDZixJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUUvQixPQUFPO1NBQ1I7UUFFRCxJQUFJLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsQyxDQUFDOzsrR0F2QlUsaUJBQWlCO21IQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs0RkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJvdXRlciB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBMb2NhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBBYnN0cmFjdE5hdmlnYXRvciB7XG4gIHByaXZhdGUgcmVhZG9ubHkgcm91dGVyPzogUm91dGVyO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgbG9jYXRpb246IExvY2F0aW9uLCBpbmplY3RvcjogSW5qZWN0b3IpIHtcbiAgICB0cnkge1xuICAgICAgdGhpcy5yb3V0ZXIgPSBpbmplY3Rvci5nZXQoUm91dGVyKTtcbiAgICB9IGNhdGNoIHt9XG4gIH1cblxuICAvKipcbiAgICogTmF2aWdhdGVzIHRvIHRoZSBzcGVjaWZpZWQgdXJsLiBUaGUgcm91dGVyIHdpbGwgYmUgdXNlZCBpZiBvbmUgaXMgYXZhaWxhYmxlLCBvdGhlcndpc2UgaXQgZmFsbHMgYmFja1xuICAgKiB0byBgd2luZG93Lmhpc3RvcnkucmVwbGFjZVN0YXRlYC5cbiAgICpcbiAgICogQHBhcmFtIHVybCBUaGUgdXJsIHRvIG5hdmlnYXRlIHRvXG4gICAqL1xuICBuYXZpZ2F0ZUJ5VXJsKHVybDogc3RyaW5nKTogdm9pZCB7XG4gICAgaWYgKHRoaXMucm91dGVyKSB7XG4gICAgICB0aGlzLnJvdXRlci5uYXZpZ2F0ZUJ5VXJsKHVybCk7XG5cbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICB0aGlzLmxvY2F0aW9uLnJlcGxhY2VTdGF0ZSh1cmwpO1xuICB9XG59XG4iXX0=

package/esm2020/lib/auth.client.mjs

@@ -0,0 +1,23 @@
+import { InjectionToken, VERSION } from '@angular/core';
+import { Auth0Client } from '@auth0/auth0-spa-js';
+import useragent from '../useragent';
+export class Auth0ClientFactory {
+    static createClient(configFactory) {
+        const config = configFactory.get();
+        if (!config) {
+            throw new Error('Configuration must be specified either through AuthModule.forRoot or through AuthClientConfig.set');
+        }
+        return new Auth0Client({
+            ...config,
+            auth0Client: {
+                name: useragent.name,
+                version: useragent.version,
+                env: {
+                    'angular/core': VERSION.full,
+                },
+            },
+        });
+    }
+}
+export const Auth0ClientService = new InjectionToken('auth0.client');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/auth.config.mjs

@@ -0,0 +1,97 @@
+import { InjectionToken, Injectable, Optional, Inject } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A custom type guard to help identify route definitions that are actually HttpInterceptorRouteConfig types.
+ *
+ * @param def The route definition type
+ */
+export function isHttpInterceptorRouteConfig(def) {
+    return typeof def !== 'string';
+}
+/**
+ * Gets and sets configuration for the internal Auth0 client. This can be
+ * used to provide configuration outside of using AuthModule.forRoot, i.e. from
+ * a factory provided by APP_INITIALIZER.
+ *
+ * @usage
+ *
+ * ```js
+ * // app.module.ts
+ * // ---------------------------
+ * import { AuthModule, AuthClientConfig } from '@auth0/auth0-angular';
+ *
+ * // Provide an initializer function that returns a Promise
+ * function configInitializer(
+ *   http: HttpClient,
+ *   config: AuthClientConfig
+ * ) {
+ *   return () =>
+ *     http
+ *       .get('/config')
+ *       .toPromise()
+ *       .then((loadedConfig: any) => config.set(loadedConfig));   // Set the config that was loaded asynchronously here
+ * }
+ *
+ * // Provide APP_INITIALIZER with this function. Note that there is no config passed to AuthModule.forRoot
+ * imports: [
+ *   // other imports..
+ *
+ *   HttpClientModule,
+ *   AuthModule.forRoot(),   //<- don't pass any config here
+ * ],
+ * providers: [
+ *   {
+ *     provide: APP_INITIALIZER,
+ *     useFactory: configInitializer,    // <- pass your initializer function here
+ *     deps: [HttpClient, AuthClientConfig],
+ *     multi: true,
+ *   },
+ * ],
+ * ```
+ *
+ */
+export class AuthClientConfig {
+    constructor(config) {
+        if (config) {
+            this.set(config);
+        }
+    }
+    /**
+     * Sets configuration to be read by other consumers of the service (see usage notes)
+     *
+     * @param config The configuration to set
+     */
+    set(config) {
+        this.config = config;
+    }
+    /**
+     * Gets the config that has been set by other consumers of the service
+     */
+    get() {
+        return this.config;
+    }
+}
+AuthClientConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthClientConfig, deps: [{ token: AuthConfigService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthClientConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthClientConfig, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthClientConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AuthConfigService]
+                }] }]; } });
+/**
+ * Injection token for accessing configuration.
+ *
+ * @usageNotes
+ *
+ * Use the `Inject` decorator to access the configuration from a service or component:
+ *
+ * ```
+ * class MyService(@Inject(AuthConfigService) config: AuthConfig) {}
+ * ```
+ */
+export const AuthConfigService = new InjectionToken('auth0-angular.config');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.config.js","sourceRoot":"","sources":["../../../../projects/auth0-angular/src/lib/auth.config.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;AAsB7E;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAC1C,GAAuB;IAEvB,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC;AACjC,CAAC;AAoHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,MAAM,OAAO,gBAAgB;IAG3B,YAAmD,MAAmB;QACpE,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;SAClB;IACH,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,MAAkB;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,CAAC,MAAoB,CAAC;IACnC,CAAC;;8GAvBU,gBAAgB,kBAGK,iBAAiB;kHAHtC,gBAAgB,cADH,MAAM;4FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAInB,QAAQ;;0BAAI,MAAM;2BAAC,iBAAiB;;AAuBnD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CACjD,sBAAsB,CACvB,CAAC","sourcesContent":["import {\n  Auth0ClientOptions,\n  CacheLocation,\n  GetTokenSilentlyOptions,\n  ICache,\n} from '@auth0/auth0-spa-js';\n\nimport { InjectionToken, Injectable, Optional, Inject } from '@angular/core';\n\n/**\n * Defines a common set of HTTP methods.\n */\nexport const enum HttpMethod {\n  Get = 'GET',\n  Post = 'POST',\n  Put = 'PUT',\n  Patch = 'PATCH',\n  Delete = 'DELETE',\n  Head = 'HEAD',\n}\n\n/**\n * Defines the type for a route config entry. Can either be:\n *\n * - an object of type HttpInterceptorRouteConfig\n * - a string\n */\nexport type ApiRouteDefinition = HttpInterceptorRouteConfig | string;\n\n/**\n * A custom type guard to help identify route definitions that are actually HttpInterceptorRouteConfig types.\n *\n * @param def The route definition type\n */\nexport function isHttpInterceptorRouteConfig(\n  def: ApiRouteDefinition\n): def is HttpInterceptorRouteConfig {\n  return typeof def !== 'string';\n}\n\n/**\n * Configuration for the HttpInterceptor\n */\nexport interface HttpInterceptorConfig {\n  allowedList: ApiRouteDefinition[];\n}\n\n/**\n * Configuration for a single interceptor route\n */\nexport interface HttpInterceptorRouteConfig {\n  /**\n   * The URL to test, by supplying the URL to match.\n   * If `test` is a match for the current request path from the HTTP client, then\n   * an access token is attached to the request in the\n   *  [\"Authorization\" header](https://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-20#section-2.1).\n   *\n   * If the test does not pass, the request proceeds without the access token attached.\n   *\n   * A wildcard character can be used to match only the start of the URL.\n   *\n   * @usagenotes\n   *\n   * '/api' - exactly match the route /api\n   * '/api/*' - match any route that starts with /api/\n   */\n  uri?: string;\n\n  /**\n   * A function that will be called with the HttpRequest.url value, allowing you to do\n   * any kind of flexible matching.\n   *\n   * If this function returns true, then\n   * an access token is attached to the request in the\n   *  [\"Authorization\" header](https://tools.ietf.org/html/draft-ietf-oauth-v2-bearer-20#section-2.1).\n   *\n   * If it returns false, the request proceeds without the access token attached.\n   */\n  uriMatcher?: (uri: string) => boolean;\n\n  /**\n   * The options that are passed to the SDK when retrieving the\n   * access token to attach to the outgoing request.\n   */\n  tokenOptions?: GetTokenSilentlyOptions;\n\n  /**\n   * The HTTP method to match on. If specified, the HTTP method of\n   * the outgoing request will be checked against this. If there is no match, the\n   * Authorization header is not attached.\n   *\n   * The HTTP method name is case-sensitive.\n   */\n  httpMethod?: HttpMethod | string;\n\n  /**\n   * Allow the HTTP call to be executed anonymously, when no token is available.\n   *\n   * When omitted (or set to false), calls that match the configuration will fail when no token is available.\n   */\n  allowAnonymous?: boolean;\n}\n\n/**\n * Configuration for the authentication service\n */\nexport interface AuthConfig extends Auth0ClientOptions {\n  /**\n   * By default, if the page URL has code and state parameters, the SDK will assume they are for\n   * an Auth0 application and attempt to exchange the code for a token.\n   * In some cases the code might be for something else (e.g. another OAuth SDK). In these\n   * instances you can instruct the client to ignore them by setting `skipRedirectCallback`.\n   *\n   * ```js\n   * AuthModule.forRoot({\n   *   skipRedirectCallback: window.location.pathname === '/other-callback'\n   * })\n   * ```\n   *\n   * **Note**: In the above example, `/other-callback` is an existing route that will be called\n   * by any other OAuth provider with a `code` (or `error` in case when something went wrong) and `state`.\n   *\n   */\n  skipRedirectCallback?: boolean;\n\n  /**\n   * Configuration for the built-in Http Interceptor, used for\n   * automatically attaching access tokens.\n   */\n  httpInterceptor?: HttpInterceptorConfig;\n\n  /**\n   * Path in your application to redirect to when the Authorization server\n   * returns an error. Defaults to `/`\n   */\n  errorPath?: string;\n}\n\n/**\n * Angular specific state to be stored before redirect\n */\nexport interface AppState {\n  /**\n   * Target path the app gets routed to after\n   * handling the callback from Auth0 (defaults to '/')\n   */\n  target?: string;\n\n  /**\n   * Any custom parameter to be stored in appState\n   */\n  [key: string]: any;\n}\n\n/**\n * Gets and sets configuration for the internal Auth0 client. This can be\n * used to provide configuration outside of using AuthModule.forRoot, i.e. from\n * a factory provided by APP_INITIALIZER.\n *\n * @usage\n *\n * ```js\n * // app.module.ts\n * // ---------------------------\n * import { AuthModule, AuthClientConfig } from '@auth0/auth0-angular';\n *\n * // Provide an initializer function that returns a Promise\n * function configInitializer(\n *   http: HttpClient,\n *   config: AuthClientConfig\n * ) {\n *   return () =>\n *     http\n *       .get('/config')\n *       .toPromise()\n *       .then((loadedConfig: any) => config.set(loadedConfig));   // Set the config that was loaded asynchronously here\n * }\n *\n * // Provide APP_INITIALIZER with this function. Note that there is no config passed to AuthModule.forRoot\n * imports: [\n *   // other imports..\n *\n *   HttpClientModule,\n *   AuthModule.forRoot(),   //<- don't pass any config here\n * ],\n * providers: [\n *   {\n *     provide: APP_INITIALIZER,\n *     useFactory: configInitializer,    // <- pass your initializer function here\n *     deps: [HttpClient, AuthClientConfig],\n *     multi: true,\n *   },\n * ],\n * ```\n *\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthClientConfig {\n  private config?: AuthConfig;\n\n  constructor(@Optional() @Inject(AuthConfigService) config?: AuthConfig) {\n    if (config) {\n      this.set(config);\n    }\n  }\n\n  /**\n   * Sets configuration to be read by other consumers of the service (see usage notes)\n   *\n   * @param config The configuration to set\n   */\n  set(config: AuthConfig): void {\n    this.config = config;\n  }\n\n  /**\n   * Gets the config that has been set by other consumers of the service\n   */\n  get(): AuthConfig {\n    return this.config as AuthConfig;\n  }\n}\n\n/**\n * Injection token for accessing configuration.\n *\n * @usageNotes\n *\n * Use the `Inject` decorator to access the configuration from a service or component:\n *\n * ```\n * class MyService(@Inject(AuthConfigService) config: AuthConfig) {}\n * ```\n */\nexport const AuthConfigService = new InjectionToken<AuthConfig>(\n  'auth0-angular.config'\n);\n"]}

package/{esm2015/lib/auth.guard.js → esm2020/lib/auth.guard.mjs}

@@ -25,9 +25,9 @@ export class AuthGuard {
         }));
     }
 }
-AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthGuard, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthGuard, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthGuard, decorators: [{
+AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthGuard, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthGuard, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',

package/esm2020/lib/auth.interceptor.mjs

@@ -0,0 +1,134 @@
+import { from, of, iif, throwError } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { isHttpInterceptorRouteConfig, } from './auth.config';
+import { switchMap, first, concatMap, catchError, tap, filter, mergeMap, mapTo, pluck, } from 'rxjs/operators';
+import { Auth0ClientService } from './auth.client';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.config";
+import * as i2 from "./auth.state";
+import * as i3 from "./auth.service";
+import * as i4 from "@auth0/auth0-spa-js";
+const waitUntil = (signal$) => (source$) => source$.pipe(mergeMap((value) => signal$.pipe(first(), mapTo(value))));
+export class AuthHttpInterceptor {
+    constructor(configFactory, auth0Client, authState, authService) {
+        this.configFactory = configFactory;
+        this.auth0Client = auth0Client;
+        this.authState = authState;
+        this.authService = authService;
+    }
+    intercept(req, next) {
+        const config = this.configFactory.get();
+        if (!config.httpInterceptor?.allowedList) {
+            return next.handle(req);
+        }
+        const isLoaded$ = this.authService.isLoading$.pipe(filter((isLoading) => !isLoading));
+        return this.findMatchingRoute(req, config.httpInterceptor).pipe(concatMap((route) => iif(
+        // Check if a route was matched
+        () => route !== null, 
+        // If we have a matching route, call getTokenSilently and attach the token to the
+        // outgoing request
+        of(route).pipe(waitUntil(isLoaded$), pluck('tokenOptions'), concatMap((options) => this.getAccessTokenSilently(options).pipe(catchError((err) => {
+            if (this.allowAnonymous(route, err)) {
+                return of('');
+            }
+            this.authState.setError(err);
+            return throwError(err);
+        }))), switchMap((token) => {
+            // Clone the request and attach the bearer token
+            const clone = token
+                ? req.clone({
+                    headers: req.headers.set('Authorization', `Bearer ${token}`),
+                })
+                : req;
+            return next.handle(clone);
+        })), 
+        // If the URI being called was not found in our httpInterceptor config, simply
+        // pass the request through without attaching a token
+        next.handle(req))));
+    }
+    /**
+     * Duplicate of AuthService.getAccessTokenSilently, but with a slightly different error handling.
+     * Only used internally in the interceptor.
+     *
+     * @param options The options for configuring the token fetch.
+     */
+    getAccessTokenSilently(options) {
+        return of(this.auth0Client).pipe(concatMap((client) => client.getTokenSilently(options)), tap((token) => this.authState.setAccessToken(token)), catchError((error) => {
+            this.authState.refresh();
+            return throwError(error);
+        }));
+    }
+    /**
+     * Strips the query and fragment from the given uri
+     *
+     * @param uri The uri to remove the query and fragment from
+     */
+    stripQueryFrom(uri) {
+        if (uri.indexOf('?') > -1) {
+            uri = uri.substr(0, uri.indexOf('?'));
+        }
+        if (uri.indexOf('#') > -1) {
+            uri = uri.substr(0, uri.indexOf('#'));
+        }
+        return uri;
+    }
+    /**
+     * Determines whether the specified route can have an access token attached to it, based on matching the HTTP request against
+     * the interceptor route configuration.
+     *
+     * @param route The route to test
+     * @param request The HTTP request
+     */
+    canAttachToken(route, request) {
+        const testPrimitive = (value) => {
+            if (!value) {
+                return false;
+            }
+            const requestPath = this.stripQueryFrom(request.url);
+            if (value === requestPath) {
+                return true;
+            }
+            // If the URL ends with an asterisk, match using startsWith.
+            return (value.indexOf('*') === value.length - 1 &&
+                request.url.startsWith(value.substr(0, value.length - 1)));
+        };
+        if (isHttpInterceptorRouteConfig(route)) {
+            if (route.httpMethod && route.httpMethod !== request.method) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (!route.uri && !route.uriMatcher) {
+                console.warn('Either a uri or uriMatcher is required when configuring the HTTP interceptor.');
+            }
+            return route.uriMatcher
+                ? route.uriMatcher(request.url)
+                : testPrimitive(route.uri);
+        }
+        return testPrimitive(route);
+    }
+    /**
+     * Tries to match a route from the SDK configuration to the HTTP request.
+     * If a match is found, the route configuration is returned.
+     *
+     * @param request The Http request
+     * @param config HttpInterceptorConfig
+     */
+    findMatchingRoute(request, config) {
+        return from(config.allowedList).pipe(first((route) => this.canAttachToken(route, request), null));
+    }
+    allowAnonymous(route, err) {
+        return (!!route &&
+            isHttpInterceptorRouteConfig(route) &&
+            !!route.allowAnonymous &&
+            ['login_required', 'consent_required'].includes(err.error));
+    }
+}
+AuthHttpInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthHttpInterceptor, deps: [{ token: i1.AuthClientConfig }, { token: Auth0ClientService }, { token: i2.AuthState }, { token: i3.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthHttpInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthHttpInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthHttpInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AuthClientConfig }, { type: i4.Auth0Client, decorators: [{
+                    type: Inject,
+                    args: [Auth0ClientService]
+                }] }, { type: i2.AuthState }, { type: i3.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.js","sourceRoot":"","sources":["../../../../projects/auth0-angular/src/lib/auth.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpInterceptor,\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n} from '@angular/common/http';\n\nimport { Observable, from, of, iif, throwError } from 'rxjs';\nimport { Inject, Injectable } from '@angular/core';\n\nimport {\n  ApiRouteDefinition,\n  isHttpInterceptorRouteConfig,\n  AuthClientConfig,\n  HttpInterceptorConfig,\n} from './auth.config';\n\nimport {\n  switchMap,\n  first,\n  concatMap,\n  catchError,\n  tap,\n  filter,\n  mergeMap,\n  mapTo,\n  pluck,\n} from 'rxjs/operators';\nimport { Auth0Client, GetTokenSilentlyOptions } from '@auth0/auth0-spa-js';\nimport { Auth0ClientService } from './auth.client';\nimport { AuthState } from './auth.state';\nimport { AuthService } from './auth.service';\n\nconst waitUntil = <TSignal>(signal$: Observable<TSignal>) => <TSource>(\n  source$: Observable<TSource>\n) => source$.pipe(mergeMap((value) => signal$.pipe(first(), mapTo(value))));\n\n@Injectable()\nexport class AuthHttpInterceptor implements HttpInterceptor {\n  constructor(\n    private configFactory: AuthClientConfig,\n    @Inject(Auth0ClientService) private auth0Client: Auth0Client,\n    private authState: AuthState,\n    private authService: AuthService,\n  ) {}\n\n  intercept(\n    req: HttpRequest<any>,\n    next: HttpHandler\n  ): Observable<HttpEvent<any>> {\n    const config = this.configFactory.get();\n    if (!config.httpInterceptor?.allowedList) {\n      return next.handle(req);\n    }\n\n    const isLoaded$ = this.authService.isLoading$.pipe(\n      filter((isLoading) => !isLoading),\n    );\n\n    return this.findMatchingRoute(req, config.httpInterceptor).pipe(\n      concatMap((route) =>\n        iif(\n          // Check if a route was matched\n          () => route !== null,\n          // If we have a matching route, call getTokenSilently and attach the token to the\n          // outgoing request\n          of(route).pipe(\n            waitUntil(isLoaded$),\n            pluck('tokenOptions'),\n            concatMap<GetTokenSilentlyOptions, Observable<string>>((options) =>\n              this.getAccessTokenSilently(options).pipe(\n                catchError((err) => {\n                  if (this.allowAnonymous(route, err)) {\n                    return of('');\n                  }\n\n                  this.authState.setError(err);\n                  return throwError(err);\n                })\n              )\n            ),\n            switchMap((token: string) => {\n              // Clone the request and attach the bearer token\n              const clone = token\n                ? req.clone({\n                    headers: req.headers.set(\n                      'Authorization',\n                      `Bearer ${token}`\n                    ),\n                  })\n                : req;\n\n              return next.handle(clone);\n            })\n          ),\n          // If the URI being called was not found in our httpInterceptor config, simply\n          // pass the request through without attaching a token\n          next.handle(req)\n        )\n      )\n    );\n  }\n\n  /**\n   * Duplicate of AuthService.getAccessTokenSilently, but with a slightly different error handling.\n   * Only used internally in the interceptor.\n   *\n   * @param options The options for configuring the token fetch.\n   */\n  private getAccessTokenSilently(\n    options?: GetTokenSilentlyOptions\n  ): Observable<string> {\n    return of(this.auth0Client).pipe(\n      concatMap((client) => client.getTokenSilently(options)),\n      tap((token) => this.authState.setAccessToken(token)),\n      catchError((error) => {\n        this.authState.refresh();\n        return throwError(error);\n      })\n    );\n  }\n\n  /**\n   * Strips the query and fragment from the given uri\n   *\n   * @param uri The uri to remove the query and fragment from\n   */\n  private stripQueryFrom(uri: string): string {\n    if (uri.indexOf('?') > -1) {\n      uri = uri.substr(0, uri.indexOf('?'));\n    }\n\n    if (uri.indexOf('#') > -1) {\n      uri = uri.substr(0, uri.indexOf('#'));\n    }\n\n    return uri;\n  }\n\n  /**\n   * Determines whether the specified route can have an access token attached to it, based on matching the HTTP request against\n   * the interceptor route configuration.\n   *\n   * @param route The route to test\n   * @param request The HTTP request\n   */\n  private canAttachToken(\n    route: ApiRouteDefinition,\n    request: HttpRequest<any>\n  ): boolean {\n    const testPrimitive = (value: string | undefined): boolean => {\n      if (!value) {\n        return false;\n      }\n\n      const requestPath = this.stripQueryFrom(request.url);\n\n      if (value === requestPath) {\n        return true;\n      }\n\n      // If the URL ends with an asterisk, match using startsWith.\n      return (\n        value.indexOf('*') === value.length - 1 &&\n        request.url.startsWith(value.substr(0, value.length - 1))\n      );\n    };\n\n    if (isHttpInterceptorRouteConfig(route)) {\n      if (route.httpMethod && route.httpMethod !== request.method) {\n        return false;\n      }\n\n      /* istanbul ignore if */\n      if (!route.uri && !route.uriMatcher) {\n        console.warn(\n          'Either a uri or uriMatcher is required when configuring the HTTP interceptor.'\n        );\n      }\n\n      return route.uriMatcher\n        ? route.uriMatcher(request.url)\n        : testPrimitive(route.uri);\n    }\n\n    return testPrimitive(route);\n  }\n\n  /**\n   * Tries to match a route from the SDK configuration to the HTTP request.\n   * If a match is found, the route configuration is returned.\n   *\n   * @param request The Http request\n   * @param config HttpInterceptorConfig\n   */\n  private findMatchingRoute(\n    request: HttpRequest<any>,\n    config: HttpInterceptorConfig\n  ): Observable<ApiRouteDefinition | null> {\n    return from(config.allowedList).pipe(\n      first((route) => this.canAttachToken(route, request), null)\n    );\n  }\n\n  private allowAnonymous(route: ApiRouteDefinition | null, err: any): boolean {\n    return (\n      !!route &&\n      isHttpInterceptorRouteConfig(route) &&\n      !!route.allowAnonymous &&\n      ['login_required', 'consent_required'].includes(err.error)\n    );\n  }\n}\n"]}

package/esm2020/lib/auth.module.mjs

@@ -0,0 +1,39 @@
+import { NgModule } from '@angular/core';
+import { AuthService } from './auth.service';
+import { AuthConfigService, AuthClientConfig } from './auth.config';
+import { Auth0ClientService, Auth0ClientFactory } from './auth.client';
+import { AuthGuard } from './auth.guard';
+import * as i0 from "@angular/core";
+export class AuthModule {
+    /**
+     * Initialize the authentication module system. Configuration can either be specified here,
+     * or by calling AuthClientConfig.set (perhaps from an APP_INITIALIZER factory function).
+     *
+     * @param config The optional configuration for the SDK.
+     */
+    static forRoot(config) {
+        return {
+            ngModule: AuthModule,
+            providers: [
+                AuthService,
+                AuthGuard,
+                {
+                    provide: AuthConfigService,
+                    useValue: config,
+                },
+                {
+                    provide: Auth0ClientService,
+                    useFactory: Auth0ClientFactory.createClient,
+                    deps: [AuthClientConfig],
+                },
+            ],
+        };
+    }
+}
+AuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthModule });
+AuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AuthModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hdXRoMC1hbmd1bGFyL3NyYy9saWIvYXV0aC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBdUIsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBYyxpQkFBaUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNoRixPQUFPLEVBQUUsa0JBQWtCLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdkUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGNBQWMsQ0FBQzs7QUFHekMsTUFBTSxPQUFPLFVBQVU7SUFDckI7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQW1CO1FBQ2hDLE9BQU87WUFDTCxRQUFRLEVBQUUsVUFBVTtZQUNwQixTQUFTLEVBQUU7Z0JBQ1QsV0FBVztnQkFDWCxTQUFTO2dCQUNUO29CQUNFLE9BQU8sRUFBRSxpQkFBaUI7b0JBQzFCLFFBQVEsRUFBRSxNQUFNO2lCQUNqQjtnQkFDRDtvQkFDRSxPQUFPLEVBQUUsa0JBQWtCO29CQUMzQixVQUFVLEVBQUUsa0JBQWtCLENBQUMsWUFBWTtvQkFDM0MsSUFBSSxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQ3pCO2FBQ0Y7U0FDRixDQUFDO0lBQ0osQ0FBQzs7d0dBeEJVLFVBQVU7eUdBQVYsVUFBVTt5R0FBVixVQUFVOzRGQUFWLFVBQVU7a0JBRHRCLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTW9kdWxlV2l0aFByb3ZpZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQXV0aFNlcnZpY2UgfSBmcm9tICcuL2F1dGguc2VydmljZSc7XG5pbXBvcnQgeyBBdXRoQ29uZmlnLCBBdXRoQ29uZmlnU2VydmljZSwgQXV0aENsaWVudENvbmZpZyB9IGZyb20gJy4vYXV0aC5jb25maWcnO1xuaW1wb3J0IHsgQXV0aDBDbGllbnRTZXJ2aWNlLCBBdXRoMENsaWVudEZhY3RvcnkgfSBmcm9tICcuL2F1dGguY2xpZW50JztcbmltcG9ydCB7IEF1dGhHdWFyZCB9IGZyb20gJy4vYXV0aC5ndWFyZCc7XG5cbkBOZ01vZHVsZSgpXG5leHBvcnQgY2xhc3MgQXV0aE1vZHVsZSB7XG4gIC8qKlxuICAgKiBJbml0aWFsaXplIHRoZSBhdXRoZW50aWNhdGlvbiBtb2R1bGUgc3lzdGVtLiBDb25maWd1cmF0aW9uIGNhbiBlaXRoZXIgYmUgc3BlY2lmaWVkIGhlcmUsXG4gICAqIG9yIGJ5IGNhbGxpbmcgQXV0aENsaWVudENvbmZpZy5zZXQgKHBlcmhhcHMgZnJvbSBhbiBBUFBfSU5JVElBTElaRVIgZmFjdG9yeSBmdW5jdGlvbikuXG4gICAqXG4gICAqIEBwYXJhbSBjb25maWcgVGhlIG9wdGlvbmFsIGNvbmZpZ3VyYXRpb24gZm9yIHRoZSBTREsuXG4gICAqL1xuICBzdGF0aWMgZm9yUm9vdChjb25maWc/OiBBdXRoQ29uZmlnKTogTW9kdWxlV2l0aFByb3ZpZGVyczxBdXRoTW9kdWxlPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgIG5nTW9kdWxlOiBBdXRoTW9kdWxlLFxuICAgICAgcHJvdmlkZXJzOiBbXG4gICAgICAgIEF1dGhTZXJ2aWNlLFxuICAgICAgICBBdXRoR3VhcmQsXG4gICAgICAgIHtcbiAgICAgICAgICBwcm92aWRlOiBBdXRoQ29uZmlnU2VydmljZSxcbiAgICAgICAgICB1c2VWYWx1ZTogY29uZmlnLFxuICAgICAgICB9LFxuICAgICAgICB7XG4gICAgICAgICAgcHJvdmlkZTogQXV0aDBDbGllbnRTZXJ2aWNlLFxuICAgICAgICAgIHVzZUZhY3Rvcnk6IEF1dGgwQ2xpZW50RmFjdG9yeS5jcmVhdGVDbGllbnQsXG4gICAgICAgICAgZGVwczogW0F1dGhDbGllbnRDb25maWddLFxuICAgICAgICB9LFxuICAgICAgXSxcbiAgICB9O1xuICB9XG59XG4iXX0=