@kolektor/nucleus-identity 0.0.8-pre.5672 → 0.0.9-pre.5707

package/{esm2015/lib/nucleus-identity.module.js → esm2020/lib/nucleus-identity.module.mjs}

@@ -14,10 +14,10 @@ export class NucleusIdentityModule {
         };
     }
 }
-NucleusIdentityModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: NucleusIdentityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-NucleusIdentityModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: NucleusIdentityModule });
-NucleusIdentityModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: NucleusIdentityModule, imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: NucleusIdentityModule, decorators: [{
+NucleusIdentityModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NucleusIdentityModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityModule });
+NucleusIdentityModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],

package/esm2020/lib/nucleus-identity.service.mjs

@@ -0,0 +1,343 @@
+import { AuthorizationRequest, RedirectRequestHandler, BasicQueryStringUtils, LocalStorageBackend, AppAuthError } from '@openid/appauth';
+import { Injectable } from '@angular/core';
+import { App } from '@capacitor/app';
+import { Browser } from '@capacitor/browser';
+import { Device } from '@capacitor/device';
+import { NucleusCrypto } from './utils/nucleus-crypto';
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { LocationService } from './utils/location.service';
+import { NucleusAuthorizationNotifier } from './utils/nucleus-authorization-notifier';
+import { HttpClient } from '@angular/common/http';
+import { SecretsStore } from './utils/secrets-store';
+import { OidcConfigurationService } from './utils/oidc-configuration.service';
+import { TokenClient } from './utils/token-client';
+import { ServicePrincipalRegistrationStatus } from './models/service-principal';
+import * as i0 from "@angular/core";
+import * as i1 from "@kolektor/nucleus-common";
+import * as i2 from "./utils/location.service";
+import * as i3 from "@angular/common/http";
+import * as i4 from "./utils/oidc-configuration.service";
+import * as i5 from "./utils/token-client";
+export class NucleusIdentityService {
+    constructor(appService, location, http, config, tokenClient) {
+        this.appService = appService;
+        this.http = http;
+        this.config = config;
+        this.tokenClient = tokenClient;
+        this._authorizationNotifier = new NucleusAuthorizationNotifier();
+        this._initStarted = false;
+        this._initialized = false;
+        this._servicePrincipalTokenId = '_svcp';
+        const storage = new LocalStorageBackend();
+        this._crypto = new NucleusCrypto();
+        this._authorizationHandler = new RedirectRequestHandler(storage, new BasicQueryStringUtils(), location, this._crypto);
+        this._authorizationHandler.setAuthorizationNotifier(this._authorizationNotifier);
+        this._store = new SecretsStore(config.clientId);
+    }
+    get identity() {
+        return this._store.getIdentity();
+    }
+    get isAuthenticated() {
+        return this.identity != null;
+    }
+    get servicePrincipalIdentity() {
+        return this._store.getIdentity(this._servicePrincipalTokenId);
+    }
+    get isServicePrincipalAuthenticated() {
+        return this.servicePrincipalIdentity != null;
+    }
+    async init(startLogin = false) {
+        if (this._initStarted || this._initialized) {
+            console.warn('Nucleus.Identity: Auth initialization was already started. Don\'t call init() multiple times!');
+            return;
+        }
+        this._initStarted = true;
+        this.handleLaunchCodeHash();
+        await this._authorizationHandler.completeAuthorizationRequestIfPossible();
+        const authErr = this._authorizationNotifier.error;
+        if (authErr) {
+            throw new Error('Authorization err: ' + authErr.error + ': ' + authErr.errorDescription);
+        }
+        else if (this._authorizationNotifier.response) {
+            window.location.hash = '';
+            const request = this._authorizationNotifier.request;
+            const response = this._authorizationNotifier.response;
+            const res = await this.tokenClient.getByAuthorizationCode(request.redirectUri, response.code, request.internal['code_verifier']);
+            await this._store.setToken(res);
+        }
+        else {
+            const res = await this._store.getToken();
+            if (!res && startLogin) {
+                await this.login();
+            }
+        }
+        this._initialized = true;
+    }
+    async loginWithSecret(provider, secret) {
+        this._store.removeToken();
+        const assertionToken = await this.getServicePrincipalAccessToken();
+        const scope = this.prepareScope(true, this.config?.requestedScopes);
+        const res = await this.tokenClient.getBySecret(provider, secret, assertionToken, scope);
+        await this._store.setToken(res);
+    }
+    async login() {
+        this._store.removeToken();
+        const config = await this.config.getConfiguration();
+        const request = this.prepareAuthorizationRequest();
+        if (this.appService.isNative) {
+            const listener = App.addListener('appUrlOpen', data => {
+                if (this.appService.platform === 'ios') {
+                    Browser.close();
+                }
+                listener.remove();
+                const hash = this.getCodeHash(data.url);
+                if (hash) {
+                    const targetUrl = window.location.origin + window.location.pathname + '#' + hash;
+                    window.location.assign(targetUrl);
+                    window.location.reload();
+                }
+                else {
+                    console.warn('Nucleus.Identity: Redirect url did not contain authorization code!', data);
+                }
+            });
+        }
+        this._authorizationHandler.performAuthorizationRequest(config, request);
+    }
+    async logout() {
+        this._store.removeToken();
+        const config = await this.config.getConfiguration();
+        const redirectUrl = this.config.redirectUrl;
+        const logoutUrl = config.endSessionEndpoint + '?post_logout_redirect_uri=' + encodeURI(redirectUrl);
+        if (this.appService.isNative) {
+            const listener = App.addListener('appUrlOpen', () => {
+                Device.getInfo().then(info => {
+                    if (info.platform === 'ios') {
+                        Browser.close();
+                    }
+                });
+                listener.remove();
+            });
+            Browser.open({ url: logoutUrl });
+        }
+        else {
+            window.location.assign(logoutUrl);
+        }
+    }
+    async getAccessToken() {
+        if (!this._getTokenPromise) {
+            this._getTokenPromise = this.getAccessTokenInternal();
+        }
+        try {
+            return await this._getTokenPromise;
+        }
+        finally {
+            this._getTokenPromise = null;
+        }
+    }
+    async getServicePrincipalAccessToken() {
+        if (!this._getServicePrincipalTokenPromise) {
+            this._getServicePrincipalTokenPromise = this.getServicePrincipalAccessTokenInternal();
+        }
+        try {
+            return await this._getServicePrincipalTokenPromise;
+        }
+        finally {
+            this._getServicePrincipalTokenPromise = null;
+        }
+    }
+    async loginServicePrincipal() {
+        await this.loginServicePrincipalInternal();
+    }
+    /*
+    public async loginAsServicePrincipal() {
+      let token = await this._store.getToken(this._servicePrincipalTokenId);
+      if (!token) {
+        await this.loginServicePrincipal();
+      }
+      token = await this._store.getToken(this._servicePrincipalTokenId);
+       // TODO: we have to distinguished that token is service principal so refresh token stuff is handled correctly.
+       // We have to implement universal getAccessToken function that can handle all cases
+      await this._store.setToken(token);
+    }
+    */
+    async getOtp(type, expiresIn = -1) {
+        let url = this.config.getServerUrl(`/otp/create?type=${type}`);
+        if (expiresIn > 0) {
+            url += `&expiresIn=${expiresIn}`;
+        }
+        return this.http.get(url).toPromise();
+    }
+    async getOtpStatus(id) {
+        const url = this.config.getServerUrl(`/otp/status/${id}`);
+        return this.http.get(url).toPromise();
+    }
+    getOtpUrl(redirectUrl, password) {
+        const encoded = encodeURIComponent(redirectUrl);
+        const url = `/otp/auth?otpValue=${password}&returnUrl=${encoded}`;
+        return this.config.getServerUrl(url);
+    }
+    async startServicePrincipalRegistration() {
+        const sp = await this._store.getServicePrincipal();
+        return await this.tokenClient.getRegistrationCode(sp?.id);
+    }
+    async completeServicePrincipalRegistration(deviceCode) {
+        const tokenRes = await this.waitForDeviceToken(deviceCode);
+        const regRes = await this.tokenClient.registerServicePrincipal(tokenRes.accessToken);
+        await this._store.setServicePrincipal({
+            id: regRes.clientId,
+            secret: regRes.clientSecret,
+            expiresAt: regRes.secretExpirationDate
+        });
+    }
+    removeServicePrincipalRegistration() {
+        return this._store.removeServicePrincipal();
+    }
+    async getServicePrincipalRegistrationStatus() {
+        const sp = await this._store.getServicePrincipal();
+        return new ServicePrincipalRegistrationStatus(sp);
+    }
+    async startDeviceCodeLogin() {
+        const scope = this.prepareScope(true, this.config.requestedScopes);
+        return await this.tokenClient.getDeviceCode(scope);
+    }
+    async completeDeviceCodeLogin(deviceCode) {
+        const res = await this.waitForDeviceToken(deviceCode);
+        await this._store.setToken(res);
+    }
+    async waitForDeviceToken(deviceCode) {
+        let res = null;
+        do {
+            if (deviceCode.isExpired()) {
+                throw Error('Device code is expired!');
+            }
+            try {
+                res = await this.tokenClient.getByDeviceCode(deviceCode.deviceCode);
+            }
+            catch (error) {
+                if (error instanceof AppAuthError && error.message === 'authorization_pending') {
+                    await this.delay(2000);
+                }
+                else {
+                    throw error;
+                }
+            }
+        } while (!res);
+        return res;
+    }
+    prepareAuthorizationRequest() {
+        const redirectUri = this.config.redirectUrl;
+        const params = {
+            response_mode: 'fragment',
+            prompt: 'consent',
+            access_type: 'offline',
+            auth_provider_hint: this.config.authProviderHint
+        };
+        return new AuthorizationRequest({
+            client_id: this.config.clientId,
+            redirect_uri: redirectUri,
+            response_type: AuthorizationRequest.RESPONSE_TYPE_CODE,
+            scope: this.prepareScope(true, this.config.requestedScopes),
+            extras: params,
+        }, this._crypto, true);
+    }
+    async loginServicePrincipalInternal() {
+        const sp = await this._store.getServicePrincipal();
+        if (sp) {
+            const scope = this.prepareScope(false, this.config.servicePrincipalRequestedScopes);
+            const res = await this.tokenClient.getByClientCredentials(sp.id, sp.secret, scope);
+            await this._store.setToken(res, this._servicePrincipalTokenId);
+            return res;
+        }
+        else {
+            throw Error('Service principal is not registered!');
+        }
+    }
+    async getServicePrincipalAccessTokenInternal() {
+        let token = await this._store.getToken(this._servicePrincipalTokenId);
+        if (!token?.isValid()) {
+            token = await this.loginServicePrincipalInternal();
+        }
+        return token?.accessToken;
+    }
+    async getAccessTokenInternal() {
+        let token = await this._store.getToken();
+        if (token && !token.isValid()) {
+            token = await this.loginWithRefreshToken(token);
+        }
+        return token?.accessToken;
+    }
+    async loginWithRefreshToken(token) {
+        if (!this._refreshTokenPromise) {
+            this._refreshTokenPromise = this.loginWithRefreshTokenInternal(token);
+        }
+        try {
+            return await this._refreshTokenPromise;
+        }
+        finally {
+            this._refreshTokenPromise = null;
+        }
+    }
+    async loginWithRefreshTokenInternal(token) {
+        if (token?.refreshToken) {
+            try {
+                const res = await this.tokenClient.getByRefreshToken(token.refreshToken);
+                await this._store.setToken(res);
+                return res;
+            }
+            catch (err) {
+                console.warn('Nucleus.Identity: Failed to login with refresh token.', err);
+                if (err.message === 'invalid_grant') {
+                    await this.logout();
+                }
+            }
+        }
+        else {
+            console.warn('Nucleus.Identity: There is no refresh token available.');
+        }
+    }
+    getCodeHash(url) {
+        const arr = url.split('#');
+        if (arr.length > 1) {
+            const hash = arr[1];
+            if (hash.startsWith('code=')) {
+                return hash;
+            }
+        }
+        return null;
+    }
+    handleLaunchCodeHash() {
+        if (this.appService.isNative && this.appService.launchUrl) {
+            const hash = this.getCodeHash(this.appService.launchUrl);
+            if (hash) {
+                console.log('Nucleus.Identity: Got authorization code from launchUrl, will assign it to hash.');
+                window.location.hash = '#' + hash;
+            }
+        }
+    }
+    prepareScope(offlineAccess, aditionalScope) {
+        let scope = 'openid';
+        if (offlineAccess) {
+            scope += ' offline_access';
+        }
+        if (scope) {
+            scope += ' ' + aditionalScope;
+        }
+        return scope;
+    }
+    delay(miliseconds) {
+        return new Promise(resolve => {
+            setTimeout(() => {
+                resolve();
+            }, miliseconds);
+        });
+    }
+}
+NucleusIdentityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityService, deps: [{ token: i1.NucleusAppService }, { token: i2.LocationService }, { token: i3.HttpClient }, { token: i4.OidcConfigurationService }, { token: i5.TokenClient }], target: i0.ɵɵFactoryTarget.Injectable });
+NucleusIdentityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusIdentityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NucleusAppService }, { type: i2.LocationService }, { type: i3.HttpClient }, { type: i4.OidcConfigurationService }, { type: i5.TokenClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nucleus-identity.service.js","sourceRoot":"","sources":["../../../../projects/nucleus-identity/src/lib/nucleus-identity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AuthorizationRequest,\r\n  TokenResponse,\r\n  Crypto,\r\n  RedirectRequestHandler,\r\n  BasicQueryStringUtils,\r\n  LocalStorageBackend,\r\n  AppAuthError\r\n} from '@openid/appauth';\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { App } from '@capacitor/app';\r\nimport { Browser } from '@capacitor/browser';\r\nimport { Device } from '@capacitor/device';\r\nimport { NucleusCrypto } from './utils/nucleus-crypto';\r\nimport { NucleusAppService } from '@kolektor/nucleus-common';\r\nimport { LocationService } from './utils/location.service';\r\nimport { AuthorizationRequestHandler } from '@openid/appauth';\r\nimport { NucleusAuthorizationNotifier } from './utils/nucleus-authorization-notifier';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { OtpResponse, OtpStatus, OtpType } from './models/otp';\r\nimport { SecretsStore } from './utils/secrets-store';\r\nimport { OidcConfigurationService } from './utils/oidc-configuration.service';\r\nimport { TokenClient } from './utils/token-client';\r\nimport { DeviceCode } from './models/device-code';\r\nimport { ServicePrincipalRegistrationStatus } from './models/service-principal';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NucleusIdentityService {\r\n  constructor(\r\n    private appService: NucleusAppService,\r\n    location: LocationService,\r\n    private http: HttpClient,\r\n    private config: OidcConfigurationService,\r\n    private tokenClient: TokenClient\r\n  ) {\r\n    const storage = new LocalStorageBackend();\r\n    this._crypto = new NucleusCrypto();\r\n    this._authorizationHandler = new RedirectRequestHandler(storage, new BasicQueryStringUtils(), location, this._crypto);\r\n    this._authorizationHandler.setAuthorizationNotifier(this._authorizationNotifier);\r\n    this._store = new SecretsStore(config.clientId);\r\n  }\r\n\r\n  // TODO: add some kind of config that will specify which token (userToken or servicePrincipalToken) should be injected by httpInterceptor\r\n\r\n  private _authorizationHandler: AuthorizationRequestHandler;\r\n  private _authorizationNotifier = new NucleusAuthorizationNotifier();\r\n  private _crypto: Crypto;\r\n  private _initStarted = false;\r\n  private _initialized = false;\r\n  private _refreshTokenPromise: Promise<TokenResponse>;\r\n  private _getTokenPromise: Promise<string>;\r\n  private _getServicePrincipalTokenPromise: Promise<string>;\r\n  private _servicePrincipalTokenId = '_svcp';\r\n  private _store: SecretsStore;\r\n\r\n  public get identity() {\r\n    return this._store.getIdentity();\r\n  }\r\n\r\n  public get isAuthenticated() {\r\n    return this.identity != null;\r\n  }\r\n\r\n  public get servicePrincipalIdentity() {\r\n    return this._store.getIdentity(this._servicePrincipalTokenId);\r\n  }\r\n\r\n  public get isServicePrincipalAuthenticated() {\r\n    return this.servicePrincipalIdentity != null;\r\n  }\r\n\r\n  public async init(startLogin: boolean = false): Promise<void> {\r\n    if (this._initStarted || this._initialized) {\r\n      console.warn('Nucleus.Identity: Auth initialization was already started. Don\\'t call init() multiple times!');\r\n      return;\r\n    }\r\n    this._initStarted = true;\r\n\r\n    this.handleLaunchCodeHash();\r\n    await this._authorizationHandler.completeAuthorizationRequestIfPossible();\r\n\r\n    const authErr = this._authorizationNotifier.error;\r\n    if (authErr) {\r\n      throw new Error('Authorization err: ' + authErr.error + ': ' + authErr.errorDescription);\r\n    } else if (this._authorizationNotifier.response) {\r\n      window.location.hash = '';\r\n      const request = this._authorizationNotifier.request;\r\n      const response = this._authorizationNotifier.response;\r\n      const res = await this.tokenClient.getByAuthorizationCode(request.redirectUri, response.code, request.internal['code_verifier']);\r\n      await this._store.setToken(res);\r\n    } else {\r\n      const res = await this._store.getToken();\r\n      if (!res && startLogin) {\r\n        await this.login();\r\n      }\r\n    }\r\n    this._initialized = true;\r\n  }\r\n\r\n  public async loginWithSecret(provider: string, secret: string): Promise<void> {\r\n    this._store.removeToken();\r\n    const assertionToken = await this.getServicePrincipalAccessToken();\r\n    const scope = this.prepareScope(true, this.config?.requestedScopes);\r\n    const res = await this.tokenClient.getBySecret(provider, secret, assertionToken, scope);\r\n    await this._store.setToken(res);\r\n  }\r\n\r\n  public async login(): Promise<void> {\r\n    this._store.removeToken();\r\n    const config = await this.config.getConfiguration();\r\n    const request = this.prepareAuthorizationRequest();\r\n    if (this.appService.isNative) {\r\n      const listener = App.addListener('appUrlOpen', data => {\r\n        if (this.appService.platform === 'ios') {\r\n          Browser.close();\r\n        }\r\n        listener.remove();\r\n        const hash = this.getCodeHash(data.url);\r\n        if (hash) {\r\n          const targetUrl = window.location.origin + window.location.pathname + '#' + hash;\r\n          window.location.assign(targetUrl);\r\n          window.location.reload();\r\n        } else {\r\n          console.warn('Nucleus.Identity: Redirect url did not contain authorization code!', data);\r\n        }\r\n      });\r\n    }\r\n    this._authorizationHandler.performAuthorizationRequest(config, request);\r\n  }\r\n\r\n  public async logout(): Promise<void> {\r\n    this._store.removeToken();\r\n    const config = await this.config.getConfiguration();\r\n    const redirectUrl = this.config.redirectUrl;\r\n    const logoutUrl = config.endSessionEndpoint + '?post_logout_redirect_uri=' + encodeURI(redirectUrl);\r\n    if (this.appService.isNative) {\r\n      const listener = App.addListener('appUrlOpen', () => {\r\n        Device.getInfo().then(info => {\r\n          if (info.platform === 'ios') {\r\n            Browser.close();\r\n          }\r\n        });\r\n        listener.remove();\r\n      });\r\n      Browser.open({ url: logoutUrl });\r\n    } else {\r\n      window.location.assign(logoutUrl);\r\n    }\r\n  }\r\n\r\n  public async getAccessToken() {\r\n    if (!this._getTokenPromise) {\r\n      this._getTokenPromise = this.getAccessTokenInternal();\r\n    }\r\n    try {\r\n      return await this._getTokenPromise;\r\n    } finally {\r\n      this._getTokenPromise = null;\r\n    }\r\n  }\r\n\r\n  public async getServicePrincipalAccessToken() {\r\n    if (!this._getServicePrincipalTokenPromise) {\r\n      this._getServicePrincipalTokenPromise = this.getServicePrincipalAccessTokenInternal();\r\n    }\r\n    try {\r\n      return await this._getServicePrincipalTokenPromise;\r\n    } finally {\r\n      this._getServicePrincipalTokenPromise = null;\r\n    }\r\n  }\r\n\r\n  public async loginServicePrincipal() {\r\n    await this.loginServicePrincipalInternal();\r\n  }\r\n\r\n  /*\r\n  public async loginAsServicePrincipal() {\r\n    let token = await this._store.getToken(this._servicePrincipalTokenId);\r\n    if (!token) {\r\n      await this.loginServicePrincipal();\r\n    }\r\n    token = await this._store.getToken(this._servicePrincipalTokenId);\r\n     // TODO: we have to distinguished that token is service principal so refresh token stuff is handled correctly.\r\n     // We have to implement universal getAccessToken function that can handle all cases\r\n    await this._store.setToken(token);\r\n  }\r\n  */\r\n\r\n  public async getOtp(type: OtpType, expiresIn: number = -1) {\r\n    let url = this.config.getServerUrl(`/otp/create?type=${type}`);\r\n    if (expiresIn > 0) {\r\n      url += `&expiresIn=${expiresIn}`;\r\n    }\r\n    return this.http.get<OtpResponse>(url).toPromise();\r\n  }\r\n\r\n  public async getOtpStatus(id: string) {\r\n    const url = this.config.getServerUrl(`/otp/status/${id}`);\r\n    return this.http.get<OtpStatus>(url).toPromise();\r\n  }\r\n\r\n  public getOtpUrl(redirectUrl: string, password: string) {\r\n    const encoded = encodeURIComponent(redirectUrl);\r\n    const url = `/otp/auth?otpValue=${password}&returnUrl=${encoded}`;\r\n    return this.config.getServerUrl(url);\r\n  }\r\n\r\n  public async startServicePrincipalRegistration() {\r\n    const sp = await this._store.getServicePrincipal();\r\n    return await this.tokenClient.getRegistrationCode(sp?.id);\r\n  }\r\n\r\n  public async completeServicePrincipalRegistration(deviceCode: DeviceCode) {\r\n    const tokenRes = await this.waitForDeviceToken(deviceCode);\r\n    const regRes = await this.tokenClient.registerServicePrincipal(tokenRes.accessToken);\r\n\r\n    await this._store.setServicePrincipal({\r\n      id: regRes.clientId,\r\n      secret: regRes.clientSecret,\r\n      expiresAt: regRes.secretExpirationDate\r\n    });\r\n  }\r\n\r\n  public removeServicePrincipalRegistration() {\r\n    return this._store.removeServicePrincipal();\r\n  }\r\n\r\n  public async getServicePrincipalRegistrationStatus() {\r\n    const sp = await this._store.getServicePrincipal();\r\n    return new ServicePrincipalRegistrationStatus(sp);\r\n  }\r\n\r\n  public async startDeviceCodeLogin() {\r\n    const scope = this.prepareScope(true, this.config.requestedScopes);\r\n    return await this.tokenClient.getDeviceCode(scope);\r\n  }\r\n\r\n  public async completeDeviceCodeLogin(deviceCode: DeviceCode) {\r\n    const res = await this.waitForDeviceToken(deviceCode);\r\n    await this._store.setToken(res);\r\n  }\r\n\r\n  private async waitForDeviceToken(deviceCode: DeviceCode) {\r\n    let res: TokenResponse = null;\r\n    do {\r\n      if (deviceCode.isExpired()) {\r\n        throw Error('Device code is expired!');\r\n      }\r\n\r\n      try {\r\n        res = await this.tokenClient.getByDeviceCode(deviceCode.deviceCode);\r\n      } catch (error) {\r\n        if (error instanceof AppAuthError && error.message === 'authorization_pending') {\r\n          await this.delay(2000);\r\n        } else {\r\n          throw error;\r\n        }\r\n      }\r\n    } while (!res);\r\n    return res;\r\n  }\r\n\r\n  private prepareAuthorizationRequest(): AuthorizationRequest {\r\n    const redirectUri = this.config.redirectUrl;\r\n\r\n    const params = {\r\n      response_mode: 'fragment',\r\n      prompt: 'consent',\r\n      access_type: 'offline',\r\n      auth_provider_hint: this.config.authProviderHint\r\n    };\r\n\r\n    return new AuthorizationRequest({\r\n      client_id: this.config.clientId,\r\n      redirect_uri: redirectUri,\r\n      response_type: AuthorizationRequest.RESPONSE_TYPE_CODE,\r\n      scope: this.prepareScope(true, this.config.requestedScopes),\r\n      extras: params,\r\n    }, this._crypto, true);\r\n  }\r\n\r\n  private async loginServicePrincipalInternal() {\r\n    const sp = await this._store.getServicePrincipal();\r\n    if (sp) {\r\n      const scope = this.prepareScope(false, this.config.servicePrincipalRequestedScopes);\r\n      const res = await this.tokenClient.getByClientCredentials(sp.id, sp.secret, scope);\r\n      await this._store.setToken(res, this._servicePrincipalTokenId);\r\n      return res;\r\n    } else {\r\n      throw Error('Service principal is not registered!');\r\n    }\r\n  }\r\n\r\n  private async getServicePrincipalAccessTokenInternal() {\r\n    let token = await this._store.getToken(this._servicePrincipalTokenId);\r\n    if (!token?.isValid()) {\r\n      token = await this.loginServicePrincipalInternal();\r\n    }\r\n    return token?.accessToken;\r\n  }\r\n\r\n  private async getAccessTokenInternal() {\r\n    let token = await this._store.getToken();\r\n    if (token && !token.isValid()) {\r\n      token = await this.loginWithRefreshToken(token);\r\n    }\r\n    return token?.accessToken;\r\n  }\r\n\r\n  private async loginWithRefreshToken(token: TokenResponse) {\r\n    if (!this._refreshTokenPromise) {\r\n      this._refreshTokenPromise = this.loginWithRefreshTokenInternal(token);\r\n    }\r\n    try {\r\n      return await this._refreshTokenPromise;\r\n    } finally {\r\n      this._refreshTokenPromise = null;\r\n    }\r\n  }\r\n\r\n  private async loginWithRefreshTokenInternal(token: TokenResponse) {\r\n    if (token?.refreshToken) {\r\n      try {\r\n        const res = await this.tokenClient.getByRefreshToken(token.refreshToken);\r\n        await this._store.setToken(res);\r\n        return res;\r\n      } catch (err) {\r\n        console.warn('Nucleus.Identity: Failed to login with refresh token.', err);\r\n        if (err.message === 'invalid_grant') {\r\n          await this.logout();\r\n        }\r\n      }\r\n    } else {\r\n      console.warn('Nucleus.Identity: There is no refresh token available.');\r\n    }\r\n  }\r\n\r\n  private getCodeHash(url: string) {\r\n    const arr = url.split('#');\r\n    if (arr.length > 1) {\r\n      const hash = arr[1];\r\n      if (hash.startsWith('code=')) {\r\n        return hash;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  private handleLaunchCodeHash() {\r\n    if (this.appService.isNative && this.appService.launchUrl) {\r\n      const hash = this.getCodeHash(this.appService.launchUrl);\r\n      if (hash) {\r\n        console.log('Nucleus.Identity: Got authorization code from launchUrl, will assign it to hash.');\r\n        window.location.hash = '#' + hash;\r\n      }\r\n    }\r\n  }\r\n\r\n  private prepareScope(offlineAccess: boolean, aditionalScope: string) {\r\n    let scope = 'openid';\r\n    if (offlineAccess) {\r\n      scope += ' offline_access';\r\n    }\r\n    if (scope) {\r\n      scope += ' ' + aditionalScope;\r\n    }\r\n    return scope;\r\n  }\r\n\r\n  private delay(miliseconds: number) {\r\n    return new Promise<void>(resolve => {\r\n      setTimeout(() => {\r\n        resolve();\r\n      }, miliseconds);\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/lib/nucleus-token-interceptor.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { from, throwError } from 'rxjs';
+import { NucleusIdentityConfig } from './nucleus-identity-config';
+import { NucleusIdentityService } from './nucleus-identity.service';
+import { mergeMap, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./nucleus-identity.service";
+import * as i2 from "./nucleus-identity-config";
+export class NucleusTokenInterceptor {
+    constructor(auth, config) {
+        this.auth = auth;
+        this.config = config;
+        this._authorityInterceptPaths = ['/api', '/manage', '/otp/create', '/otp/status'];
+        this._authority = config.authority.toLowerCase();
+        this._interceptUrls = config.httpInterceptorUrls?.map(x => x.toLowerCase());
+    }
+    intercept(req, next) {
+        if (this.shouldIntercept(req.url)) {
+            const res = this.authorizeRequest(this.auth.getAccessToken(), req, next);
+            return this.checkUnauthorized(res);
+        }
+        return next.handle(req);
+    }
+    shouldIntercept(url) {
+        url = url.toLowerCase();
+        if (url.startsWith(this._authority)) {
+            const pathname = new URL(url).pathname;
+            return (this._authorityInterceptPaths.some(x => pathname.startsWith(x)));
+        }
+        if (this._interceptUrls?.length > 0) {
+            return this.config.httpInterceptorUrls.some(x => url.startsWith(x));
+        }
+        return false;
+    }
+    authorizeRequest(getToken, req, next) {
+        return from(getToken).pipe(mergeMap(token => {
+            if (token) {
+                const headers = req.headers.set('Authorization', `Bearer ${token}`);
+                req = req.clone({ headers });
+            }
+            return next.handle(req);
+        }));
+    }
+    checkUnauthorized(response) {
+        return response.pipe(catchError((err) => {
+            if (err instanceof HttpErrorResponse && err.status === 401) {
+                if (this.config.automaticLoginOnHttp401) {
+                    this.auth.login();
+                }
+            }
+            return throwError(err);
+        }));
+    }
+}
+NucleusTokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusTokenInterceptor, deps: [{ token: i1.NucleusIdentityService }, { token: i2.NucleusIdentityConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+NucleusTokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusTokenInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: NucleusTokenInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NucleusIdentityService }, { type: i2.NucleusIdentityConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVjbGV1cy10b2tlbi1pbnRlcmNlcHRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbnVjbGV1cy1pZGVudGl0eS9zcmMvbGliL251Y2xldXMtdG9rZW4taW50ZXJjZXB0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBd0QsaUJBQWlCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMvRyxPQUFPLEVBQWMsSUFBSSxFQUFFLFVBQVUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUNwRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFDOzs7O0FBS3RELE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsWUFBb0IsSUFBNEIsRUFBVSxNQUE2QjtRQUFuRSxTQUFJLEdBQUosSUFBSSxDQUF3QjtRQUFVLFdBQU0sR0FBTixNQUFNLENBQXVCO1FBTy9FLDZCQUF3QixHQUFHLENBQUMsTUFBTSxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFMbkYsSUFBSSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ2pELElBQUksQ0FBQyxjQUFjLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFNTSxTQUFTLENBQUMsR0FBcUIsRUFBRSxJQUFpQjtRQUN2RCxJQUFJLElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFO1lBQ2pDLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxFQUFFLEdBQUcsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUN6RSxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNwQztRQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBRU8sZUFBZSxDQUFDLEdBQVc7UUFDakMsR0FBRyxHQUFHLEdBQUcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUV4QixJQUFJLEdBQUcsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ25DLE1BQU0sUUFBUSxHQUFHLElBQUksR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsQ0FBQztZQUN2QyxPQUFPLENBQUMsSUFBSSxDQUFDLHdCQUF3QixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQzFFO1FBRUQsSUFBSSxJQUFJLENBQUMsY0FBYyxFQUFFLE1BQU0sR0FBRyxDQUFDLEVBQUU7WUFDbkMsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztTQUNyRTtRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVPLGdCQUFnQixDQUFDLFFBQXlCLEVBQUUsR0FBcUIsRUFBRSxJQUFpQjtRQUMxRixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQ3hCLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUNmLElBQUksS0FBSyxFQUFFO2dCQUNQLE1BQU0sT0FBTyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsRUFBRSxVQUFVLEtBQUssRUFBRSxDQUFDLENBQUM7Z0JBQ3BFLEdBQUcsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQzthQUNoQztZQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUMxQixDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQztJQUVPLGlCQUFpQixDQUFDLFFBQW9DO1FBQzVELE9BQU8sUUFBUSxDQUFDLElBQUksQ0FDbEIsVUFBVSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDakIsSUFBSSxHQUFHLFlBQVksaUJBQWlCLElBQUksR0FBRyxDQUFDLE1BQU0sS0FBSyxHQUFHLEVBQUU7Z0JBQzFELElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyx1QkFBdUIsRUFBRTtvQkFDdkMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztpQkFDbkI7YUFDRjtZQUNELE9BQU8sVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDOztvSEF4RFUsdUJBQXVCO3dIQUF2Qix1QkFBdUIsY0FGdEIsTUFBTTsyRkFFUCx1QkFBdUI7a0JBSG5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBIdHRwRXZlbnQsIEh0dHBIYW5kbGVyLCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBSZXF1ZXN0LCBIdHRwRXJyb3JSZXNwb25zZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgZnJvbSwgdGhyb3dFcnJvciB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgeyBOdWNsZXVzSWRlbnRpdHlDb25maWcgfSBmcm9tICcuL251Y2xldXMtaWRlbnRpdHktY29uZmlnJztcclxuaW1wb3J0IHsgTnVjbGV1c0lkZW50aXR5U2VydmljZSB9IGZyb20gJy4vbnVjbGV1cy1pZGVudGl0eS5zZXJ2aWNlJztcclxuaW1wb3J0IHsgbWVyZ2VNYXAsIGNhdGNoRXJyb3IgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBOdWNsZXVzVG9rZW5JbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvciB7XHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBhdXRoOiBOdWNsZXVzSWRlbnRpdHlTZXJ2aWNlLCBwcml2YXRlIGNvbmZpZzogTnVjbGV1c0lkZW50aXR5Q29uZmlnXHJcbiAgKSB7XHJcbiAgICB0aGlzLl9hdXRob3JpdHkgPSBjb25maWcuYXV0aG9yaXR5LnRvTG93ZXJDYXNlKCk7XHJcbiAgICB0aGlzLl9pbnRlcmNlcHRVcmxzID0gY29uZmlnLmh0dHBJbnRlcmNlcHRvclVybHM/Lm1hcCh4ID0+IHgudG9Mb3dlckNhc2UoKSk7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIF9hdXRob3JpdHk6IHN0cmluZztcclxuICBwcml2YXRlIF9hdXRob3JpdHlJbnRlcmNlcHRQYXRocyA9IFsnL2FwaScsICcvbWFuYWdlJywgJy9vdHAvY3JlYXRlJywgJy9vdHAvc3RhdHVzJ107XHJcbiAgcHJpdmF0ZSBfaW50ZXJjZXB0VXJsczogc3RyaW5nW107XHJcblxyXG4gIHB1YmxpYyBpbnRlcmNlcHQocmVxOiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+IHtcclxuICAgIGlmICh0aGlzLnNob3VsZEludGVyY2VwdChyZXEudXJsKSkge1xyXG4gICAgICBjb25zdCByZXMgPSB0aGlzLmF1dGhvcml6ZVJlcXVlc3QodGhpcy5hdXRoLmdldEFjY2Vzc1Rva2VuKCksIHJlcSwgbmV4dCk7XHJcbiAgICAgIHJldHVybiB0aGlzLmNoZWNrVW5hdXRob3JpemVkKHJlcyk7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxKTtcclxuICB9XHJcblxyXG4gIHByaXZhdGUgc2hvdWxkSW50ZXJjZXB0KHVybDogc3RyaW5nKTogYm9vbGVhbiB7XHJcbiAgICB1cmwgPSB1cmwudG9Mb3dlckNhc2UoKTtcclxuXHJcbiAgICBpZiAodXJsLnN0YXJ0c1dpdGgodGhpcy5fYXV0aG9yaXR5KSkge1xyXG4gICAgICBjb25zdCBwYXRobmFtZSA9IG5ldyBVUkwodXJsKS5wYXRobmFtZTtcclxuICAgICAgcmV0dXJuICh0aGlzLl9hdXRob3JpdHlJbnRlcmNlcHRQYXRocy5zb21lKHggPT4gcGF0aG5hbWUuc3RhcnRzV2l0aCh4KSkpO1xyXG4gICAgfVxyXG5cclxuICAgIGlmICh0aGlzLl9pbnRlcmNlcHRVcmxzPy5sZW5ndGggPiAwKSB7XHJcbiAgICAgIHJldHVybiB0aGlzLmNvbmZpZy5odHRwSW50ZXJjZXB0b3JVcmxzLnNvbWUoeCA9PiB1cmwuc3RhcnRzV2l0aCh4KSk7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gZmFsc2U7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGF1dGhvcml6ZVJlcXVlc3QoZ2V0VG9rZW46IFByb21pc2U8c3RyaW5nPiwgcmVxOiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+IHtcclxuICAgIHJldHVybiBmcm9tKGdldFRva2VuKS5waXBlKFxyXG4gICAgICBtZXJnZU1hcCh0b2tlbiA9PiB7XHJcbiAgICAgICAgaWYgKHRva2VuKSB7XHJcbiAgICAgICAgICAgIGNvbnN0IGhlYWRlcnMgPSByZXEuaGVhZGVycy5zZXQoJ0F1dGhvcml6YXRpb24nLCBgQmVhcmVyICR7dG9rZW59YCk7XHJcbiAgICAgICAgICAgIHJlcSA9IHJlcS5jbG9uZSh7IGhlYWRlcnMgfSk7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXEpO1xyXG4gICAgICB9KVxyXG4gICAgKTtcclxuICB9XHJcblxyXG4gIHByaXZhdGUgY2hlY2tVbmF1dGhvcml6ZWQocmVzcG9uc2U6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+KTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj4ge1xyXG4gICAgcmV0dXJuIHJlc3BvbnNlLnBpcGUoXHJcbiAgICAgIGNhdGNoRXJyb3IoKGVycikgPT4ge1xyXG4gICAgICAgIGlmIChlcnIgaW5zdGFuY2VvZiBIdHRwRXJyb3JSZXNwb25zZSAmJiBlcnIuc3RhdHVzID09PSA0MDEpIHtcclxuICAgICAgICAgIGlmICh0aGlzLmNvbmZpZy5hdXRvbWF0aWNMb2dpbk9uSHR0cDQwMSkge1xyXG4gICAgICAgICAgICB0aGlzLmF1dGgubG9naW4oKTtcclxuICAgICAgICAgIH1cclxuICAgICAgICB9XHJcbiAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoZXJyKTtcclxuICAgICAgfSlcclxuICAgICk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/{esm2015/lib/utils/angular-requestor.js → esm2020/lib/utils/angular-requestor.mjs}

@@ -18,22 +18,21 @@ export class AngularRequestor extends Requestor {
                 body: settings.data,
                 headers: settings.headers,
             }).subscribe(res => resolve(res), err => {
-                var _a;
                 let e = new AppAuthError(err);
                 if (err instanceof HttpErrorResponse) {
-                    e = new AppAuthError(((_a = err.error) === null || _a === void 0 ? void 0 : _a.error) || err.statusText);
+                    e = new AppAuthError(err.error?.error || err.statusText);
                 }
                 reject(e);
             });
         });
     }
 }
-AngularRequestor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: AngularRequestor, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-AngularRequestor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: AngularRequestor, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.3", ngImport: i0, type: AngularRequestor, decorators: [{
+AngularRequestor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AngularRequestor, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+AngularRequestor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AngularRequestor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: AngularRequestor, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/utils/location.service.js → esm2020/lib/utils/location.service.mjs}

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