keycloak-angular 8.4.0 → 9.2.0

package/README.md

@@ -4,7 +4,7 @@
 [![License: MIT][license-mit-badge]][license-mit]
 [![Build Status][build-badge]][build]
 [![Known Vulnerabilities][vulnerabilities-badge]][vulnerabilities]
-[![npm version][npm-version-badge]][npm-version]
+[![npm version][npm-version-badge]][npm]
 [![npm][npm-badge]][npm]
 [![All Contributors][contributors-badge]](#contributors)
 [![Discord][discord-badge]][discord]
@@ -51,13 +51,14 @@ Note that `keycloak-js` is a peer dependency of Keycloak Angular. This change al
 
 ### Versions
 
-| Angular     | keycloak-angular | keycloak-js               | Support             |
-| :---------: | :--------------: | :-----------------------: | :-----------------: |
-| 11.x - 12.x | 8.4.x            | 10 - 15                   | Bugs / New Features |
-| 10.x        | 8.x.x            | 10 - 11                   | Bugs                |
-|  9.x        | 7.3.x            | 3.4.3 - 10 (excluding v7) | Bugs                |
+|   Angular   | keycloak-angular | keycloak-js |       Support       |
+| :---------: | :--------------: | :---------: | :-----------------: |
+|    13.x     |      9.x.x       |   10 - 16   | Bugs / New Features |
+| 11.x - 12.x |      8.4.0       |   10 - 15   |        None         |
 
-We try to support the same Angular versions that are [supported](https://angular.io/guide/releases#support-policy-and-schedule) by the Angular team. That said, it's always best to keep up to date with the latest version of Angular for optimal support.
+Only the latest version of Angular in the table above is actively supported. This is due to the fact that compilation of Angular libraries is [incompatible between major versions](https://angular.io/guide/creating-libraries#ensuring-library-version-compatibility).
+
+_Note_: In keycloak-angular **v.9**, it is needed to add `allowSyntheticDefaultImports: true` in the tsconfig.json file in your project. There is an [issue in the keycloak project](https://github.com/keycloak/keycloak/issues/9045) to update the typescript definitions file and solve the problem.
 
 #### Choosing the right keycloak-js version
 
@@ -84,13 +85,13 @@ function initializeKeycloak(keycloak: KeycloakService) {
       config: {
         url: 'http://localhost:8080/auth',
         realm: 'your-realm',
-        clientId: 'your-client-id',
+        clientId: 'your-client-id'
       },
       initOptions: {
         onLoad: 'check-sso',
         silentCheckSsoRedirectUri:
-          window.location.origin + '/assets/silent-check-sso.html',
-      },
+          window.location.origin + '/assets/silent-check-sso.html'
+      }
     });
 }
 
@@ -102,10 +103,10 @@ function initializeKeycloak(keycloak: KeycloakService) {
       provide: APP_INITIALIZER,
       useFactory: initializeKeycloak,
       multi: true,
-      deps: [KeycloakService],
-    },
+      deps: [KeycloakService]
+    }
   ],
-  bootstrap: [AppComponent],
+  bootstrap: [AppComponent]
 })
 export class AppModule {}
 ```
@@ -143,12 +144,12 @@ import { Injectable } from '@angular/core';
 import {
   ActivatedRouteSnapshot,
   Router,
-  RouterStateSnapshot,
+  RouterStateSnapshot
 } from '@angular/router';
 import { KeycloakAuthGuard, KeycloakService } from 'keycloak-angular';
 
 @Injectable({
-  providedIn: 'root',
+  providedIn: 'root'
 })
 export class AuthGuard extends KeycloakAuthGuard {
   constructor(
@@ -165,7 +166,7 @@ export class AuthGuard extends KeycloakAuthGuard {
     // Force the user to log in if currently unauthenticated.
     if (!this.authenticated) {
       await this.keycloak.login({
-        redirectUri: window.location.origin + state.url,
+        redirectUri: window.location.origin + state.url
       });
     }
 
@@ -185,18 +186,44 @@ export class AuthGuard extends KeycloakAuthGuard {
 
 ## HttpClient Interceptor
 
-By default all HttpClient requests will add the Authorization header in the format of: Authorization: Bearer **_TOKEN_**.
+By default, all HttpClient requests will add the Authorization header in the format of: `Authorization: Bearer **_TOKEN_**`.
 
-There is also the possibility to exclude a list of URLs that should not have the authorization header. The excluded list must be provided in the keycloak initialization. For example:
+There is also the possibility to exclude requests that should not have the authorization header. This is accomplished by implementing the `shouldAddToken` method in the keycloak initialization. For example, the configuration below will not add the token to `GET` requests that match the paths `/assets` or `/clients/public`:
 
 ```ts
 await keycloak.init({
   config: {
     url: 'http://localhost:8080/auth',
     realm: 'your-realm',
-    clientId: 'your-client-id',
+    clientId: 'your-client-id'
+  },
+  shouldAddToken: (request) => {
+    const { method, url } = request;
+
+    const isGetRequest = 'GET' === method.toUpperCase();
+    const acceptablePaths = ['/assets', '/clients/public'];
+    const isAcceptablePathMatch = urls.some((path) => url.includes(path));
+
+    return !(isGetRequest && isAcceptablePathMatch);
+  }
+});
+```
+
+In the case where your application frequently polls an authenticated endpoint, you will find that users will not be logged out automatically over time. If that functionality is not desirable, you can add an http header to the polling requests then configure the `shouldUpdateToken` option in the keycloak initialization.
+
+In the example below, any http requests with the header `token-update: false` will not trigger the user's keycloak token to be updated.
+
+```ts
+await keycloak.init({
+  config: {
+    url: 'http://localhost:8080/auth',
+    realm: 'your-realm',
+    clientId: 'your-client-id'
   },
   bearerExcludedUrls: ['/assets', '/clients/public'],
+  shouldUpdateToken: (request) => {
+    return !request.headers.get('token-update') === 'false';
+  }
 });
 ```
 
@@ -208,7 +235,7 @@ For example you make keycloak-angular auto refreshing your access token when exp
 
 ```ts
 keycloakService.keycloakEvents$.subscribe({
-  next: e => {
+  next: (e) => {
     if (e.type == KeycloakEventType.OnTokenExpired) {
       keycloakService.updateToken(20);
     }
@@ -234,17 +261,16 @@ document.
 **keycloak-angular** is licensed under the **[MIT license](LICENSE)**.
 
 <!-- prettier-ignore-start -->
-[license-mit-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-mit-badge]: https://img.shields.io/badge/License-MIT-yellow
 [license-mit]: https://opensource.org/licenses/MIT
-[build-badge]: https://travis-ci.org/mauriciovigolo/keycloak-angular.svg?branch=master
-[build]: https://travis-ci.org/mauriciovigolo/keycloak-angular
-[vulnerabilities-badge]: https://snyk.io/test/github/mauriciovigolo/keycloak-angular/badge.svg
+[build-badge]: https://img.shields.io/github/workflow/status/mauriciovigolo/keycloak-angular/CI?label=CI&logo=github
+[build]: https://github.com/mauriciovigolo/keycloak-angular/actions/workflows/main.yml
+[vulnerabilities-badge]: https://img.shields.io/snyk/vulnerabilities/github/mauriciovigolo/keycloak-angular?logo=snyk
 [vulnerabilities]: https://snyk.io/test/github/mauriciovigolo/keycloak-angular
-[npm-version-badge]: https://badge.fury.io/js/keycloak-angular.svg
-[npm-version]: https://badge.fury.io/js/keycloak-angular
-[npm-badge]: https://img.shields.io/npm/dm/keycloak-angular.svg
+[npm-version-badge]: https://img.shields.io/npm/v/keycloak-angular
+[npm-badge]: https://img.shields.io/npm/dm/keycloak-angular
 [npm]: https://www.npmjs.com/package/keycloak-angular
-[contributors-badge]: https://img.shields.io/badge/all_contributors-5-orange.svg?style=flat-square
-[discord-badge]: https://img.shields.io/discord/790617227853692958.svg?color=7389D8&labelColor=6A7EC2&logo=discord&logoColor=ffffff&style=flat-square
+[contributors-badge]: https://img.shields.io/badge/all_contributors-5-orange
+[discord-badge]: https://img.shields.io/discord/790617227853692958?color=7389d8&labelColor=6a7ec2&logo=discord&logoColor=fff
 [discord]: https://discord.gg/mmzEhYXXDG
-<!-- prettier-ignore-end -->
+<!-- prettier-ignore-end -->

package/esm2020/lib/core/core.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { KeycloakService } from './services/keycloak.service';
+import { KeycloakBearerInterceptor } from './interceptors/keycloak-bearer.interceptor';
+import * as i0 from "@angular/core";
+export class CoreModule {
+}
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CoreModule, imports: [CommonModule] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CoreModule, providers: [
+        KeycloakService,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: KeycloakBearerInterceptor,
+            multi: true
+        }
+    ], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    providers: [
+                        KeycloakService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: KeycloakBearerInterceptor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/interceptors/keycloak-bearer.interceptor.mjs

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/keycloak.service";
+export class KeycloakBearerInterceptor {
+    constructor(keycloak) {
+        this.keycloak = keycloak;
+    }
+    async conditionallyUpdateToken(req) {
+        if (this.keycloak.shouldUpdateToken(req)) {
+            return await this.keycloak.updateToken();
+        }
+        return true;
+    }
+    isUrlExcluded({ method, url }, { urlPattern, httpMethods }) {
+        const httpTest = httpMethods.length === 0 ||
+            httpMethods.join().indexOf(method.toUpperCase()) > -1;
+        const urlTest = urlPattern.test(url);
+        return httpTest && urlTest;
+    }
+    intercept(req, next) {
+        const { enableBearerInterceptor, excludedUrls } = this.keycloak;
+        if (!enableBearerInterceptor) {
+            return next.handle(req);
+        }
+        const shallPass = !this.keycloak.shouldAddToken(req) ||
+            excludedUrls.findIndex((item) => this.isUrlExcluded(req, item)) > -1;
+        if (shallPass) {
+            return next.handle(req);
+        }
+        return combineLatest([
+            this.conditionallyUpdateToken(req),
+            this.keycloak.isLoggedIn()
+        ]).pipe(mergeMap(([_, loggedIn]) => loggedIn
+            ? this.handleRequestWithTokenHeader(req, next)
+            : next.handle(req)));
+    }
+    handleRequestWithTokenHeader(req, next) {
+        return this.keycloak.addTokenToHeader(req.headers).pipe(mergeMap((headersWithBearer) => {
+            const kcReq = req.clone({ headers: headersWithBearer });
+            return next.handle(kcReq);
+        }));
+    }
+}
+KeycloakBearerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakBearerInterceptor, deps: [{ token: i1.KeycloakService }], target: i0.ɵɵFactoryTarget.Injectable });
+KeycloakBearerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakBearerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakBearerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/interfaces/keycloak-event.mjs

@@ -0,0 +1,12 @@
+export var KeycloakEventType;
+(function (KeycloakEventType) {
+    KeycloakEventType[KeycloakEventType["OnAuthError"] = 0] = "OnAuthError";
+    KeycloakEventType[KeycloakEventType["OnAuthLogout"] = 1] = "OnAuthLogout";
+    KeycloakEventType[KeycloakEventType["OnAuthRefreshError"] = 2] = "OnAuthRefreshError";
+    KeycloakEventType[KeycloakEventType["OnAuthRefreshSuccess"] = 3] = "OnAuthRefreshSuccess";
+    KeycloakEventType[KeycloakEventType["OnAuthSuccess"] = 4] = "OnAuthSuccess";
+    KeycloakEventType[KeycloakEventType["OnReady"] = 5] = "OnReady";
+    KeycloakEventType[KeycloakEventType["OnTokenExpired"] = 6] = "OnTokenExpired";
+    KeycloakEventType[KeycloakEventType["OnActionUpdate"] = 7] = "OnActionUpdate";
+})(KeycloakEventType || (KeycloakEventType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/interfaces/keycloak-options.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/keycloak-auth-guard.mjs

@@ -0,0 +1,17 @@
+export class KeycloakAuthGuard {
+    constructor(router, keycloakAngular) {
+        this.router = router;
+        this.keycloakAngular = keycloakAngular;
+    }
+    async canActivate(route, state) {
+        try {
+            this.authenticated = await this.keycloakAngular.isLoggedIn();
+            this.roles = await this.keycloakAngular.getUserRoles(true);
+            return await this.isAccessAllowed(route, state);
+        }
+        catch (error) {
+            throw new Error('An error happened during access validation. Details:' + error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/keycloak.service.mjs

@@ -0,0 +1,200 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { Subject, from } from 'rxjs';
+import { map } from 'rxjs/operators';
+import Keycloak from 'keycloak-js';
+import { KeycloakEventType } from '../interfaces/keycloak-event';
+import * as i0 from "@angular/core";
+export class KeycloakService {
+    constructor() {
+        this._keycloakEvents$ = new Subject();
+    }
+    bindsKeycloakEvents() {
+        this._instance.onAuthError = (errorData) => {
+            this._keycloakEvents$.next({
+                args: errorData,
+                type: KeycloakEventType.OnAuthError
+            });
+        };
+        this._instance.onAuthLogout = () => {
+            this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthLogout });
+        };
+        this._instance.onAuthRefreshSuccess = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnAuthRefreshSuccess
+            });
+        };
+        this._instance.onAuthRefreshError = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnAuthRefreshError
+            });
+        };
+        this._instance.onAuthSuccess = () => {
+            this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthSuccess });
+        };
+        this._instance.onTokenExpired = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnTokenExpired
+            });
+        };
+        this._instance.onActionUpdate = (state) => {
+            this._keycloakEvents$.next({
+                args: state,
+                type: KeycloakEventType.OnActionUpdate
+            });
+        };
+        this._instance.onReady = (authenticated) => {
+            this._keycloakEvents$.next({
+                args: authenticated,
+                type: KeycloakEventType.OnReady
+            });
+        };
+    }
+    loadExcludedUrls(bearerExcludedUrls) {
+        const excludedUrls = [];
+        for (const item of bearerExcludedUrls) {
+            let excludedUrl;
+            if (typeof item === 'string') {
+                excludedUrl = { urlPattern: new RegExp(item, 'i'), httpMethods: [] };
+            }
+            else {
+                excludedUrl = {
+                    urlPattern: new RegExp(item.url, 'i'),
+                    httpMethods: item.httpMethods
+                };
+            }
+            excludedUrls.push(excludedUrl);
+        }
+        return excludedUrls;
+    }
+    initServiceValues({ enableBearerInterceptor = true, loadUserProfileAtStartUp = false, bearerExcludedUrls = [], authorizationHeaderName = 'Authorization', bearerPrefix = 'Bearer', initOptions, updateMinValidity = 20, shouldAddToken = () => true, shouldUpdateToken = () => true }) {
+        this._enableBearerInterceptor = enableBearerInterceptor;
+        this._loadUserProfileAtStartUp = loadUserProfileAtStartUp;
+        this._authorizationHeaderName = authorizationHeaderName;
+        this._bearerPrefix = bearerPrefix.trim().concat(' ');
+        this._excludedUrls = this.loadExcludedUrls(bearerExcludedUrls);
+        this._silentRefresh = initOptions ? initOptions.flow === 'implicit' : false;
+        this._updateMinValidity = updateMinValidity;
+        this.shouldAddToken = shouldAddToken;
+        this.shouldUpdateToken = shouldUpdateToken;
+    }
+    async init(options = {}) {
+        this.initServiceValues(options);
+        const { config, initOptions } = options;
+        this._instance = Keycloak(config);
+        this.bindsKeycloakEvents();
+        const authenticated = await this._instance.init(initOptions);
+        if (authenticated && this._loadUserProfileAtStartUp) {
+            await this.loadUserProfile();
+        }
+        return authenticated;
+    }
+    async login(options = {}) {
+        await this._instance.login(options);
+        if (this._loadUserProfileAtStartUp) {
+            await this.loadUserProfile();
+        }
+    }
+    async logout(redirectUri) {
+        const options = {
+            redirectUri
+        };
+        await this._instance.logout(options);
+        this._userProfile = undefined;
+    }
+    async register(options = { action: 'register' }) {
+        await this._instance.register(options);
+    }
+    isUserInRole(role, resource) {
+        let hasRole;
+        hasRole = this._instance.hasResourceRole(role, resource);
+        if (!hasRole) {
+            hasRole = this._instance.hasRealmRole(role);
+        }
+        return hasRole;
+    }
+    getUserRoles(allRoles = true) {
+        let roles = [];
+        if (this._instance.resourceAccess) {
+            for (const key in this._instance.resourceAccess) {
+                if (this._instance.resourceAccess.hasOwnProperty(key)) {
+                    const resourceAccess = this._instance.resourceAccess[key];
+                    const clientRoles = resourceAccess['roles'] || [];
+                    roles = roles.concat(clientRoles);
+                }
+            }
+        }
+        if (allRoles && this._instance.realmAccess) {
+            const realmRoles = this._instance.realmAccess['roles'] || [];
+            roles.push(...realmRoles);
+        }
+        return roles;
+    }
+    async isLoggedIn() {
+        try {
+            return this._instance.authenticated;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    isTokenExpired(minValidity = 0) {
+        return this._instance.isTokenExpired(minValidity);
+    }
+    async updateToken() {
+        if (this._silentRefresh) {
+            if (this.isTokenExpired()) {
+                throw new Error('Failed to refresh the token, or the session is expired');
+            }
+            return true;
+        }
+        if (!this._instance) {
+            throw new Error('Keycloak Angular library is not initialized.');
+        }
+        return this._instance.updateToken(this._updateMinValidity);
+    }
+    async loadUserProfile(forceReload = false) {
+        if (this._userProfile && !forceReload) {
+            return this._userProfile;
+        }
+        if (!this._instance.authenticated) {
+            throw new Error('The user profile was not loaded as the user is not logged in.');
+        }
+        return (this._userProfile = await this._instance.loadUserProfile());
+    }
+    async getToken() {
+        return this._instance.token;
+    }
+    getUsername() {
+        if (!this._userProfile) {
+            throw new Error('User not logged in or user profile was not loaded.');
+        }
+        return this._userProfile.username;
+    }
+    clearToken() {
+        this._instance.clearToken();
+    }
+    addTokenToHeader(headers = new HttpHeaders()) {
+        return from(this.getToken()).pipe(map((token) => token
+            ? headers.set(this._authorizationHeaderName, this._bearerPrefix + token)
+            : headers));
+    }
+    getKeycloakInstance() {
+        return this._instance;
+    }
+    get excludedUrls() {
+        return this._excludedUrls;
+    }
+    get enableBearerInterceptor() {
+        return this._enableBearerInterceptor;
+    }
+    get keycloakEvents$() {
+        return this._keycloakEvents$;
+    }
+}
+KeycloakService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+KeycloakService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keycloak.service.js","sourceRoot":"","sources":["../../../../../../projects/keycloak-angular/src/lib/core/services/keycloak.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Mauricio Gemelli Vigolo and contributors.\n *\n * Use of this source code is governed by a MIT-style license that can be\n * found in the LICENSE file at https://github.com/mauriciovigolo/keycloak-angular/blob/master/LICENSE.md\n */\n\nimport { Injectable } from '@angular/core';\nimport { HttpHeaders, HttpRequest } from '@angular/common/http';\n\nimport { Subject, from } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport Keycloak from 'keycloak-js';\n\nimport {\n  ExcludedUrl,\n  ExcludedUrlRegex,\n  KeycloakOptions\n} from '../interfaces/keycloak-options';\nimport { KeycloakEvent, KeycloakEventType } from '../interfaces/keycloak-event';\n\n/**\n * Service to expose existent methods from the Keycloak JS adapter, adding new\n * functionalities to improve the use of keycloak in Angular v > 4.3 applications.\n *\n * This class should be injected in the application bootstrap, so the same instance will be used\n * along the web application.\n */\n@Injectable()\nexport class KeycloakService {\n  /**\n   * Keycloak-js instance.\n   */\n  private _instance: Keycloak.KeycloakInstance;\n  /**\n   * User profile as KeycloakProfile interface.\n   */\n  private _userProfile: Keycloak.KeycloakProfile;\n  /**\n   * Flag to indicate if the bearer will not be added to the authorization header.\n   */\n  private _enableBearerInterceptor: boolean;\n  /**\n   * When the implicit flow is choosen there must exist a silentRefresh, as there is\n   * no refresh token.\n   */\n  private _silentRefresh: boolean;\n  /**\n   * Indicates that the user profile should be loaded at the keycloak initialization,\n   * just after the login.\n   */\n  private _loadUserProfileAtStartUp: boolean;\n  /**\n   * The bearer prefix that will be appended to the Authorization Header.\n   */\n  private _bearerPrefix: string;\n  /**\n   * Value that will be used as the Authorization Http Header name.\n   */\n  private _authorizationHeaderName: string;\n  /**\n   * @deprecated\n   * The excluded urls patterns that must skip the KeycloakBearerInterceptor.\n   */\n  private _excludedUrls: ExcludedUrlRegex[];\n  /**\n   * Observer for the keycloak events\n   */\n  private _keycloakEvents$: Subject<KeycloakEvent> =\n    new Subject<KeycloakEvent>();\n  /**\n   * The amount of required time remaining before expiry of the token before the token will be refreshed.\n   */\n  private _updateMinValidity: number;\n  /**\n   * Returns true if the request should have the token added to the headers by the KeycloakBearerInterceptor.\n   */\n  shouldAddToken: (request: HttpRequest<unknown>) => boolean;\n  /**\n   * Returns true if the request being made should potentially update the token.\n   */\n  shouldUpdateToken: (request: HttpRequest<unknown>) => boolean;\n\n  /**\n   * Binds the keycloak-js events to the keycloakEvents Subject\n   * which is a good way to monitor for changes, if needed.\n   *\n   * The keycloakEvents returns the keycloak-js event type and any\n   * argument if the source function provides any.\n   */\n  private bindsKeycloakEvents(): void {\n    this._instance.onAuthError = (errorData) => {\n      this._keycloakEvents$.next({\n        args: errorData,\n        type: KeycloakEventType.OnAuthError\n      });\n    };\n\n    this._instance.onAuthLogout = () => {\n      this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthLogout });\n    };\n\n    this._instance.onAuthRefreshSuccess = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnAuthRefreshSuccess\n      });\n    };\n\n    this._instance.onAuthRefreshError = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnAuthRefreshError\n      });\n    };\n\n    this._instance.onAuthSuccess = () => {\n      this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthSuccess });\n    };\n\n    this._instance.onTokenExpired = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnTokenExpired\n      });\n    };\n\n    this._instance.onActionUpdate = (state) => {\n      this._keycloakEvents$.next({\n        args: state,\n        type: KeycloakEventType.OnActionUpdate\n      });\n    };\n\n    this._instance.onReady = (authenticated) => {\n      this._keycloakEvents$.next({\n        args: authenticated,\n        type: KeycloakEventType.OnReady\n      });\n    };\n  }\n\n  /**\n   * Loads all bearerExcludedUrl content in a uniform type: ExcludedUrl,\n   * so it becomes easier to handle.\n   *\n   * @param bearerExcludedUrls array of strings or ExcludedUrl that includes\n   * the url and HttpMethod.\n   */\n  private loadExcludedUrls(\n    bearerExcludedUrls: (string | ExcludedUrl)[]\n  ): ExcludedUrlRegex[] {\n    const excludedUrls: ExcludedUrlRegex[] = [];\n    for (const item of bearerExcludedUrls) {\n      let excludedUrl: ExcludedUrlRegex;\n      if (typeof item === 'string') {\n        excludedUrl = { urlPattern: new RegExp(item, 'i'), httpMethods: [] };\n      } else {\n        excludedUrl = {\n          urlPattern: new RegExp(item.url, 'i'),\n          httpMethods: item.httpMethods\n        };\n      }\n      excludedUrls.push(excludedUrl);\n    }\n    return excludedUrls;\n  }\n\n  /**\n   * Handles the class values initialization.\n   *\n   * @param options\n   */\n  private initServiceValues({\n    enableBearerInterceptor = true,\n    loadUserProfileAtStartUp = false,\n    bearerExcludedUrls = [],\n    authorizationHeaderName = 'Authorization',\n    bearerPrefix = 'Bearer',\n    initOptions,\n    updateMinValidity = 20,\n    shouldAddToken = () => true,\n    shouldUpdateToken = () => true\n  }: KeycloakOptions): void {\n    this._enableBearerInterceptor = enableBearerInterceptor;\n    this._loadUserProfileAtStartUp = loadUserProfileAtStartUp;\n    this._authorizationHeaderName = authorizationHeaderName;\n    this._bearerPrefix = bearerPrefix.trim().concat(' ');\n    this._excludedUrls = this.loadExcludedUrls(bearerExcludedUrls);\n    this._silentRefresh = initOptions ? initOptions.flow === 'implicit' : false;\n    this._updateMinValidity = updateMinValidity;\n    this.shouldAddToken = shouldAddToken;\n    this.shouldUpdateToken = shouldUpdateToken;\n  }\n\n  /**\n   * Keycloak initialization. It should be called to initialize the adapter.\n   * Options is a object with 2 main parameters: config and initOptions. The first one\n   * will be used to create the Keycloak instance. The second one are options to initialize the\n   * keycloak instance.\n   *\n   * @param options\n   * Config: may be a string representing the keycloak URI or an object with the\n   * following content:\n   * - url: Keycloak json URL\n   * - realm: realm name\n   * - clientId: client id\n   *\n   * initOptions:\n   * Options to initialize the Keycloak adapter, matches the options as provided by Keycloak itself.\n   *\n   * enableBearerInterceptor:\n   * Flag to indicate if the bearer will added to the authorization header.\n   *\n   * loadUserProfileInStartUp:\n   * Indicates that the user profile should be loaded at the keycloak initialization,\n   * just after the login.\n   *\n   * bearerExcludedUrls:\n   * String Array to exclude the urls that should not have the Authorization Header automatically\n   * added.\n   *\n   * authorizationHeaderName:\n   * This value will be used as the Authorization Http Header name.\n   *\n   * bearerPrefix:\n   * This value will be included in the Authorization Http Header param.\n   *\n   * tokenUpdateExcludedHeaders:\n   * Array of Http Header key/value maps that should not trigger the token to be updated.\n   *\n   * updateMinValidity:\n   * This value determines if the token will be refreshed based on its expiration time.\n   *\n   * @returns\n   * A Promise with a boolean indicating if the initialization was successful.\n   */\n  public async init(options: KeycloakOptions = {}) {\n    this.initServiceValues(options);\n    const { config, initOptions } = options;\n\n    this._instance = Keycloak(config);\n    this.bindsKeycloakEvents();\n\n    const authenticated = await this._instance.init(initOptions);\n\n    if (authenticated && this._loadUserProfileAtStartUp) {\n      await this.loadUserProfile();\n    }\n\n    return authenticated;\n  }\n\n  /**\n   * Redirects to login form on (options is an optional object with redirectUri and/or\n   * prompt fields).\n   *\n   * @param options\n   * Object, where:\n   *  - redirectUri: Specifies the uri to redirect to after login.\n   *  - prompt:By default the login screen is displayed if the user is not logged-in to Keycloak.\n   * To only authenticate to the application if the user is already logged-in and not display the\n   * login page if the user is not logged-in, set this option to none. To always require\n   * re-authentication and ignore SSO, set this option to login .\n   *  - maxAge: Used just if user is already authenticated. Specifies maximum time since the\n   * authentication of user happened. If user is already authenticated for longer time than\n   * maxAge, the SSO is ignored and he will need to re-authenticate again.\n   *  - loginHint: Used to pre-fill the username/email field on the login form.\n   *  - action: If value is 'register' then user is redirected to registration page, otherwise to\n   * login page.\n   *  - locale: Specifies the desired locale for the UI.\n   * @returns\n   * A void Promise if the login is successful and after the user profile loading.\n   */\n  public async login(options: Keycloak.KeycloakLoginOptions = {}) {\n    await this._instance.login(options);\n\n    if (this._loadUserProfileAtStartUp) {\n      await this.loadUserProfile();\n    }\n  }\n\n  /**\n   * Redirects to logout.\n   *\n   * @param redirectUri\n   * Specifies the uri to redirect to after logout.\n   * @returns\n   * A void Promise if the logout was successful, cleaning also the userProfile.\n   */\n  public async logout(redirectUri?: string) {\n    const options = {\n      redirectUri\n    };\n\n    await this._instance.logout(options);\n    this._userProfile = undefined;\n  }\n\n  /**\n   * Redirects to registration form. Shortcut for login with option\n   * action = 'register'. Options are same as for the login method but 'action' is set to\n   * 'register'.\n   *\n   * @param options\n   * login options\n   * @returns\n   * A void Promise if the register flow was successful.\n   */\n  public async register(\n    options: Keycloak.KeycloakLoginOptions = { action: 'register' }\n  ) {\n    await this._instance.register(options);\n  }\n\n  /**\n   * Check if the user has access to the specified role. It will look for roles in\n   * realm and clientId, but will not check if the user is logged in for better performance.\n   *\n   * @param role\n   * role name\n   * @param resource\n   * resource name If not specified, `clientId` is used\n   * @returns\n   * A boolean meaning if the user has the specified Role.\n   */\n  isUserInRole(role: string, resource?: string): boolean {\n    let hasRole: boolean;\n    hasRole = this._instance.hasResourceRole(role, resource);\n    if (!hasRole) {\n      hasRole = this._instance.hasRealmRole(role);\n    }\n    return hasRole;\n  }\n\n  /**\n   * Return the roles of the logged user. The allRoles parameter, with default value\n   * true, will return the clientId and realm roles associated with the logged user. If set to false\n   * it will only return the user roles associated with the clientId.\n   *\n   * @param allRoles\n   * Flag to set if all roles should be returned.(Optional: default value is true)\n   * @returns\n   * Array of Roles associated with the logged user.\n   */\n  getUserRoles(allRoles: boolean = true): string[] {\n    let roles: string[] = [];\n    if (this._instance.resourceAccess) {\n      for (const key in this._instance.resourceAccess) {\n        if (this._instance.resourceAccess.hasOwnProperty(key)) {\n          const resourceAccess = this._instance.resourceAccess[key];\n          const clientRoles = resourceAccess['roles'] || [];\n          roles = roles.concat(clientRoles);\n        }\n      }\n    }\n    if (allRoles && this._instance.realmAccess) {\n      const realmRoles = this._instance.realmAccess['roles'] || [];\n      roles.push(...realmRoles);\n    }\n    return roles;\n  }\n\n  /**\n   * Check if user is logged in.\n   *\n   * @returns\n   * A boolean that indicates if the user is logged in.\n   */\n  async isLoggedIn(): Promise<boolean> {\n    try {\n      return this._instance.authenticated;\n    } catch (error) {\n      return false;\n    }\n  }\n\n  /**\n   * Returns true if the token has less than minValidity seconds left before\n   * it expires.\n   *\n   * @param minValidity\n   * Seconds left. (minValidity) is optional. Default value is 0.\n   * @returns\n   * Boolean indicating if the token is expired.\n   */\n  isTokenExpired(minValidity: number = 0): boolean {\n    return this._instance.isTokenExpired(minValidity);\n  }\n\n  /**\n   * If the token expires within _updateMinValidity seconds the token is refreshed. If the\n   * session status iframe is enabled, the session status is also checked.\n   * Returns a promise telling if the token was refreshed or not. If the session is not active\n   * anymore, the promise is rejected.\n   *\n   * @returns\n   * Promise with a boolean indicating if the token was succesfully updated.\n   */\n  public async updateToken() {\n    // TODO: this is a workaround until the silent refresh (issue #43)\n    // is not implemented, avoiding the redirect loop.\n    if (this._silentRefresh) {\n      if (this.isTokenExpired()) {\n        throw new Error(\n          'Failed to refresh the token, or the session is expired'\n        );\n      }\n\n      return true;\n    }\n\n    if (!this._instance) {\n      throw new Error('Keycloak Angular library is not initialized.');\n    }\n\n    return this._instance.updateToken(this._updateMinValidity);\n  }\n\n  /**\n   * Loads the user profile.\n   * Returns promise to set functions to be invoked if the profile was loaded\n   * successfully, or if the profile could not be loaded.\n   *\n   * @param forceReload\n   * If true will force the loadUserProfile even if its already loaded.\n   * @returns\n   * A promise with the KeycloakProfile data loaded.\n   */\n  public async loadUserProfile(forceReload = false) {\n    if (this._userProfile && !forceReload) {\n      return this._userProfile;\n    }\n\n    if (!this._instance.authenticated) {\n      throw new Error(\n        'The user profile was not loaded as the user is not logged in.'\n      );\n    }\n\n    return (this._userProfile = await this._instance.loadUserProfile());\n  }\n\n  /**\n   * Returns the authenticated token, calling updateToken to get a refreshed one if necessary.\n   */\n  public async getToken() {\n    return this._instance.token;\n  }\n\n  /**\n   * Returns the logged username.\n   *\n   * @returns\n   * The logged username.\n   */\n  public getUsername() {\n    if (!this._userProfile) {\n      throw new Error('User not logged in or user profile was not loaded.');\n    }\n\n    return this._userProfile.username;\n  }\n\n  /**\n   * Clear authentication state, including tokens. This can be useful if application\n   * has detected the session was expired, for example if updating token fails.\n   * Invoking this results in onAuthLogout callback listener being invoked.\n   */\n  clearToken(): void {\n    this._instance.clearToken();\n  }\n\n  /**\n   * Adds a valid token in header. The key & value format is:\n   * Authorization Bearer <token>.\n   * If the headers param is undefined it will create the Angular headers object.\n   *\n   * @param headers\n   * Updated header with Authorization and Keycloak token.\n   * @returns\n   * An observable with with the HTTP Authorization header and the current token.\n   */\n  public addTokenToHeader(headers: HttpHeaders = new HttpHeaders()) {\n    return from(this.getToken()).pipe(\n      map((token) =>\n        token\n          ? headers.set(\n              this._authorizationHeaderName,\n              this._bearerPrefix + token\n            )\n          : headers\n      )\n    );\n  }\n\n  /**\n   * Returns the original Keycloak instance, if you need any customization that\n   * this Angular service does not support yet. Use with caution.\n   *\n   * @returns\n   * The KeycloakInstance from keycloak-js.\n   */\n  getKeycloakInstance(): Keycloak.KeycloakInstance {\n    return this._instance;\n  }\n\n  /**\n   * @deprecated\n   * Returns the excluded URLs that should not be considered by\n   * the http interceptor which automatically adds the authorization header in the Http Request.\n   *\n   * @returns\n   * The excluded urls that must not be intercepted by the KeycloakBearerInterceptor.\n   */\n  get excludedUrls(): ExcludedUrlRegex[] {\n    return this._excludedUrls;\n  }\n\n  /**\n   * Flag to indicate if the bearer will be added to the authorization header.\n   *\n   * @returns\n   * Returns if the bearer interceptor was set to be disabled.\n   */\n  get enableBearerInterceptor(): boolean {\n    return this._enableBearerInterceptor;\n  }\n\n  /**\n   * Keycloak subject to monitor the events triggered by keycloak-js.\n   * The following events as available (as described at keycloak docs -\n   * https://www.keycloak.org/docs/latest/securing_apps/index.html#callback-events):\n   * - OnAuthError\n   * - OnAuthLogout\n   * - OnAuthRefreshError\n   * - OnAuthRefreshSuccess\n   * - OnAuthSuccess\n   * - OnReady\n   * - OnTokenExpire\n   * In each occurrence of any of these, this subject will return the event type,\n   * described at {@link KeycloakEventType} enum and the function args from the keycloak-js\n   * if provided any.\n   *\n   * @returns\n   * A subject with the {@link KeycloakEvent} which describes the event type and attaches the\n   * function args.\n   */\n  get keycloakEvents$(): Subject<KeycloakEvent> {\n    return this._keycloakEvents$;\n  }\n}\n"]}

package/esm2020/lib/keycloak-angular.module.mjs

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CoreModule } from './core/core.module';
+import * as i0 from "@angular/core";
+export class KeycloakAngularModule {
+}
+KeycloakAngularModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KeycloakAngularModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakAngularModule, imports: [CoreModule] });
+KeycloakAngularModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakAngularModule, imports: [[CoreModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: KeycloakAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CoreModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Y2xvYWstYW5ndWxhci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9rZXljbG9hay1hbmd1bGFyL3NyYy9saWIva2V5Y2xvYWstYW5ndWxhci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBS2hELE1BQU0sT0FBTyxxQkFBcUI7O2tIQUFyQixxQkFBcUI7bUhBQXJCLHFCQUFxQixZQUZ0QixVQUFVO21IQUVULHFCQUFxQixZQUZ2QixDQUFDLFVBQVUsQ0FBQzsyRkFFVixxQkFBcUI7a0JBSGpDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDO2lCQUN0QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBNYXVyaWNpbyBHZW1lbGxpIFZpZ29sbyBhbmQgY29udHJpYnV0b3JzLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGEgTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9naXRodWIuY29tL21hdXJpY2lvdmlnb2xvL2tleWNsb2FrLWFuZ3VsYXIvYmxvYi9tYXN0ZXIvTElDRU5TRS5tZFxuICovXG5cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IENvcmVNb2R1bGUgfSBmcm9tICcuL2NvcmUvY29yZS5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29yZU1vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgS2V5Y2xvYWtBbmd1bGFyTW9kdWxlIHt9XG4iXX0=