@softheon/armature 10.45.3 → 15.0.0

package/esm2020/lib/core/initializer/initializer.service.mjs

@@ -0,0 +1,189 @@
+import { Injectable, Optional } from '@angular/core';
+import { AuthConfig } from 'angular-oauth2-oidc';
+import { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';
+import * as _ from 'lodash';
+import { BehaviorSubject, throwError } from 'rxjs';
+import { languageStorageKey } from '../models/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "../../theming/services/theme.service";
+import * as i4 from "../services/base-config.service";
+import * as i5 from "angular-oauth2-oidc";
+import * as i6 from "../services/custom-auth-config.service";
+/**
+ * The startup service is used to call methods that should be run when initially loading the application
+ */
+export class Initializer {
+    /** Gets the configurations */
+    get isInitialized() {
+        return this.isInitializedBs.value;
+    }
+    /**
+     * Constructs the startup service. Include any services that should be used during startup
+     * @param http The HTTP Client
+     * @param translateService The translate service
+     * @param configService The configuration service
+     * @param oAuthService The oidc authorization service
+     * @param customAuthConfigService The service that will configure the auth config
+     */
+    constructor(http, translateService, themeService, configService, oAuthService, customAuthConfigService) {
+        this.http = http;
+        this.translateService = translateService;
+        this.themeService = themeService;
+        this.configService = configService;
+        this.oAuthService = oAuthService;
+        this.customAuthConfigService = customAuthConfigService;
+        /** The configuration behavior subject */
+        this.isInitializedBs = new BehaviorSubject(false);
+        this.isInitialized$ = this.isInitializedBs.asObservable();
+    }
+    /**
+     * Loads all data that is needed upon initial loading of the website
+     */
+    async initialize() {
+        // reads the language from local storage set in the parent app
+        // language loading
+        // Set languages for translation service
+        const lang = window.localStorage.getItem(languageStorageKey) || window.sessionStorage.getItem(languageStorageKey) || 'en';
+        this.translateService.setDefaultLang(lang);
+        this.translateService.use(lang);
+        // Adapted from https://stackoverflow.com/a/41636880
+        // Adapted from https://stackoverflow.com/a/41736293
+        // A callback used to initialize the promise. This callback is passed two arguments:
+        // a resolve callback used resolve the promise with a value or the result of another promise,
+        // and a reject callback used to reject the promise with a provided reason or error.
+        return new Promise(async (resolve, reject) => {
+            // Go through all services and complete any API calls necessary.
+            // At the end, if all works and loads as expected, resolve the promise and set startup success to true.
+            // If an issue is encountered, you can call reject() to hit the catch() code below.
+            // First, load the configurations
+            let [baseConfig, overrideConfig, baseLang, overrideLang, theme] = [JSON, JSON, JSON, JSON, JSON];
+            try {
+                [baseConfig, overrideConfig, baseLang, overrideLang, theme] = await Promise.all([
+                    this.http.get('./assets/baseline/appsettings.json').toPromise(),
+                    this.http.get('./assets/configurations/appsettings.json').toPromise(),
+                    this.http.get(`./assets/i18n/${this.translateService.currentLang}.json`).toPromise(),
+                    this.http.get(`./assets/configurations/${this.translateService.currentLang}.json`).toPromise(),
+                    this.http.get('./assets/configurations/theme.json').toPromise()
+                ]);
+                this.configService.config = _.mergeWith(baseConfig, overrideConfig, this.mergeCustomizer);
+                const configSnapShot = this.configService.config;
+                configSnapShot.theme = theme;
+                this.configService.config = configSnapShot;
+                this.translateService.setTranslation(this.translateService.currentLang, _.mergeWith(baseLang, overrideLang, this.mergeCustomizer));
+                this.themeService.initPalette(theme);
+            }
+            catch (error) {
+                // Catch any errors during the get configurations API call
+                console.error('Error Loading Configurations or Languages');
+                // Reject the promise
+                reject('error');
+                return throwError(error.error || 'Server error');
+            }
+            try {
+                if (this.customAuthConfigService) {
+                    await this.customAuthConfigService.configureAuthSettings().then(authConfig => {
+                        if (authConfig) {
+                            const config = this.configService.config.oAuthSettings;
+                            return this.login(config);
+                        }
+                        else {
+                            return Promise.resolve(false);
+                        }
+                    });
+                }
+                else {
+                    const oAuth = await this.setUpOAuth();
+                }
+            }
+            catch (error) {
+                reject(error);
+                return throwError(error);
+            }
+            this.isInitializedBs.next(true);
+            resolve(true);
+        }).catch((error) => {
+            // Catch the error
+            console.error('There was an error loading the startup configurations.');
+        });
+    }
+    /**
+     * Configure implicit flow
+     */
+    async setUpOAuth() {
+        if (this.configService.config?.oAuthSettings?.issuer) {
+            const config = this.configService.config.oAuthSettings;
+            const authConfig = new AuthConfig({
+                clientId: config.clientId,
+                redirectUri: config.redirectUri,
+                issuer: config.issuer,
+                scope: config.scope,
+                skipIssuerCheck: config.skipIssuerCheck != undefined ? config.skipIssuerCheck : true,
+                timeoutFactor: config.timeoutFactor || 0.75,
+                postLogoutRedirectUri: config.postLogoutRedirectUri,
+                loginUrl: config.loginUrl,
+                strictDiscoveryDocumentValidation: false,
+                responseType: config.responseType || 'code'
+            });
+            this.oAuthService.configure(authConfig);
+            this.oAuthService.skipIssuerCheck = true;
+            this.oAuthService.responseType = config.responseType || 'code';
+            this.oAuthService.strictDiscoveryDocumentValidation = false;
+            this.oAuthService.tokenValidationHandler = new JwksValidationHandler();
+            this.oAuthService.timeoutFactor = 0.75;
+            this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token');
+            // set initialized on start up to true
+            config.authSetOnStartup = true;
+            const parentConfig = this.configService.config;
+            parentConfig.oAuthSettings = config;
+            this.configService.config = parentConfig;
+            return this.login(config);
+        }
+        return Promise.resolve(true);
+    }
+    /**
+     * Handle Login
+     * @param config The Oidc Auth Settings
+     */
+    async login(config) {
+        if (config.requireLoginOnStartup) {
+            return this.oAuthService.loadDiscoveryDocumentAndLogin()
+                // handles the case for expired access token or invalid nonce or people bookmarking the ids login page
+                .catch(async (res) => {
+                this.oAuthService.initLoginFlow();
+                return Promise.resolve(true);
+            });
+        }
+        else {
+            return this.oAuthService.loadDiscoveryDocumentAndTryLogin()
+                // handles the case for expired access token or invalid nonce or people bookmarking the ids login page
+                .catch(async (res) => {
+                this.oAuthService.initLoginFlow();
+                return Promise.resolve(true);
+            });
+        }
+    }
+    /**
+     * Merges the two config objects ignoring the array type
+     * @param objValue The default config value
+     * @param srcValue The target switchboard config value
+     * @returns The merge of the two configs provided
+     */
+    mergeCustomizer(objValue, srcValue) {
+        if (_.isArray(objValue) && srcValue) {
+            return srcValue;
+        }
+    }
+}
+Initializer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Initializer, deps: [{ token: i1.HttpClient }, { token: i2.TranslateService }, { token: i3.ThemeService }, { token: i4.BaseConfigService }, { token: i5.OAuthService }, { token: i6.CustomAuthConfigService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Initializer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Initializer, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Initializer, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TranslateService }, { type: i3.ThemeService }, { type: i4.BaseConfigService }, { type: i5.OAuthService }, { type: i6.CustomAuthConfigService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializer.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/core/initializer/initializer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable, Optional } from '@angular/core';\r\n\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { AuthConfig, OAuthService } from 'angular-oauth2-oidc';\r\nimport { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';\r\nimport * as _ from 'lodash';\r\nimport { BehaviorSubject, Observable, throwError } from 'rxjs';\r\n\r\nimport { ThemeService } from '../../theming/services/theme.service';\r\nimport { languageStorageKey } from '../models/constants';\r\nimport { OidcAuthSettings } from '../models/oidc-auth-settings';\r\nimport { BaseConfigService } from '../services/base-config.service';\r\nimport { CustomAuthConfigService } from '../services/custom-auth-config.service';\r\n\r\n/**\r\n * The startup service is used to call methods that should be run when initially loading the application\r\n */\r\n@Injectable(\r\n  {\r\n    providedIn: 'root'\r\n  }\r\n)\r\nexport class Initializer {\r\n\r\n  /** The configuration behavior subject */\r\n  private readonly isInitializedBs: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  /** Gets the configurations */\r\n  public get isInitialized(): boolean {\r\n    return this.isInitializedBs.value;\r\n  }\r\n\r\n  /** The configuration observable */\r\n  public readonly isInitialized$: Observable<boolean>;\r\n\r\n  /**\r\n   * Constructs the startup service. Include any services that should be used during startup\r\n   * @param http The HTTP Client\r\n   * @param translateService The translate service\r\n   * @param configService The configuration service\r\n   * @param oAuthService The oidc authorization service\r\n   * @param customAuthConfigService The service that will configure the auth config\r\n   */\r\n  constructor(\r\n    private readonly http: HttpClient,\r\n    private readonly translateService: TranslateService,\r\n    private readonly themeService: ThemeService,\r\n    private readonly configService: BaseConfigService,\r\n    private readonly oAuthService: OAuthService,\r\n    @Optional() private readonly customAuthConfigService: CustomAuthConfigService\r\n  ) {\r\n    this.isInitialized$ = this.isInitializedBs.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Loads all data that is needed upon initial loading of the website\r\n   */\r\n  public async initialize(): Promise<any> {\r\n    // reads the language from local storage set in the parent app\r\n    // language loading\r\n\r\n    // Set languages for translation service\r\n    const lang = window.localStorage.getItem(languageStorageKey) || window.sessionStorage.getItem(languageStorageKey) || 'en';\r\n    this.translateService.setDefaultLang(lang);\r\n    this.translateService.use(lang);\r\n\r\n    // Adapted from https://stackoverflow.com/a/41636880\r\n    // Adapted from https://stackoverflow.com/a/41736293\r\n\r\n    // A callback used to initialize the promise. This callback is passed two arguments:\r\n    // a resolve callback used resolve the promise with a value or the result of another promise,\r\n    // and a reject callback used to reject the promise with a provided reason or error.\r\n    return new Promise(async (resolve, reject) => {\r\n      // Go through all services and complete any API calls necessary.\r\n      // At the end, if all works and loads as expected, resolve the promise and set startup success to true.\r\n      // If an issue is encountered, you can call reject() to hit the catch() code below.\r\n\r\n      // First, load the configurations\r\n      let [baseConfig, overrideConfig, baseLang, overrideLang, theme] = [JSON, JSON, JSON, JSON, JSON];\r\n      try {\r\n        [baseConfig, overrideConfig, baseLang, overrideLang, theme] = await Promise.all([\r\n          this.http.get<JSON>('./assets/baseline/appsettings.json').toPromise(),\r\n          this.http.get<JSON>('./assets/configurations/appsettings.json').toPromise(),\r\n          this.http.get<JSON>(`./assets/i18n/${this.translateService.currentLang}.json`).toPromise(),\r\n          this.http.get<JSON>(`./assets/configurations/${this.translateService.currentLang}.json`).toPromise(),\r\n          this.http.get<JSON>('./assets/configurations/theme.json').toPromise()\r\n        ]);\r\n        this.configService.config = _.mergeWith(baseConfig, overrideConfig, this.mergeCustomizer);\r\n        const configSnapShot = this.configService.config;\r\n        configSnapShot.theme = theme as any;\r\n        this.configService.config = configSnapShot;\r\n        this.translateService.setTranslation(this.translateService.currentLang, _.mergeWith(baseLang, overrideLang, this.mergeCustomizer));\r\n        this.themeService.initPalette(theme as any);\r\n      }\r\n      catch (error) {\r\n        // Catch any errors during the get configurations API call\r\n        console.error('Error Loading Configurations or Languages');\r\n        // Reject the promise\r\n        reject('error');\r\n\r\n        return throwError(error.error || 'Server error');\r\n      }\r\n      try {\r\n        if (this.customAuthConfigService) {\r\n          await this.customAuthConfigService.configureAuthSettings().then(authConfig => {\r\n            if (authConfig) {\r\n              const config = this.configService.config.oAuthSettings;\r\n              return this.login(config);\r\n            }\r\n            else {\r\n              return Promise.resolve(false);\r\n            }\r\n          });\r\n        }\r\n        else {\r\n          const oAuth = await this.setUpOAuth();\r\n        }\r\n      }\r\n      catch (error) {\r\n        reject(error);\r\n\r\n        return throwError(error);\r\n      }\r\n\r\n      this.isInitializedBs.next(true);\r\n      resolve(true);\r\n    }).catch((error) => {\r\n      // Catch the error\r\n      console.error('There was an error loading the startup configurations.');\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Configure implicit flow\r\n   */\r\n  private async setUpOAuth(): Promise<boolean> {\r\n    if (this.configService.config?.oAuthSettings?.issuer) {\r\n      const config = this.configService.config.oAuthSettings;\r\n      const authConfig = new AuthConfig({\r\n        clientId: config.clientId,\r\n        redirectUri: config.redirectUri,\r\n        issuer: config.issuer,\r\n        scope: config.scope,\r\n        skipIssuerCheck: config.skipIssuerCheck != undefined ? config.skipIssuerCheck : true,\r\n        timeoutFactor: config.timeoutFactor || 0.75,\r\n        postLogoutRedirectUri: config.postLogoutRedirectUri,\r\n        loginUrl: config.loginUrl,\r\n        strictDiscoveryDocumentValidation: false,\r\n        responseType: config.responseType || 'code'\r\n      });\r\n      this.oAuthService.configure(authConfig);\r\n      this.oAuthService.skipIssuerCheck = true;\r\n      this.oAuthService.responseType = config.responseType || 'code';\r\n      this.oAuthService.strictDiscoveryDocumentValidation = false;\r\n      this.oAuthService.tokenValidationHandler = new JwksValidationHandler();\r\n      this.oAuthService.timeoutFactor = 0.75;\r\n      this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token');\r\n\r\n      // set initialized on start up to true\r\n      config.authSetOnStartup = true;\r\n      const parentConfig = this.configService.config;\r\n      parentConfig.oAuthSettings = config;\r\n      this.configService.config = parentConfig;\r\n\r\n      return this.login(config);\r\n    }\r\n\r\n    return Promise.resolve(true);\r\n  }\r\n\r\n  /**\r\n   * Handle Login\r\n   * @param config The Oidc Auth Settings\r\n   */\r\n  private async login(config: OidcAuthSettings): Promise<boolean> {\r\n    if (config.requireLoginOnStartup) {\r\n      return this.oAuthService.loadDiscoveryDocumentAndLogin()\r\n        // handles the case for expired access token or invalid nonce or people bookmarking the ids login page\r\n        .catch(async (res) => {\r\n          this.oAuthService.initLoginFlow();\r\n\r\n          return Promise.resolve(true);\r\n        });\r\n    }\r\n    else {\r\n      return this.oAuthService.loadDiscoveryDocumentAndTryLogin()\r\n        // handles the case for expired access token or invalid nonce or people bookmarking the ids login page\r\n        .catch(async (res) => {\r\n          this.oAuthService.initLoginFlow();\r\n\r\n          return Promise.resolve(true);\r\n        });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Merges the two config objects ignoring the array type\r\n   * @param objValue The default config value\r\n   * @param srcValue The target switchboard config value\r\n   * @returns The merge of the two configs provided\r\n   */\r\n  private mergeCustomizer(objValue: any, srcValue: any): any {\r\n    if (_.isArray(objValue) && srcValue) {\r\n      return srcValue;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/core/interceptors/armature-auth-token-append.interceptor.mjs

@@ -0,0 +1,73 @@
+import { Injectable, isDevMode, Optional } from '@angular/core';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+/** The Custom OAuth Interceptor Service */
+export class ArmatureAuthTokenAppendInterceptor {
+    /**
+     * The Constructor
+     * @param authStorage The Authorization storage
+     * @param errorHandler The Error handler
+     * @param moduleConfig The Authorization module config
+     */
+    constructor(authStorage, errorHandler, moduleConfig) {
+        this.authStorage = authStorage;
+        this.errorHandler = errorHandler;
+        this.moduleConfig = moduleConfig;
+    }
+    /**
+     * Checks if the given url starts with the current website url
+     * @param url The url
+     */
+    checkUrl(url) {
+        // don't append token to non softheon calls for dev mode
+        if (isDevMode() && (url.indexOf('.softheon.com') > -1 || url.indexOf('localhost') > -1)) {
+            return true;
+        }
+        if (!this.moduleConfig.resourceServer
+            || !this.moduleConfig.resourceServer.allowedUrls
+            || !this.moduleConfig.resourceServer.sendAccessToken) {
+            return false;
+        }
+        const currentUrl = `${window.location.protocol}//${window.location.hostname}${window.location.port ? `:${window.location.port}` : ''}`;
+        // still append token to local url refs
+        return url.startsWith(currentUrl) || url.indexOf('http') === -1;
+    }
+    /**
+     * Intercepts the http requests and appends the authorization token to the header if the endpoint matches the current base uri
+     * @param req The request
+     * @param next The Next
+     * https://manfredsteyer.github.io/angular-oauth2-oidc/angular-oauth2-oidc/docs/additional-documentation/working-with-httpinterceptors.html
+     */
+    intercept(req, next) {
+        // request url
+        const url = req.url.toLowerCase();
+        // checks the url and determines if sending the access token is allowed
+        if ((this.checkUrl(url) && this.moduleConfig.resourceServer.sendAccessToken)) {
+            let headers = req.headers;
+            let token = this.authStorage.getItem('access_token');
+            const ssoToken = window.sessionStorage.getItem('Sof-Arm-Access-Token');
+            if (ssoToken) {
+                token = ssoToken;
+            }
+            const header = `Bearer ${token}`;
+            if (token) {
+                headers = headers.set('Authorization', header);
+            }
+            req = req.clone({ headers });
+        }
+        return next.handle(req)
+            .pipe(catchError(err => this.errorHandler.handleError(err)));
+    }
+}
+ArmatureAuthTokenAppendInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArmatureAuthTokenAppendInterceptor, deps: [{ token: i1.OAuthStorage }, { token: i1.OAuthResourceServerErrorHandler }, { token: i1.OAuthModuleConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ArmatureAuthTokenAppendInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArmatureAuthTokenAppendInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArmatureAuthTokenAppendInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthStorage }, { type: i1.OAuthResourceServerErrorHandler }, { type: i1.OAuthModuleConfig, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/models/base-config.mjs

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

package/esm2020/lib/core/models/constants.mjs

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+// Injection tokens
+/** The session configs */
+export const SESSION_CONFIG = new InjectionToken('SessionConfig');
+/** The window interface */
+export const WINDOW = new InjectionToken('Window');
+/** The user entity service configs */
+export const USER_ENTITY_SERVICE_CONFIG = new InjectionToken('UserEntityServiceConfig');
+/** The pre sign in route storage key */
+export const preSignInRouteStorageKey = 'preSignInRoute';
+/** The language storage key */
+export const languageStorageKey = 'language';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9jb3JlL21vZGVscy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUsvQyxtQkFBbUI7QUFDbkIsMEJBQTBCO0FBQzFCLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBa0MsSUFBSSxjQUFjLENBQWdCLGVBQWUsQ0FBQyxDQUFDO0FBRWhILDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxNQUFNLEdBQTJCLElBQUksY0FBYyxDQUFTLFFBQVEsQ0FBQyxDQUFDO0FBRW5GLHNDQUFzQztBQUN0QyxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBNEMsSUFBSSxjQUFjLENBQTBCLHlCQUF5QixDQUFDLENBQUM7QUFFMUosd0NBQXdDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFXLGdCQUFnQixDQUFDO0FBRWpFLCtCQUErQjtBQUMvQixNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBVyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuaW1wb3J0IHsgU2Vzc2lvbkNvbmZpZyB9IGZyb20gJy4vc2Vzc2lvbi1jb25maWcnO1xyXG5pbXBvcnQgeyBVc2VyRW50aXR5U2VydmljZUNvbmZpZyB9IGZyb20gJy4vdXNlci1lbnRpdHktc2VydmljZS1jb25maWcnO1xyXG5cclxuLy8gSW5qZWN0aW9uIHRva2Vuc1xyXG4vKiogVGhlIHNlc3Npb24gY29uZmlncyAqL1xyXG5leHBvcnQgY29uc3QgU0VTU0lPTl9DT05GSUc6IEluamVjdGlvblRva2VuPFNlc3Npb25Db25maWc+ID0gbmV3IEluamVjdGlvblRva2VuPFNlc3Npb25Db25maWc+KCdTZXNzaW9uQ29uZmlnJyk7XHJcblxyXG4vKiogVGhlIHdpbmRvdyBpbnRlcmZhY2UgKi9cclxuZXhwb3J0IGNvbnN0IFdJTkRPVzogSW5qZWN0aW9uVG9rZW48V2luZG93PiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxXaW5kb3c+KCdXaW5kb3cnKTtcclxuXHJcbi8qKiBUaGUgdXNlciBlbnRpdHkgc2VydmljZSBjb25maWdzICovXHJcbmV4cG9ydCBjb25zdCBVU0VSX0VOVElUWV9TRVJWSUNFX0NPTkZJRzogSW5qZWN0aW9uVG9rZW48VXNlckVudGl0eVNlcnZpY2VDb25maWc+ID0gbmV3IEluamVjdGlvblRva2VuPFVzZXJFbnRpdHlTZXJ2aWNlQ29uZmlnPignVXNlckVudGl0eVNlcnZpY2VDb25maWcnKTtcclxuXHJcbi8qKiBUaGUgcHJlIHNpZ24gaW4gcm91dGUgc3RvcmFnZSBrZXkgKi9cclxuZXhwb3J0IGNvbnN0IHByZVNpZ25JblJvdXRlU3RvcmFnZUtleTogc3RyaW5nID0gJ3ByZVNpZ25JblJvdXRlJztcclxuXHJcbi8qKiBUaGUgbGFuZ3VhZ2Ugc3RvcmFnZSBrZXkgKi9cclxuZXhwb3J0IGNvbnN0IGxhbmd1YWdlU3RvcmFnZUtleTogc3RyaW5nID0gJ2xhbmd1YWdlJztcclxuIl19

package/esm2020/lib/core/models/data-store-config.mjs

@@ -0,0 +1,4 @@
+/** The data store configurations */
+export class DataStoreConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zdG9yZS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL2NvcmUvbW9kZWxzL2RhdGEtc3RvcmUtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLG9DQUFvQztBQUNwQyxNQUFNLE9BQU8sZUFBZTtDQXdCM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwVmVyYiB9IGZyb20gJy4vaHR0cC12ZXJicyc7XHJcbmltcG9ydCB7IFR5cGVkU2Vzc2lvbiB9IGZyb20gJy4uLy4uL2NvcmUvbW9kZWxzL3R5cGVkLXNlc3Npb24nO1xyXG5cclxuLyoqIFRoZSBkYXRhIHN0b3JlIGNvbmZpZ3VyYXRpb25zICovXHJcbmV4cG9ydCBjbGFzcyBEYXRhU3RvcmVDb25maWc8VCA9IGFueT4ge1xyXG4gICAgLyoqIFRoZSBkYXRhIHN0b3JlIGJhc2UgdXJpICovXHJcbiAgICBwdWJsaWMgYmFzZVVyaTogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBUaGUgcmV0cmlldmUgaHR0cCB2ZXJiICovXHJcbiAgICBwdWJsaWMgcmV0cmlldmVWZXJiOiBIdHRwVmVyYjtcclxuXHJcbiAgICAvKiogVGhlIHJldHJpZXZlIHJlcXVlc3QgZGVsZWdhdGUgKi9cclxuICAgIHB1YmxpYyByZXRyaWV2ZVJlcXVlc3REZWxlZ2F0ZTogKGJhc2VVcmk6IHN0cmluZywgZGF0YTogVHlwZWRTZXNzaW9uPFQ+KSA9PiB7IHVyaTogc3RyaW5nLCBib2R5PzogYW55IH07XHJcblxyXG4gICAgLyoqIFRoZSByZXRyaWV2ZSByZXNwb25zZSBkZWxlZ2F0ZSAqL1xyXG4gICAgcHVibGljIHJldHJpZXZlUmVzcG9uc2VEZWxlZ2F0ZTogKHJlc3BvbnNlOiBhbnksIHNlc3Npb246IFR5cGVkU2Vzc2lvbjxUPikgPT4gVHlwZWRTZXNzaW9uPFQ+O1xyXG5cclxuICAgIC8qKiBUaGUgcmV0cmlldmUgc2VjdXJhYmxlIGRlbGVnYXRlICovXHJcbiAgICBwdWJsaWMgcmV0cmlldmVTZWN1cmFibGVEZWxlZ2F0ZTogKHJlc3BvbnNlOiBhbnkpID0+IEFycmF5PChhcmc6IGFueSkgPT4gYW55PiB8ICgoYXJnOiBhbnkpID0+IGFueSk7XHJcblxyXG4gICAgLyoqIFRoZSB1cGRhdGUgaHR0cCB2ZXJiICovXHJcbiAgICBwdWJsaWMgdXBkYXRlVmVyYjogSHR0cFZlcmI7XHJcblxyXG4gICAgLyoqIFRoZSB1cGRhdGUgcmVxdWVzdCBkZWxlZ2F0ZSAqL1xyXG4gICAgcHVibGljIHVwZGF0ZVJlcXVlc3REZWxlZ2F0ZTogKGJhc2VVcmk6IHN0cmluZywgZGF0YTogVCkgPT4geyB1cmk6IHN0cmluZywgYm9keT86IGFueX07XHJcblxyXG4gICAgLyoqIERlbGVnYXRlIGZvciBkZXRlcm1pbmluZyB3aGVuIHRvIG1ha2UgYSBjYWxsIHRvIHVwZGF0ZSB0aGUgZGF0YSBzdG9yZSAqL1xyXG4gICAgcHVibGljIHNob3VsZFVwZGF0ZURhdGFTdG9yZURlbGVnYXRlOiAoZGF0YTogVCkgPT4gYm9vbGVhbjtcclxufVxyXG4iXX0=

package/esm2020/lib/core/models/header-config.mjs

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

package/esm2020/lib/core/models/http-verbs.mjs

@@ -0,0 +1,9 @@
+/** The http verb constants */
+export const httpVerb = {
+    POST: 'POST',
+    GET: 'GET',
+    PUT: 'PUT',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC12ZXJicy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvY29yZS9tb2RlbHMvaHR0cC12ZXJicy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSw4QkFBOEI7QUFDOUIsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHO0lBQ3BCLElBQUksRUFBRSxNQUFrQjtJQUN4QixHQUFHLEVBQUUsS0FBaUI7SUFDdEIsR0FBRyxFQUFFLEtBQWlCO0lBQ3RCLEtBQUssRUFBRSxPQUFtQjtJQUMxQixNQUFNLEVBQUUsUUFBb0I7Q0FDL0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBUaGUgaHR0cCB2ZXJiIHR5cGVzICovXHJcbmV4cG9ydCB0eXBlIEh0dHBWZXJiID0gJ1BPU1QnIHwgJ0dFVCcgfCAnUFVUJyB8ICdQQVRDSCcgfCAnREVMRVRFJztcclxuXHJcbi8qKiBUaGUgaHR0cCB2ZXJiIGNvbnN0YW50cyAqL1xyXG5leHBvcnQgY29uc3QgaHR0cFZlcmIgPSB7XHJcbiAgICBQT1NUOiAnUE9TVCcgYXMgSHR0cFZlcmIsXHJcbiAgICBHRVQ6ICdHRVQnIGFzIEh0dHBWZXJiLFxyXG4gICAgUFVUOiAnUFVUJyBhcyBIdHRwVmVyYixcclxuICAgIFBBVENIOiAnUEFUQ0gnIGFzIEh0dHBWZXJiLFxyXG4gICAgREVMRVRFOiAnREVMRVRFJyBhcyBIdHRwVmVyYixcclxufVxyXG4iXX0=

package/esm2020/lib/core/models/navigation-config.mjs

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

package/esm2020/lib/core/models/oidc-auth-settings.mjs

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

package/esm2020/lib/core/models/route-path.mjs

@@ -0,0 +1,7 @@
+/** The route path enum */
+export var RoutePath;
+(function (RoutePath) {
+    RoutePath["Internal"] = "internal";
+    RoutePath["External"] = "external";
+})(RoutePath || (RoutePath = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtcGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvY29yZS9tb2RlbHMvcm91dGUtcGF0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwQkFBMEI7QUFDMUIsTUFBTSxDQUFOLElBQVksU0FHWDtBQUhELFdBQVksU0FBUztJQUNuQixrQ0FBcUIsQ0FBQTtJQUNyQixrQ0FBcUIsQ0FBQTtBQUN2QixDQUFDLEVBSFcsU0FBUyxLQUFULFNBQVMsUUFHcEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogVGhlIHJvdXRlIHBhdGggZW51bSAqL1xyXG5leHBvcnQgZW51bSBSb3V0ZVBhdGgge1xyXG4gIEludGVybmFsID0gJ2ludGVybmFsJyxcclxuICBFeHRlcm5hbCA9ICdleHRlcm5hbCdcclxufVxyXG4iXX0=

package/esm2020/lib/core/models/session-config.mjs

@@ -0,0 +1,4 @@
+/** The session configurations */
+export class SessionConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL2NvcmUvbW9kZWxzL3Nlc3Npb24tY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGlDQUFpQztBQUNqQyxNQUFNLE9BQU8sYUFBYTtDQXFCekIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEYXRhU3RvcmVDb25maWcgfSBmcm9tICcuL2RhdGEtc3RvcmUtY29uZmlnJztcclxuXHJcbi8qKiBUaGUgc2Vzc2lvbiBjb25maWd1cmF0aW9ucyAqL1xyXG5leHBvcnQgY2xhc3MgU2Vzc2lvbkNvbmZpZzxUID0gYW55PiB7XHJcbiAgICAvKiogVGhlIGJyb3dzZXIgc3RvcmFnZSBpbXBsZW1lbnRhdGlvbiAqL1xyXG4gICAgcHVibGljIGJyb3dzZXJTdG9yYWdlSW1wbGVtZW50YXRpb246IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIHNlc3Npb24gbWFuYWdlbWVudCBpbXBsZW1lbnRhdGlvbiAqL1xyXG4gICAgcHVibGljIHNlc3Npb25NYW5hZ2VtZW50SW1wbGVtZW50YXRpb246IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIGRhdGEgc3RvcmUgY29uZmlndXJhdGlvbnMgKi9cclxuICAgIHB1YmxpYyBkYXRhU3RvcmVDb25maWc6IERhdGFTdG9yZUNvbmZpZzxUPjtcclxuXHJcbiAgICAvKiogVGhlIHRyYW5zZmVyIGJhc2UgcGF0aCAqL1xyXG4gICAgcHVibGljIHRyYW5zZmVyQmFzZVBhdGg6IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIGtleSBwYXRoIHVzZWQgZm9yIGJyb3dzZXIgc3RvcmFnZSAqL1xyXG4gICAgcHVibGljIGtleVBhdGg6IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIHNlc3Npb24gbWFuYWdlbWVudCBiYXNlIHBhdGggKi9cclxuICAgIHB1YmxpYyBzZXNzaW9uTWFuYWdlbWVudEJhc2VQYXRoOiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIFRoZSBzZXNzaW9uIHJlZnJlc2ggdGltZSBpbiBtaW51dGVzICovXHJcbiAgICBwdWJsaWMgc2Vzc2lvblJlZnJlc2hUaW1lTWludXRlczogbnVtYmVyO1xyXG59XHJcbiJdfQ==

package/esm2020/lib/core/models/styles.mjs

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

package/esm2020/lib/core/models/typed-session.mjs

@@ -0,0 +1,4 @@
+/** The session class */
+export class TypedSession {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZWQtc2Vzc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvY29yZS9tb2RlbHMvdHlwZWQtc2Vzc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSx3QkFBd0I7QUFDeEIsTUFBTSxPQUFPLFlBQVk7Q0FrQnhCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2Vzc2lvblJlc3BvbnNlTW9kZWwgfSBmcm9tICcuLi8uLi9jb3JlL2NsaWVudC1nZW5lcmF0ZWQvbW9kZWwvc2Vzc2lvblJlc3BvbnNlTW9kZWwnO1xyXG5pbXBvcnQgeyBCcmFuZGluZ01vZGVsLCBUcmFja2luZ01vZGVsLCBPQXV0aE1vZGVsIH0gZnJvbSAnLi4vLi4vY29yZS9jbGllbnQtZ2VuZXJhdGVkL21vZGVsL21vZGVscyc7XHJcblxyXG4vKiogVGhlIHNlc3Npb24gY2xhc3MgKi9cclxuZXhwb3J0IGNsYXNzIFR5cGVkU2Vzc2lvbjxUPiBpbXBsZW1lbnRzIFNlc3Npb25SZXNwb25zZU1vZGVsIHtcclxuICAgIC8qKiBUaGUgaW5pdGFsaXppbmcgb3JpZ2luICovXHJcbiAgICBwdWJsaWMgaW5pdGlhbGl6aW5nT3JpZ2luPzogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBUaGUgc2Vzc2lvbiBpZCAqL1xyXG4gICAgcHVibGljIHNlc3Npb25JZD86IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIHR5cGVkIHNlc3Npb24gZGF0YSAqL1xyXG4gICAgcHVibGljIHNlc3Npb25EYXRhPzogVDtcclxuXHJcbiAgICAvKiogVGhlIGJyYW5kaW5nIG1vZGVsICovXHJcbiAgICBwdWJsaWMgYnJhbmRpbmc/OiBCcmFuZGluZ01vZGVsO1xyXG5cclxuICAgIC8qKiBUaGUgdHJhY2tpbmcgbW9kZWwgKi9cclxuICAgIHB1YmxpYyB0cmFja2luZz86IFRyYWNraW5nTW9kZWw7XHJcblxyXG4gICAgLyoqIFRoZSBvYXV0aCBtb2RlbCAqL1xyXG4gICAgcHVibGljIG9BdXRoPzogT0F1dGhNb2RlbDtcclxufSJdfQ==

package/esm2020/lib/core/models/user-entity-service-config.mjs

@@ -0,0 +1,12 @@
+/** The user entity service config */
+export class UserEntityServiceConfig {
+    constructor() {
+        /** true if getting user on start up */
+        this.getUserOnInit = true;
+        /** True when including links */
+        this.includeLinks = true;
+        /** The validate function */
+        this.validate = (user) => true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1lbnRpdHktc2VydmljZS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL2NvcmUvbW9kZWxzL3VzZXItZW50aXR5LXNlcnZpY2UtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLHFDQUFxQztBQUNyQyxNQUFNLE9BQU8sdUJBQXVCO0lBQXBDO1FBQ0ksdUNBQXVDO1FBQ2hDLGtCQUFhLEdBQVksSUFBSSxDQUFDO1FBS3JDLGdDQUFnQztRQUN6QixpQkFBWSxHQUFZLElBQUksQ0FBQztRQUtwQyw0QkFBNEI7UUFDckIsYUFBUSxHQUF5QyxDQUFDLElBQXVCLEVBQVcsRUFBRSxDQUFDLElBQUksQ0FBQztJQUN2RyxDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBc3NlcnRlZFVzZXJNb2RlbCB9IGZyb20gJy4uL2NsaWVudC1nZW5lcmF0ZWQvbW9kZWwvYXNzZXJ0ZWRVc2VyTW9kZWwnO1xyXG5cclxuLyoqIFRoZSB1c2VyIGVudGl0eSBzZXJ2aWNlIGNvbmZpZyAqL1xyXG5leHBvcnQgY2xhc3MgVXNlckVudGl0eVNlcnZpY2VDb25maWcge1xyXG4gICAgLyoqIHRydWUgaWYgZ2V0dGluZyB1c2VyIG9uIHN0YXJ0IHVwICovXHJcbiAgICBwdWJsaWMgZ2V0VXNlck9uSW5pdDogYm9vbGVhbiA9IHRydWU7XHJcblxyXG4gICAgLyoqIFRoZSB1c2VyIGVudGl0eSBiYXNlIHVybCAqL1xyXG4gICAgcHVibGljIHVzZXJFbnRpdHlCYXNlVXJsOiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIFRydWUgd2hlbiBpbmNsdWRpbmcgbGlua3MgKi9cclxuICAgIHB1YmxpYyBpbmNsdWRlTGlua3M6IGJvb2xlYW4gPSB0cnVlO1xyXG5cclxuICAgIC8qKiBUaGUgcGFydGlhbCBmb3IgdGhlIGdldCB1c2VyIGNhbGwgKi9cclxuICAgIHB1YmxpYyBnZXRVc2VyUGFydGlhbDogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBUaGUgdmFsaWRhdGUgZnVuY3Rpb24gKi9cclxuICAgIHB1YmxpYyB2YWxpZGF0ZTogKHVzZXI6IEFzc2VydGVkVXNlck1vZGVsKSA9PiBib29sZWFuID0gKHVzZXI6IEFzc2VydGVkVXNlck1vZGVsKTogYm9vbGVhbiA9PiB0cnVlO1xyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,175 @@
+import { Injectable, Optional } from "@angular/core";
+import { AuthConfig } from "angular-oauth2-oidc";
+import { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';
+import { BehaviorSubject } from "rxjs";
+import { preSignInRouteStorageKey } from "../models/constants";
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../../oauth/oauth-api";
+import * as i4 from "./custom-auth-config.service";
+/** The session service */
+export class AuthorizationService {
+    /**
+     * Constructs authorization service
+     * @param authService The OAuth Service
+     * @param httpClient The HTTPClient
+     * @param authStorage The AuthStorage
+     * @param hybridAuthService The Hybrid Service
+     * @param customAuthConfigService The Custom Authorization Service
+     */
+    constructor(authService, httpClient, authStorage, hybridAuthService, customAuthConfigService) {
+        this.authService = authService;
+        this.httpClient = httpClient;
+        this.authStorage = authStorage;
+        this.hybridAuthService = hybridAuthService;
+        this.customAuthConfigService = customAuthConfigService;
+        /** IsloggedIn behaviour subject **/
+        this.isLoggedInBs = new BehaviorSubject(false);
+        this.isLoggedIn$ = this.isLoggedInBs.asObservable();
+    }
+    /**
+     * Initialize Authorization Settings.
+     *  @param authSettings The Authorization settings
+     */
+    initializeAuthSettings(authSettings, shouldTryLogin = true) {
+        this.authSettings = authSettings;
+        if (this.customAuthConfigService) {
+            this.customAuthConfigService.configureAuthSettings().then(authConfig => {
+                // Overwrite initial header auth setting with custom resolver
+                this.authSettings = {
+                    ...authSettings,
+                    ...authConfig
+                };
+                if (shouldTryLogin) {
+                    this.handleTryLogin(authSettings.authSetOnStartup);
+                }
+            });
+        }
+        else {
+            const authConfig = new AuthConfig({
+                clientId: authSettings.clientId,
+                redirectUri: authSettings.redirectUri,
+                issuer: authSettings.issuer,
+                scope: authSettings.scope,
+                skipIssuerCheck: authSettings.skipIssuerCheck,
+                timeoutFactor: authSettings.timeoutFactor || 0.75,
+                postLogoutRedirectUri: authSettings.postLogOutUrl,
+                loginUrl: authSettings.loginUrl,
+                responseType: authSettings.responseType || 'code'
+            });
+            this.authService.configure(authConfig);
+            this.authService.issuer = authSettings.issuer;
+            this.authService.strictDiscoveryDocumentValidation = false;
+            this.authService.skipIssuerCheck = true;
+            this.authService.tokenValidationHandler = new JwksValidationHandler();
+            this.authService.setupAutomaticSilentRefresh({}, 'access_token');
+            this.authService.timeoutFactor = authSettings.timeoutFactor || 0.75;
+            this.authService.responseType = authSettings.responseType || 'code';
+            if (shouldTryLogin) {
+                this.handleTryLogin(authSettings.authSetOnStartup);
+            }
+        }
+    }
+    /** The user name */
+    userName() {
+        let name = '';
+        if (this.claims.given_name) {
+            name += this.claims.given_name;
+        }
+        if (name && this.claims.family_name) {
+            name += ` ${this.claims.family_name}`;
+        }
+        else if (this.claims.family_name) {
+            name += this.claims.family_name;
+        }
+        return name || this.claims.upn;
+    }
+    /**
+     * Authorize User.
+     */
+    authorizeUser() {
+        if (this.authSettings) {
+            if (!this.IsLoggedIn) {
+                if (this.customAuthConfigService) {
+                    this.customAuthConfigService.configureAuthSettings().then(_ => {
+                        this.handleLogin();
+                    });
+                }
+                else {
+                    if (this.authService.issuer !== this.authSettings.issuer) {
+                        this.authService.issuer = this.authSettings.issuer;
+                    }
+                    this.handleLogin();
+                }
+            }
+            else {
+                if (this.hybridAuthService) {
+                    this.hybridAuthService.expireSession(true);
+                }
+                this.authService.logOut();
+                this.authStorage.removeItem('access_token');
+                this.isLoggedInBs.next(false);
+                this.IsLoggedIn = false;
+                return;
+            }
+        }
+    }
+    /**
+    * Handle Login
+    * @param authSetOnStartup Is auth set on startup
+    */
+    handleTryLogin(authSetOnStartup) {
+        if (!authSetOnStartup) {
+            this.authService.loadDiscoveryDocumentAndTryLogin()
+                .then(() => {
+                const token = this.authService.getAccessToken();
+                const isValid = !!token;
+                this.claims = this.authService.getIdentityClaims();
+                this.isLoggedInBs.next(isValid);
+                this.IsLoggedIn = isValid;
+            })
+                .catch(e => {
+                console.error(e);
+            });
+        }
+        else {
+            this.authService.loadDiscoveryDocument()
+                .then(() => {
+                const token = this.authService.getAccessToken();
+                const isValid = !!token;
+                this.claims = this.authService.getIdentityClaims();
+                this.isLoggedInBs.next(isValid);
+                this.IsLoggedIn = isValid;
+            })
+                .catch(e => {
+                console.error(e);
+            });
+        }
+    }
+    /** Handle Login */
+    handleLogin() {
+        window.sessionStorage.setItem(preSignInRouteStorageKey, window.location.pathname.toLowerCase());
+        this.authService.loadDiscoveryDocumentAndLogin()
+            .then(logInSuccess => {
+            if (logInSuccess) {
+                this.isLoggedInBs.next(true);
+                this.IsLoggedIn = true;
+            }
+        })
+            .catch(e => {
+            console.error(e);
+        });
+    }
+}
+AuthorizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: AuthorizationService, deps: [{ token: i1.OAuthService }, { token: i2.HttpClient }, { token: i1.OAuthStorage }, { token: i3.HybridSamlOauthService }, { token: i4.CustomAuthConfigService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthorizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: AuthorizationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: AuthorizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.HttpClient }, { type: i1.OAuthStorage }, { type: i3.HybridSamlOauthService }, { type: i4.CustomAuthConfigService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorization.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/core/services/authorization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport { Inject, Injectable, Optional } from \"@angular/core\";\r\n\r\nimport { AuthConfig, OAuthService, OAuthStorage } from \"angular-oauth2-oidc\";\r\nimport { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';\r\nimport { BehaviorSubject, Observable } from \"rxjs\";\r\n\r\nimport { HeaderAuthSettings } from \"../../header/models/header-auth.settings\";\r\nimport { HybridSamlOauthService } from \"../../oauth/oauth-api\";\r\nimport { AccessTokenClaims } from \"../../rbac/rbac-api\";\r\nimport { preSignInRouteStorageKey } from \"../models/constants\";\r\nimport { CustomAuthConfigService } from './custom-auth-config.service';\r\n\r\n/** The session service */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthorizationService {\r\n\r\n  /** The claims */\r\n  private claims: AccessTokenClaims;\r\n\r\n  /** Authorization settings.*/\r\n  public authSettings: HeaderAuthSettings;\r\n\r\n  /** IsloggedIn behaviour subject **/\r\n  private readonly isLoggedInBs: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  /** IsloggedIn observable **/\r\n  public isLoggedIn$: Observable<boolean>;\r\n\r\n  /** Determined whether is user is logged in**/\r\n  public IsLoggedIn: boolean;\r\n\r\n  /**\r\n   * Constructs authorization service\r\n   * @param authService The OAuth Service\r\n   * @param httpClient The HTTPClient\r\n   * @param authStorage The AuthStorage\r\n   * @param hybridAuthService The Hybrid Service\r\n   * @param customAuthConfigService The Custom Authorization Service\r\n   */\r\n  constructor(\r\n    private readonly authService: OAuthService,\r\n    private readonly httpClient: HttpClient,\r\n    private readonly authStorage: OAuthStorage,\r\n    private readonly hybridAuthService: HybridSamlOauthService,\r\n    @Optional() private readonly customAuthConfigService: CustomAuthConfigService\r\n  ) {\r\n    this.isLoggedIn$ = this.isLoggedInBs.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Initialize Authorization Settings.\r\n   *  @param authSettings The Authorization settings\r\n   */\r\n  public initializeAuthSettings(authSettings: HeaderAuthSettings, shouldTryLogin: boolean = true): void {\r\n    this.authSettings = authSettings;\r\n\r\n    if (this.customAuthConfigService) {\r\n      this.customAuthConfigService.configureAuthSettings().then(authConfig => {\r\n        // Overwrite initial header auth setting with custom resolver\r\n        this.authSettings = {\r\n          ...authSettings,\r\n          ...authConfig\r\n        };\r\n        if (shouldTryLogin) {\r\n          this.handleTryLogin(authSettings.authSetOnStartup);\r\n        }\r\n      });\r\n    }\r\n    else {\r\n      const authConfig = new AuthConfig({\r\n        clientId: authSettings.clientId,\r\n        redirectUri: authSettings.redirectUri,\r\n        issuer: authSettings.issuer,\r\n        scope: authSettings.scope,\r\n        skipIssuerCheck: authSettings.skipIssuerCheck,\r\n        timeoutFactor: authSettings.timeoutFactor || 0.75,\r\n        postLogoutRedirectUri: authSettings.postLogOutUrl,\r\n        loginUrl: authSettings.loginUrl,\r\n        responseType: authSettings.responseType || 'code'\r\n      });\r\n      this.authService.configure(authConfig);\r\n      this.authService.issuer = authSettings.issuer;\r\n      this.authService.strictDiscoveryDocumentValidation = false;\r\n      this.authService.skipIssuerCheck = true;\r\n      this.authService.tokenValidationHandler = new JwksValidationHandler();\r\n      this.authService.setupAutomaticSilentRefresh({}, 'access_token');\r\n      this.authService.timeoutFactor = authSettings.timeoutFactor || 0.75;\r\n      this.authService.responseType = authSettings.responseType || 'code';\r\n\r\n      if (shouldTryLogin) {\r\n        this.handleTryLogin(authSettings.authSetOnStartup);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** The user name */\r\n  public userName(): string {\r\n    let name = '';\r\n    if (this.claims.given_name) {\r\n      name += this.claims.given_name;\r\n    }\r\n    if (name && this.claims.family_name) {\r\n      name += ` ${this.claims.family_name}`;\r\n    }\r\n    else if (this.claims.family_name) {\r\n      name += this.claims.family_name;\r\n    }\r\n    return name || this.claims.upn;\r\n  }\r\n\r\n  /**\r\n   * Authorize User.\r\n   */\r\n  public authorizeUser(): void {\r\n    if (this.authSettings) {\r\n      if (!this.IsLoggedIn) {\r\n        if (this.customAuthConfigService) {\r\n          this.customAuthConfigService.configureAuthSettings().then(_ => {\r\n            this.handleLogin();\r\n          });\r\n        }\r\n        else {\r\n          if (this.authService.issuer !== this.authSettings.issuer) {\r\n            this.authService.issuer = this.authSettings.issuer;\r\n          }\r\n          this.handleLogin();\r\n        }\r\n      } else {\r\n        if (this.hybridAuthService) {\r\n          this.hybridAuthService.expireSession(true);\r\n        }\r\n        this.authService.logOut();\r\n        this.authStorage.removeItem('access_token');\r\n        this.isLoggedInBs.next(false);\r\n        this.IsLoggedIn = false;\r\n        return;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n  * Handle Login\r\n  * @param authSetOnStartup Is auth set on startup \r\n  */\r\n  private handleTryLogin(authSetOnStartup: boolean): void {\r\n    if (!authSetOnStartup) {\r\n      this.authService.loadDiscoveryDocumentAndTryLogin()\r\n        .then(() => {\r\n          const token = this.authService.getAccessToken();\r\n          const isValid = !!token;\r\n          this.claims = this.authService.getIdentityClaims() as AccessTokenClaims;\r\n          this.isLoggedInBs.next(isValid);\r\n          this.IsLoggedIn = isValid;\r\n        })\r\n        .catch(e => {\r\n          console.error(e);\r\n        });\r\n    }\r\n    else {\r\n      this.authService.loadDiscoveryDocument()\r\n        .then(() => {\r\n          const token = this.authService.getAccessToken();\r\n          const isValid = !!token;\r\n          this.claims = this.authService.getIdentityClaims() as AccessTokenClaims;\r\n          this.isLoggedInBs.next(isValid);\r\n          this.IsLoggedIn = isValid;\r\n        })\r\n        .catch(e => {\r\n          console.error(e);\r\n        });\r\n    }\r\n  }\r\n\r\n  /** Handle Login */\r\n  private handleLogin(): void {\r\n    window.sessionStorage.setItem(preSignInRouteStorageKey, window.location.pathname.toLowerCase());\r\n    this.authService.loadDiscoveryDocumentAndLogin()\r\n      .then(logInSuccess => {\r\n        if (logInSuccess) {\r\n          this.isLoggedInBs.next(true);\r\n          this.IsLoggedIn = true;\r\n        }\r\n      })\r\n      .catch(e => {\r\n        console.error(e);\r\n      });\r\n  }\r\n}\r\n"]}