@auth0/auth0-angular 2.2.3 → 2.3.0

package/README.md

@@ -22,7 +22,7 @@ A library for integrating [Auth0](https://auth0.com) into an Angular application
 
 ### Requirements
 
-This project only supports the [actively supported versions of Angular as stated in the Angular documentation](https://angular.io/guide/releases#actively-supported-versions). Whilst other versions might be compatible they are not actively supported.
+This project only supports the [actively supported versions of Angular as stated in the Angular documentation](https://angular.dev/reference/releases#actively-supported-versions). Whilst other versions might be compatible they are not actively supported.
 
 ### Installation
 

package/esm2022/lib/abstract-navigator.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AbstractNavigator {
+    constructor(location, injector) {
+        this.location = location;
+        try {
+            this.router = injector.get(Router);
+        }
+        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) {
+        if (this.router) {
+            this.router.navigateByUrl(url);
+            return;
+        }
+        this.location.replaceState(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractNavigator, deps: [{ token: i1.Location }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractNavigator, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractNavigator, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Location }, { type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtbmF2aWdhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYXV0aDAtYW5ndWxhci9zcmMvbGliL2Fic3RyYWN0LW5hdmlnYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3JELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7O0FBTXpDLE1BQU0sT0FBTyxpQkFBaUI7SUFHNUIsWUFBb0IsUUFBa0IsRUFBRSxRQUFrQjtRQUF0QyxhQUFRLEdBQVIsUUFBUSxDQUFVO1FBQ3BDLElBQUksQ0FBQztZQUNILElBQUksQ0FBQyxNQUFNLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNyQyxDQUFDO1FBQUMsTUFBTSxDQUFDLENBQUEsQ0FBQztJQUNaLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILGFBQWEsQ0FBQyxHQUFXO1FBQ3ZCLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ2hCLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBRS9CLE9BQU87UUFDVCxDQUFDO1FBRUQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQzsrR0F2QlUsaUJBQWlCO21IQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs7NEZBRVAsaUJBQWlCO2tCQUg3QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSb3V0ZXIgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgTG9jYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgQWJzdHJhY3ROYXZpZ2F0b3Ige1xuICBwcml2YXRlIHJlYWRvbmx5IHJvdXRlcj86IFJvdXRlcjtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGxvY2F0aW9uOiBMb2NhdGlvbiwgaW5qZWN0b3I6IEluamVjdG9yKSB7XG4gICAgdHJ5IHtcbiAgICAgIHRoaXMucm91dGVyID0gaW5qZWN0b3IuZ2V0KFJvdXRlcik7XG4gICAgfSBjYXRjaCB7fVxuICB9XG5cbiAgLyoqXG4gICAqIE5hdmlnYXRlcyB0byB0aGUgc3BlY2lmaWVkIHVybC4gVGhlIHJvdXRlciB3aWxsIGJlIHVzZWQgaWYgb25lIGlzIGF2YWlsYWJsZSwgb3RoZXJ3aXNlIGl0IGZhbGxzIGJhY2tcbiAgICogdG8gYHdpbmRvdy5oaXN0b3J5LnJlcGxhY2VTdGF0ZWAuXG4gICAqXG4gICAqIEBwYXJhbSB1cmwgVGhlIHVybCB0byBuYXZpZ2F0ZSB0b1xuICAgKi9cbiAgbmF2aWdhdGVCeVVybCh1cmw6IHN0cmluZyk6IHZvaWQge1xuICAgIGlmICh0aGlzLnJvdXRlcikge1xuICAgICAgdGhpcy5yb3V0ZXIubmF2aWdhdGVCeVVybCh1cmwpO1xuXG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdGhpcy5sb2NhdGlvbi5yZXBsYWNlU3RhdGUodXJsKTtcbiAgfVxufVxuIl19

package/esm2022/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/esm2022/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';
+}
+/**
+ * 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');
+/**
+ * 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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthClientConfig, deps: [{ token: AuthConfigService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthClientConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthClientConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AuthConfigService]
+                }] }] });
+//# 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;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CACjD,sBAAsB,CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,MAAM,OAAO,gBAAgB;IAG3B,YAAmD,MAAmB;QACpE,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnB,CAAC;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;+GAvBU,gBAAgB,kBAGK,iBAAiB;mHAHtC,gBAAgB,cADH,MAAM;;4FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;0BAInB,QAAQ;;0BAAI,MAAM;2BAAC,iBAAiB","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 * 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\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"]}

package/esm2022/lib/auth.guard.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { take, switchMap, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+export class AuthGuard {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    canLoad(route, segments) {
+        return this.auth.isAuthenticated$.pipe(take(1));
+    }
+    canActivate(next, state) {
+        return this.redirectIfUnauthenticated(state);
+    }
+    canActivateChild(childRoute, state) {
+        return this.redirectIfUnauthenticated(state);
+    }
+    redirectIfUnauthenticated(state) {
+        return this.auth.isAuthenticated$.pipe(switchMap((loggedIn) => {
+            if (!loggedIn) {
+                return this.auth
+                    .loginWithRedirect({
+                    appState: { target: state.url },
+                })
+                    .pipe(map(() => false));
+            }
+            return of(true);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthGuard, deps: [{ token: i1.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2F1dGgwLWFuZ3VsYXIvc3JjL2xpYi9hdXRoLmd1YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFPM0MsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN0QyxPQUFPLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7O0FBTXRELE1BQU0sT0FBTyxTQUFTO0lBQ3BCLFlBQW9CLElBQWlCO1FBQWpCLFNBQUksR0FBSixJQUFJLENBQWE7SUFBRyxDQUFDO0lBRXpDLE9BQU8sQ0FBQyxLQUFZLEVBQUUsUUFBc0I7UUFDMUMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRUQsV0FBVyxDQUNULElBQTRCLEVBQzVCLEtBQTBCO1FBRTFCLE9BQU8sSUFBSSxDQUFDLHlCQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9DLENBQUM7SUFFRCxnQkFBZ0IsQ0FDZCxVQUFrQyxFQUNsQyxLQUEwQjtRQUUxQixPQUFPLElBQUksQ0FBQyx5QkFBeUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRU8seUJBQXlCLENBQy9CLEtBQTBCO1FBRTFCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQ3BDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO1lBQ3JCLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDZCxPQUFPLElBQUksQ0FBQyxJQUFJO3FCQUNiLGlCQUFpQixDQUFDO29CQUNqQixRQUFRLEVBQUUsRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLEdBQUcsRUFBRTtpQkFDaEMsQ0FBQztxQkFDRCxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7WUFDNUIsQ0FBQztZQUNELE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2xCLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDOytHQXBDVSxTQUFTO21IQUFULFNBQVMsY0FGUixNQUFNOzs0RkFFUCxTQUFTO2tCQUhyQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXG4gIFJvdXRlclN0YXRlU25hcHNob3QsXG4gIFJvdXRlLFxuICBVcmxTZWdtZW50LFxufSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IHRha2UsIHN3aXRjaE1hcCwgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgQXV0aFNlcnZpY2UgfSBmcm9tICcuL2F1dGguc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBBdXRoR3VhcmQge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGF1dGg6IEF1dGhTZXJ2aWNlKSB7fVxuXG4gIGNhbkxvYWQocm91dGU6IFJvdXRlLCBzZWdtZW50czogVXJsU2VnbWVudFtdKTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMuYXV0aC5pc0F1dGhlbnRpY2F0ZWQkLnBpcGUodGFrZSgxKSk7XG4gIH1cblxuICBjYW5BY3RpdmF0ZShcbiAgICBuZXh0OiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LFxuICAgIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90XG4gICk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiB0aGlzLnJlZGlyZWN0SWZVbmF1dGhlbnRpY2F0ZWQoc3RhdGUpO1xuICB9XG5cbiAgY2FuQWN0aXZhdGVDaGlsZChcbiAgICBjaGlsZFJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LFxuICAgIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90XG4gICk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiB0aGlzLnJlZGlyZWN0SWZVbmF1dGhlbnRpY2F0ZWQoc3RhdGUpO1xuICB9XG5cbiAgcHJpdmF0ZSByZWRpcmVjdElmVW5hdXRoZW50aWNhdGVkKFxuICAgIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90XG4gICk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiB0aGlzLmF1dGguaXNBdXRoZW50aWNhdGVkJC5waXBlKFxuICAgICAgc3dpdGNoTWFwKChsb2dnZWRJbikgPT4ge1xuICAgICAgICBpZiAoIWxvZ2dlZEluKSB7XG4gICAgICAgICAgcmV0dXJuIHRoaXMuYXV0aFxuICAgICAgICAgICAgLmxvZ2luV2l0aFJlZGlyZWN0KHtcbiAgICAgICAgICAgICAgYXBwU3RhdGU6IHsgdGFyZ2V0OiBzdGF0ZS51cmwgfSxcbiAgICAgICAgICAgIH0pXG4gICAgICAgICAgICAucGlwZShtYXAoKCkgPT4gZmFsc2UpKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gb2YodHJ1ZSk7XG4gICAgICB9KVxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/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', 'missing_refresh_token'].includes(err.error));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpInterceptor, deps: [{ token: i1.AuthClientConfig }, { token: Auth0ClientService }, { token: i2.AuthState }, { token: i3.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ 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 =\n  <TSignal>(signal$: Observable<TSignal>) =>\n  <TSource>(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', 'missing_refresh_token'].includes(\n        err.error\n      )\n    );\n  }\n}\n"]}

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

@@ -29,11 +29,11 @@ export class AuthModule {
             ],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AuthModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule }); }
 }
-AuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthModule });
-AuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: AuthModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, decorators: [{
             type: NgModule
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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