@kolektor/nucleus-identity 0.0.12-pre.7931 → 0.1.0-pre.128

package/README.md

@@ -0,0 +1,4 @@
+# nucleus-identity
+
+This library was generated with [Nx](https://nx.dev).
+

package/esm2022/index.mjs

@@ -0,0 +1,7 @@
+export * from './lib/nucleus-identity.module';
+export * from './lib/nucleus-identity.service';
+export * from './lib/nucleus-identity-config';
+export { OtpResponse, OtpStatus, OtpType } from './lib/models/otp';
+export { DeviceCode } from './lib/models/device-code';
+export { ServicePrincipalRegistrationStatus } from './lib/models/service-principal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL25nL251Y2xldXMtaWRlbnRpdHkvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25FLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL251Y2xldXMtaWRlbnRpdHkubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL251Y2xldXMtaWRlbnRpdHkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9udWNsZXVzLWlkZW50aXR5LWNvbmZpZyc7XG5leHBvcnQgeyBPdHBSZXNwb25zZSwgT3RwU3RhdHVzLCBPdHBUeXBlIH0gZnJvbSAnLi9saWIvbW9kZWxzL290cCc7XG5leHBvcnQgeyBEZXZpY2VDb2RlIH0gZnJvbSAnLi9saWIvbW9kZWxzL2RldmljZS1jb2RlJztcbmV4cG9ydCB7IFNlcnZpY2VQcmluY2lwYWxSZWdpc3RyYXRpb25TdGF0dXMgfSBmcm9tICcuL2xpYi9tb2RlbHMvc2VydmljZS1wcmluY2lwYWwnO1xuIl19

package/esm2022/kolektor-nucleus-identity.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29sZWt0b3ItbnVjbGV1cy1pZGVudGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvbmcvbnVjbGV1cy1pZGVudGl0eS9zcmMva29sZWt0b3ItbnVjbGV1cy1pZGVudGl0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/lib/models/client-registration.mjs

@@ -0,0 +1,8 @@
+export class ClientRegistrationResponse {
+    constructor(response) {
+        this.clientId = response.client_id;
+        this.clientSecret = response.client_secret;
+        this.secretExpirationDate = new Date(response.client_secret_expires_at * 1000);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LXJlZ2lzdHJhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmcvbnVjbGV1cy1pZGVudGl0eS9zcmMvbGliL21vZGVscy9jbGllbnQtcmVnaXN0cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE1BQU0sT0FBTywwQkFBMEI7SUFDckMsWUFBWSxRQUF3QztRQUNsRCxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUM7UUFDbkMsSUFBSSxDQUFDLFlBQVksR0FBRyxRQUFRLENBQUMsYUFBYSxDQUFDO1FBQzNDLElBQUksQ0FBQyxvQkFBb0IsR0FBRyxJQUFJLElBQUksQ0FDbEMsUUFBUSxDQUFDLHdCQUF3QixHQUFHLElBQUksQ0FDekMsQ0FBQztJQUNKLENBQUM7Q0FLRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgQ2xpZW50UmVnaXN0cmF0aW9uUmVzcG9uc2VKc29uIHtcbiAgY2xpZW50X2lkOiBzdHJpbmc7XG4gIGNsaWVudF9zZWNyZXQ6IHN0cmluZztcbiAgY2xpZW50X3NlY3JldF9leHBpcmVzX2F0OiBudW1iZXI7XG59XG5cbmV4cG9ydCBjbGFzcyBDbGllbnRSZWdpc3RyYXRpb25SZXNwb25zZSB7XG4gIGNvbnN0cnVjdG9yKHJlc3BvbnNlOiBDbGllbnRSZWdpc3RyYXRpb25SZXNwb25zZUpzb24pIHtcbiAgICB0aGlzLmNsaWVudElkID0gcmVzcG9uc2UuY2xpZW50X2lkO1xuICAgIHRoaXMuY2xpZW50U2VjcmV0ID0gcmVzcG9uc2UuY2xpZW50X3NlY3JldDtcbiAgICB0aGlzLnNlY3JldEV4cGlyYXRpb25EYXRlID0gbmV3IERhdGUoXG4gICAgICByZXNwb25zZS5jbGllbnRfc2VjcmV0X2V4cGlyZXNfYXQgKiAxMDAwXG4gICAgKTtcbiAgfVxuXG4gIGNsaWVudElkOiBzdHJpbmc7XG4gIGNsaWVudFNlY3JldDogc3RyaW5nO1xuICBzZWNyZXRFeHBpcmF0aW9uRGF0ZTogRGF0ZTtcbn1cbiJdfQ==

package/esm2022/lib/models/device-code.mjs

@@ -0,0 +1,19 @@
+import { nowInSeconds } from '@openid/appauth';
+export class DeviceCode {
+    constructor(response) {
+        this.deviceCode = response.device_code;
+        this.userCode = response.user_code;
+        this.verificationUrl = response.verification_uri;
+        this.verificationUrlComplete = response.verification_uri_complete;
+        this.expiresIn = parseInt(response.expires_in, 10);
+        this.issuedAt = nowInSeconds();
+    }
+    isExpired(buffer = 60) {
+        return this.secondsLeft(buffer) <= 0;
+    }
+    secondsLeft(buffer = 60) {
+        const now = nowInSeconds();
+        return this.issuedAt + this.expiresIn - buffer - now;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/identity.mjs

@@ -0,0 +1,52 @@
+export class Claim {
+    constructor(name, values) {
+        this.name = name;
+        this.values = values;
+    }
+}
+export class Identity {
+    constructor(res) {
+        this.claims = [];
+        if (!res.idToken) {
+            throw Error("There is no id token in the token response!");
+        }
+        const token = this.decodeToken(res.idToken);
+        this.name = token.name;
+        this.subject = token.sub;
+        for (const key in token) {
+            if ({}.hasOwnProperty.call(token, key)) {
+                let vals = token[key];
+                if (!Array.isArray(vals)) {
+                    vals = [vals];
+                }
+                const claim = new Claim(key, vals);
+                this.claims.push(claim);
+            }
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    decodeToken(jwt) {
+        if (!jwt) {
+            throw new Error('NucleusIdentity: There was no identity token in the response!');
+        }
+        try {
+            const arr = jwt.split('.');
+            // var header = arr[0];
+            const payload = this.b64DecodeUnicode(arr[1]);
+            // var signature = arr[2];
+            return JSON.parse(payload);
+        }
+        catch (error) {
+            console.error('Error while decoding identity token', error);
+            console.error('Error while decoding identity token JWT', jwt);
+        }
+    }
+    b64DecodeUnicode(str) {
+        str = str.replace(/-/g, '+').replace(/_/g, '/'); // Qlector fix :)
+        return decodeURIComponent(atob(str)
+            .split('')
+            .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(''));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/otp.mjs

@@ -0,0 +1,11 @@
+export class OtpResponse {
+}
+export class OtpStatus {
+}
+export var OtpType;
+(function (OtpType) {
+    OtpType[OtpType["SimpleNumbers"] = 0] = "SimpleNumbers";
+    OtpType[OtpType["SimpleAlfanumeric"] = 1] = "SimpleAlfanumeric";
+    OtpType[OtpType["Complex"] = 2] = "Complex";
+})(OtpType || (OtpType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy9udWNsZXVzLWlkZW50aXR5L3NyYy9saWIvbW9kZWxzL290cC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sV0FBVztDQUd2QjtBQUVELE1BQU0sT0FBTyxTQUFTO0NBSXJCO0FBRUQsTUFBTSxDQUFOLElBQVksT0FJWDtBQUpELFdBQVksT0FBTztJQUNqQix1REFBaUIsQ0FBQTtJQUNqQiwrREFBcUIsQ0FBQTtJQUNyQiwyQ0FBVyxDQUFBO0FBQ2IsQ0FBQyxFQUpXLE9BQU8sS0FBUCxPQUFPLFFBSWxCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIE90cFJlc3BvbnNlIHtcbiAgcHVibGljIHBhc3N3b3JkITogc3RyaW5nO1xuICBwdWJsaWMgcGFzc3dvcmRJZCE6IHN0cmluZztcbn1cblxuZXhwb3J0IGNsYXNzIE90cFN0YXR1cyB7XG4gIHB1YmxpYyBpc0V4cGlyZWQhOiBib29sZWFuO1xuICBwdWJsaWMgaXNVc2VkITogYm9vbGVhbjtcbiAgcHVibGljIHNlY29uZHNUb0V4cGlyYXRpb24hOiBudW1iZXI7XG59XG5cbmV4cG9ydCBlbnVtIE90cFR5cGUge1xuICBTaW1wbGVOdW1iZXJzID0gMCxcbiAgU2ltcGxlQWxmYW51bWVyaWMgPSAxLFxuICBDb21wbGV4ID0gMixcbn1cbiJdfQ==

package/esm2022/lib/models/service-principal.mjs

@@ -0,0 +1,16 @@
+export class ServicePrincipal {
+}
+export class ServicePrincipalRegistrationStatus {
+    constructor(servicePrincipal) {
+        this.isRegistered = false;
+        if (servicePrincipal) {
+            this.isRegistered = true;
+            this.id = servicePrincipal.id;
+            this.expiresAt = servicePrincipal.expiresAt;
+        }
+    }
+    get isExpired() {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS1wcmluY2lwYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nL251Y2xldXMtaWRlbnRpdHkvc3JjL2xpYi9tb2RlbHMvc2VydmljZS1wcmluY2lwYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGdCQUFnQjtDQUk1QjtBQUVELE1BQU0sT0FBTyxrQ0FBa0M7SUFLN0MsWUFBWSxnQkFBeUM7UUFIOUMsaUJBQVksR0FBRyxLQUFLLENBQUM7UUFJMUIsSUFBSSxnQkFBZ0IsRUFBRTtZQUNwQixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQztZQUN6QixJQUFJLENBQUMsRUFBRSxHQUFHLGdCQUFnQixDQUFDLEVBQUUsQ0FBQztZQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLGdCQUFnQixDQUFDLFNBQVMsQ0FBQztTQUM3QztJQUNILENBQUM7SUFFRCxJQUFXLFNBQVM7UUFDbEIsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgU2VydmljZVByaW5jaXBhbCB7XG4gIHB1YmxpYyBpZCE6IHN0cmluZztcbiAgcHVibGljIHNlY3JldCE6IHN0cmluZztcbiAgcHVibGljIGV4cGlyZXNBdCE6IERhdGU7XG59XG5cbmV4cG9ydCBjbGFzcyBTZXJ2aWNlUHJpbmNpcGFsUmVnaXN0cmF0aW9uU3RhdHVzIHtcbiAgcHVibGljIGlkITogc3RyaW5nO1xuICBwdWJsaWMgaXNSZWdpc3RlcmVkID0gZmFsc2U7XG4gIHB1YmxpYyBleHBpcmVzQXQhOiBEYXRlO1xuXG4gIGNvbnN0cnVjdG9yKHNlcnZpY2VQcmluY2lwYWw6IFNlcnZpY2VQcmluY2lwYWwgfCBudWxsKSB7XG4gICAgaWYgKHNlcnZpY2VQcmluY2lwYWwpIHtcbiAgICAgIHRoaXMuaXNSZWdpc3RlcmVkID0gdHJ1ZTtcbiAgICAgIHRoaXMuaWQgPSBzZXJ2aWNlUHJpbmNpcGFsLmlkO1xuICAgICAgdGhpcy5leHBpcmVzQXQgPSBzZXJ2aWNlUHJpbmNpcGFsLmV4cGlyZXNBdDtcbiAgICB9XG4gIH1cblxuICBwdWJsaWMgZ2V0IGlzRXhwaXJlZCgpIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/nucleus-identity-config.mjs

@@ -0,0 +1,7 @@
+export class NucleusIdentityConfig {
+    constructor() {
+        this.httpInterceptorUrls = [];
+        this.automaticLoginOnHttp401 = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVjbGV1cy1pZGVudGl0eS1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25nL251Y2xldXMtaWRlbnRpdHkvc3JjL2xpYi9udWNsZXVzLWlkZW50aXR5LWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8scUJBQXFCO0lBQWxDO1FBV1Msd0JBQW1CLEdBQWMsRUFBRSxDQUFDO1FBRXBDLDRCQUF1QixHQUFHLEtBQUssQ0FBQztJQU96QyxDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTnVjbGV1c0lkZW50aXR5Q29uZmlnIHtcbiAgcHVibGljIGF1dGhvcml0eSE6IHN0cmluZztcblxuICBwdWJsaWMgY2xpZW50SWQhOiBzdHJpbmc7XG5cbiAgcHVibGljIHJlZGlyZWN0VXJpPzogc3RyaW5nO1xuXG4gIHB1YmxpYyBhbmRyb2lkUmVkaXJlY3RVcmk/OiBzdHJpbmc7XG5cbiAgcHVibGljIGlPU1JlZGlyZWN0VXJpPzogc3RyaW5nO1xuXG4gIHB1YmxpYyBodHRwSW50ZXJjZXB0b3JVcmxzPzogc3RyaW5nW10gPSBbXTtcblxuICBwdWJsaWMgYXV0b21hdGljTG9naW5Pbkh0dHA0MDEgPSBmYWxzZTtcblxuICBwdWJsaWMgcmVxdWVzdGVkU2NvcGVzPzogc3RyaW5nO1xuXG4gIHB1YmxpYyBzZXJ2aWNlUHJpbmNpcGFsUmVxdWVzdGVkU2NvcGVzPzogc3RyaW5nO1xuXG4gIHB1YmxpYyBhdXRoUHJvdmlkZXJIaW50Pzogc3RyaW5nO1xufVxuIl19

package/esm2022/lib/nucleus-identity.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { NucleusTokenInterceptor } from './nucleus-token-interceptor.service';
+import { NucleusIdentityConfig } from './nucleus-identity-config';
+import * as i0 from "@angular/core";
+export class NucleusIdentityModule {
+    static forRoot(config) {
+        return {
+            ngModule: NucleusIdentityModule,
+            providers: [
+                { provide: NucleusIdentityConfig, useValue: config },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: NucleusTokenInterceptor,
+                    multi: true,
+                },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [],
+                    exports: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,350 @@
+import { AuthorizationRequest, RedirectRequestHandler, BasicQueryStringUtils, LocalStorageBackend, AppAuthError, DefaultCrypto, } from '@openid/appauth';
+import { Injectable } from '@angular/core';
+import { App } from '@capacitor/app';
+import { Browser } from '@capacitor/browser';
+import { Device } from '@capacitor/device';
+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 { lastValueFrom } from 'rxjs';
+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._refreshTokenPromise = null;
+        this._getTokenPromise = null;
+        this._getServicePrincipalTokenPromise = null;
+        this._servicePrincipalTokenId = '_svcp';
+        const storage = new LocalStorageBackend();
+        this._crypto = new DefaultCrypto();
+        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;
+    }
+    get isIdentityServicePrincipal() {
+        return this._store.defaultIdentityId === this._servicePrincipalTokenId;
+    }
+    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 codeVerifier = (request.internal) ? request.internal['code_verifier'] : undefined;
+            const res = await this.tokenClient.getByAuthorizationCode(request.redirectUri, response.code, codeVerifier);
+            this._store.setDefaultIdentityId(null);
+            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);
+        this._store.setDefaultIdentityId(null);
+        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() {
+        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 loginAsServicePrincipal() {
+        const token = await this._store.getToken(this._servicePrincipalTokenId);
+        if (!token) {
+            await this.loginServicePrincipal();
+        }
+        this._store.setDefaultIdentityId(this._servicePrincipalTokenId);
+    }
+    async getOtp(type, expiresIn = -1) {
+        let url = this.config.getServerUrl(`/otp/create?type=${type}`);
+        if (expiresIn > 0) {
+            url += `&expiresIn=${expiresIn}`;
+        }
+        return lastValueFrom(this.http.get(url));
+    }
+    async getOtpStatus(id) {
+        const url = this.config.getServerUrl(`/otp/status/${id}`);
+        return lastValueFrom(this.http.get(url));
+    }
+    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 getServicePrincipalAccessTokenInternal() {
+        let token = await this._store.getToken(this._servicePrincipalTokenId);
+        if (!token?.isValid()) {
+            token = await this.loginServicePrincipal();
+        }
+        return token?.accessToken;
+    }
+    async getAccessTokenInternal() {
+        let token = await this._store.getToken();
+        if (token && !token.isValid()) {
+            token = await this.loginWithRefreshToken(token);
+        }
+        return token?.accessToken ?? null;
+    }
+    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);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (err.message === 'invalid_grant') {
+                    await this.logout();
+                }
+            }
+        }
+        else {
+            console.warn('Nucleus.Identity: There is no refresh token available.');
+        }
+        return null;
+    }
+    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 (aditionalScope) {
+            scope += ' ' + aditionalScope;
+        }
+        return scope;
+    }
+    delay(miliseconds) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, miliseconds);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityService, deps: [{ token: i1.NucleusAppService }, { token: i2.LocationService }, { token: i3.HttpClient }, { token: i4.OidcConfigurationService }, { token: i5.TokenClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusIdentityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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":["../../../../../../libs/ng/nucleus-identity/src/lib/nucleus-identity.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EAGpB,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,aAAa,GAEd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,kCAAkC,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;;;;;;;AAKrC,MAAM,OAAO,sBAAsB;IACjC,YACU,UAA6B,EACrC,QAAyB,EACjB,IAAgB,EAChB,MAAgC,EAChC,WAAwB;QAJxB,eAAU,GAAV,UAAU,CAAmB;QAE7B,SAAI,GAAJ,IAAI,CAAY;QAChB,WAAM,GAAN,MAAM,CAA0B;QAChC,gBAAW,GAAX,WAAW,CAAa;QAiB1B,2BAAsB,GAAG,IAAI,4BAA4B,EAAE,CAAC;QAE5D,iBAAY,GAAG,KAAK,CAAC;QACrB,iBAAY,GAAG,KAAK,CAAC;QACrB,yBAAoB,GAAyC,IAAI,CAAC;QAClE,qBAAgB,GAAkC,IAAI,CAAC;QACvD,qCAAgC,GAA2B,IAAI,CAAC;QAChE,6BAAwB,GAAG,OAAO,CAAC;QAtBzC,MAAM,OAAO,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;QACnC,IAAI,CAAC,qBAAqB,GAAG,IAAI,sBAAsB,CACrD,OAAO,EACP,IAAI,qBAAqB,EAAE,EAC3B,QAAQ,EACR,IAAI,CAAC,OAAO,CACb,CAAC;QACF,IAAI,CAAC,qBAAqB,CAAC,wBAAwB,CACjD,IAAI,CAAC,sBAAsB,CAC5B,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;IAaD,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC;IAC/B,CAAC;IAED,IAAW,wBAAwB;QACjC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAChE,CAAC;IAED,IAAW,+BAA+B;QACxC,OAAO,IAAI,CAAC,wBAAwB,IAAI,IAAI,CAAC;IAC/C,CAAC;IAED,IAAW,0BAA0B;QACnC,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,KAAK,IAAI,CAAC,wBAAwB,CAAC;IACzE,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,UAAU,GAAG,KAAK;QAClC,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,EAAE;YAC1C,OAAO,CAAC,IAAI,CACV,8FAA8F,CAC/F,CAAC;YACF,OAAO;SACR;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEzB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,MAAM,IAAI,CAAC,qBAAqB,CAAC,sCAAsC,EAAE,CAAC;QAE1E,MAAM,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC;QAClD,IAAI,OAAO,EAAE;YACX,MAAM,IAAI,KAAK,CACb,qBAAqB,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,CACxE,CAAC;SACH;aAAM,IAAI,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE;YAC/C,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,EAAE,CAAC;YAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC;YACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC;YAEtD,MAAM,YAAY,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACxF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;YAC5G,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SACjC;aAAM;YACL,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzC,IAAI,CAAC,GAAG,IAAI,UAAU,EAAE;gBACtB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;aACpB;SACF;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,QAAgB,EAChB,MAAc;QAEd,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QAC1B,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QACpE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAC5C,QAAQ,EACR,MAAM,EACN,cAAc,EACd,KAAK,CACN,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACvC,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACnD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC5B,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE;gBACtD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,KAAK,KAAK,EAAE;oBACtC,OAAO,CAAC,KAAK,EAAE,CAAC;iBACjB;gBACD,QAAQ,CAAC,MAAM,EAAE,CAAC;gBAClB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACxC,IAAI,IAAI,EAAE;oBACR,MAAM,SAAS,GACb,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,GAAG,GAAG,IAAI,CAAC;oBACjE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBAClC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;iBAC1B;qBAAM;oBACL,OAAO,CAAC,IAAI,CACV,oEAAoE,EACpE,IAAI,CACL,CAAC;iBACH;YACH,CAAC,CAAC,CAAC;SACJ;QACD,IAAI,CAAC,qBAAqB,CAAC,2BAA2B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC;IAEM,KAAK,CAAC,MAAM;QACjB,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QAC5C,MAAM,SAAS,GACb,MAAM,CAAC,kBAAkB;YACzB,4BAA4B;YAC5B,SAAS,CAAC,WAAW,CAAC,CAAC;QACzB,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC5B,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,CAAC,YAAY,EAAE,GAAG,EAAE;gBAClD,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;oBAC7B,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE;wBAC3B,OAAO,CAAC,KAAK,EAAE,CAAC;qBACjB;gBACH,CAAC,CAAC,CAAC;gBACH,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;SAClC;aAAM;YACL,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;SACnC;IACH,CAAC;IAEM,KAAK,CAAC,cAAc;QACzB,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YAC1B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;SACvD;QACD,IAAI;YACF,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC;SACpC;gBAAS;YACR,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAC9B;IACH,CAAC;IAEM,KAAK,CAAC,8BAA8B;QACzC,IAAI,CAAC,IAAI,CAAC,gCAAgC,EAAE;YAC1C,IAAI,CAAC,gCAAgC;gBACnC,IAAI,CAAC,sCAAsC,EAAE,CAAC;SACjD;QACD,IAAI;YACF,OAAO,MAAM,IAAI,CAAC,gCAAgC,CAAC;SACpD;gBAAS;YACR,IAAI,CAAC,gCAAgC,GAAG,IAAI,CAAC;SAC9C;IACH,CAAC;IAEM,KAAK,CAAC,qBAAqB;QAChC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;QACnD,IAAI,EAAE,EAAE;YACN,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,+BAA+B,CAAC,CAAC;YACpF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,sBAAsB,CACvD,EAAE,CAAC,EAAE,EACL,EAAE,CAAC,MAAM,EACT,KAAK,CACN,CAAC;YACF,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,wBAAwB,CAAC,CAAC;YAC/D,OAAO,GAAG,CAAC;SACZ;aAAM;YACL,MAAM,KAAK,CAAC,sCAAsC,CAAC,CAAC;SACrD;IACH,CAAC;IAEM,KAAK,CAAC,uBAAuB;QAClC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACxE,IAAI,CAAC,KAAK,EAAE;YACV,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;SACpC;QACD,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAClE,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,IAAa,EAAE,SAAS,GAAG,CAAC,CAAC;QAC/C,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC;QAC/D,IAAI,SAAS,GAAG,CAAC,EAAE;YACjB,GAAG,IAAI,cAAc,SAAS,EAAE,CAAC;SAClC;QACD,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAc,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,EAAU;QAClC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;QAC1D,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAY,GAAG,CAAC,CAAC,CAAC;IACtD,CAAC;IAEM,SAAS,CAAC,WAAmB,EAAE,QAAgB;QACpD,MAAM,OAAO,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;QAChD,MAAM,GAAG,GAAG,sBAAsB,QAAQ,cAAc,OAAO,EAAE,CAAC;QAClE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,iCAAiC;QAC5C,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;QACnD,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,oCAAoC,CAAC,UAAsB;QACtE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAC5D,QAAQ,CAAC,WAAW,CACrB,CAAC;QAEF,MAAM,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC;YACpC,EAAE,EAAE,MAAM,CAAC,QAAQ;YACnB,MAAM,EAAE,MAAM,CAAC,YAAY;YAC3B,SAAS,EAAE,MAAM,CAAC,oBAAoB;SACvC,CAAC,CAAC;IACL,CAAC;IAEM,kCAAkC;QACvC,OAAO,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,qCAAqC;QAChD,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;QACnD,OAAO,IAAI,kCAAkC,CAAC,EAAE,CAAC,CAAC;IACpD,CAAC;IAEM,KAAK,CAAC,oBAAoB;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QACnE,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAEM,KAAK,CAAC,uBAAuB,CAAC,UAAsB;QACzD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;QACtD,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAAC,UAAsB;QACrD,IAAI,GAAG,GAAyB,IAAI,CAAC;QACrC,GAAG;YACD,IAAI,UAAU,CAAC,SAAS,EAAE,EAAE;gBAC1B,MAAM,KAAK,CAAC,yBAAyB,CAAC,CAAC;aACxC;YAED,IAAI;gBACF,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;aACrE;YAAC,OAAO,KAAK,EAAE;gBACd,IACE,KAAK,YAAY,YAAY;oBAC7B,KAAK,CAAC,OAAO,KAAK,uBAAuB,EACzC;oBACA,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;iBACxB;qBAAM;oBACL,MAAM,KAAK,CAAC;iBACb;aACF;SACF,QAAQ,CAAC,GAAG,EAAE;QACf,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,2BAA2B;QACjC,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QAE5C,MAAM,MAAM,GAAG;YACb,aAAa,EAAE,UAAU;YACzB,MAAM,EAAE,SAAS;YACjB,WAAW,EAAE,SAAS;YACtB,kBAAkB,EAAE,IAAI,CAAC,MAAM,CAAC,gBAAgB;SACjD,CAAC;QAEF,OAAO,IAAI,oBAAoB,CAC7B;YACE,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC/B,YAAY,EAAE,WAAW;YACzB,aAAa,EAAE,oBAAoB,CAAC,kBAAkB;YACtD,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC;YAC3D,MAAM,EAAE,MAAmB;SAC5B,EACD,IAAI,CAAC,OAAO,EACZ,IAAI,CACL,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,sCAAsC;QAClD,IAAI,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACtE,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YACrB,KAAK,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC5C;QACD,OAAO,KAAK,EAAE,WAAW,CAAC;IAC5B,CAAC;IAEO,KAAK,CAAC,sBAAsB;QAClC,IAAI,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;QACzC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE;YAC7B,KAAK,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;SACjD;QACD,OAAO,KAAK,EAAE,WAAW,IAAI,IAAI,CAAC;IACpC,CAAC;IAEO,KAAK,CAAC,qBAAqB,CAAC,KAAoB;QACtD,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE;YAC9B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;SACvE;QACD,IAAI;YACF,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC;SACxC;gBAAS;YACR,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;SAClC;IACH,CAAC;IAEO,KAAK,CAAC,6BAA6B,CAAC,KAAoB;QAC9D,IAAI,KAAK,EAAE,YAAY,EAAE;YACvB,IAAI;gBACF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAClD,KAAK,CAAC,YAAY,CACnB,CAAC;gBACF,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAChC,OAAO,GAAG,CAAC;aACZ;YAAC,OAAO,GAAG,EAAE;gBACZ,OAAO,CAAC,IAAI,CACV,uDAAuD,EACvD,GAAG,CACJ,CAAC;gBACF,8DAA8D;gBAC9D,IAAK,GAAW,CAAC,OAAO,KAAK,eAAe,EAAE;oBAC5C,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;iBACrB;aACF;SACF;aAAM;YACL,OAAO,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;SACxE;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,WAAW,CAAC,GAAW;QAC7B,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YAClB,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE;gBAC5B,OAAO,IAAI,CAAC;aACb;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,oBAAoB;QAC1B,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE;YACzD,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YACzD,IAAI,IAAI,EAAE;gBACR,OAAO,CAAC,GAAG,CACT,kFAAkF,CACnF,CAAC;gBACF,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;aACnC;SACF;IACH,CAAC;IAEO,YAAY,CAAC,aAAsB,EAAE,cAAuB;QAClE,IAAI,KAAK,GAAG,QAAQ,CAAC;QACrB,IAAI,aAAa,EAAE;YACjB,KAAK,IAAI,iBAAiB,CAAC;SAC5B;QACD,IAAI,cAAc,EAAE;YAClB,KAAK,IAAI,GAAG,GAAG,cAAc,CAAC;SAC/B;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,KAAK,CAAC,WAAmB;QAC/B,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnC,UAAU,CAAC,GAAG,EAAE;gBACd,OAAO,EAAE,CAAC;YACZ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;+GA3YU,sBAAsB;mHAAtB,sBAAsB,cAFrB,MAAM;;4FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\n  AuthorizationRequest,\n  TokenResponse,\n  Crypto,\n  RedirectRequestHandler,\n  BasicQueryStringUtils,\n  LocalStorageBackend,\n  AppAuthError,\n  DefaultCrypto,\n  StringMap,\n} from '@openid/appauth';\n\nimport { Injectable } from '@angular/core';\nimport { App } from '@capacitor/app';\nimport { Browser } from '@capacitor/browser';\nimport { Device } from '@capacitor/device';\nimport { NucleusAppService } from '@kolektor/nucleus-common';\nimport { LocationService } from './utils/location.service';\nimport { AuthorizationRequestHandler } from '@openid/appauth';\nimport { NucleusAuthorizationNotifier } from './utils/nucleus-authorization-notifier';\nimport { HttpClient } from '@angular/common/http';\nimport { OtpResponse, OtpStatus, OtpType } from './models/otp';\nimport { SecretsStore } from './utils/secrets-store';\nimport { OidcConfigurationService } from './utils/oidc-configuration.service';\nimport { TokenClient } from './utils/token-client';\nimport { DeviceCode } from './models/device-code';\nimport { ServicePrincipalRegistrationStatus } from './models/service-principal';\nimport { lastValueFrom } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NucleusIdentityService {\n  constructor(\n    private appService: NucleusAppService,\n    location: LocationService,\n    private http: HttpClient,\n    private config: OidcConfigurationService,\n    private tokenClient: TokenClient\n  ) {\n    const storage = new LocalStorageBackend();\n    this._crypto = new DefaultCrypto();\n    this._authorizationHandler = new RedirectRequestHandler(\n      storage,\n      new BasicQueryStringUtils(),\n      location,\n      this._crypto\n    );\n    this._authorizationHandler.setAuthorizationNotifier(\n      this._authorizationNotifier\n    );\n    this._store = new SecretsStore(config.clientId);\n  }\n\n  private _authorizationHandler: AuthorizationRequestHandler;\n  private _authorizationNotifier = new NucleusAuthorizationNotifier();\n  private _crypto: Crypto;\n  private _initStarted = false;\n  private _initialized = false;\n  private _refreshTokenPromise: Promise<TokenResponse | null> | null = null;\n  private _getTokenPromise: Promise<string | null> | null = null;\n  private _getServicePrincipalTokenPromise: Promise<string> | null = null;\n  private _servicePrincipalTokenId = '_svcp';\n  private _store: SecretsStore;\n\n  public get identity() {\n    return this._store.getIdentity();\n  }\n\n  public get isAuthenticated() {\n    return this.identity != null;\n  }\n\n  public get servicePrincipalIdentity() {\n    return this._store.getIdentity(this._servicePrincipalTokenId);\n  }\n\n  public get isServicePrincipalAuthenticated() {\n    return this.servicePrincipalIdentity != null;\n  }\n\n  public get isIdentityServicePrincipal() {\n    return this._store.defaultIdentityId === this._servicePrincipalTokenId;\n  }\n\n  public async init(startLogin = false): Promise<void> {\n    if (this._initStarted || this._initialized) {\n      console.warn(\n        \"Nucleus.Identity: Auth initialization was already started. Don't call init() multiple times!\"\n      );\n      return;\n    }\n    this._initStarted = true;\n\n    this.handleLaunchCodeHash();\n    await this._authorizationHandler.completeAuthorizationRequestIfPossible();\n\n    const authErr = this._authorizationNotifier.error;\n    if (authErr) {\n      throw new Error(\n        'Authorization err: ' + authErr.error + ': ' + authErr.errorDescription\n      );\n    } else if (this._authorizationNotifier.response) {\n      window.location.hash = '';\n      const request = this._authorizationNotifier.request;\n      const response = this._authorizationNotifier.response;\n\n      const codeVerifier = (request.internal) ? request.internal['code_verifier'] : undefined;\n      const res = await this.tokenClient.getByAuthorizationCode(request.redirectUri, response.code, codeVerifier);\n      this._store.setDefaultIdentityId(null);\n      await this._store.setToken(res);\n    } else {\n      const res = await this._store.getToken();\n      if (!res && startLogin) {\n        await this.login();\n      }\n    }\n    this._initialized = true;\n  }\n\n  public async loginWithSecret(\n    provider: string,\n    secret: string\n  ): Promise<void> {\n    this._store.removeToken();\n    const assertionToken = await this.getServicePrincipalAccessToken();\n    const scope = this.prepareScope(true, this.config?.requestedScopes);\n    const res = await this.tokenClient.getBySecret(\n      provider,\n      secret,\n      assertionToken,\n      scope\n    );\n    this._store.setDefaultIdentityId(null);\n    await this._store.setToken(res);\n  }\n\n  public async login(): Promise<void> {\n    this._store.removeToken();\n    const config = await this.config.getConfiguration();\n    const request = this.prepareAuthorizationRequest();\n    if (this.appService.isNative) {\n      const listener = App.addListener('appUrlOpen', (data) => {\n        if (this.appService.platform === 'ios') {\n          Browser.close();\n        }\n        listener.remove();\n        const hash = this.getCodeHash(data.url);\n        if (hash) {\n          const targetUrl =\n            window.location.origin + window.location.pathname + '#' + hash;\n          window.location.assign(targetUrl);\n          window.location.reload();\n        } else {\n          console.warn(\n            'Nucleus.Identity: Redirect url did not contain authorization code!',\n            data\n          );\n        }\n      });\n    }\n    this._authorizationHandler.performAuthorizationRequest(config, request);\n  }\n\n  public async logout(): Promise<void> {\n    this._store.removeToken();\n    const config = await this.config.getConfiguration();\n    const redirectUrl = this.config.redirectUrl;\n    const logoutUrl =\n      config.endSessionEndpoint +\n      '?post_logout_redirect_uri=' +\n      encodeURI(redirectUrl);\n    if (this.appService.isNative) {\n      const listener = App.addListener('appUrlOpen', () => {\n        Device.getInfo().then((info) => {\n          if (info.platform === 'ios') {\n            Browser.close();\n          }\n        });\n        listener.remove();\n      });\n      Browser.open({ url: logoutUrl });\n    } else {\n      window.location.assign(logoutUrl);\n    }\n  }\n\n  public async getAccessToken() {\n    if (!this._getTokenPromise) {\n      this._getTokenPromise = this.getAccessTokenInternal();\n    }\n    try {\n      return await this._getTokenPromise;\n    } finally {\n      this._getTokenPromise = null;\n    }\n  }\n\n  public async getServicePrincipalAccessToken() {\n    if (!this._getServicePrincipalTokenPromise) {\n      this._getServicePrincipalTokenPromise =\n        this.getServicePrincipalAccessTokenInternal();\n    }\n    try {\n      return await this._getServicePrincipalTokenPromise;\n    } finally {\n      this._getServicePrincipalTokenPromise = null;\n    }\n  }\n\n  public async loginServicePrincipal() {\n    const sp = await this._store.getServicePrincipal();\n    if (sp) {\n      const scope = this.prepareScope(false, this.config.servicePrincipalRequestedScopes);\n      const res = await this.tokenClient.getByClientCredentials(\n        sp.id,\n        sp.secret,\n        scope\n      );\n      await this._store.setToken(res, this._servicePrincipalTokenId);\n      return res;\n    } else {\n      throw Error('Service principal is not registered!');\n    }\n  }\n\n  public async loginAsServicePrincipal() {\n    const token = await this._store.getToken(this._servicePrincipalTokenId);\n    if (!token) {\n      await this.loginServicePrincipal();\n    }\n    this._store.setDefaultIdentityId(this._servicePrincipalTokenId);\n  }\n\n  public async getOtp(type: OtpType, expiresIn = -1) {\n    let url = this.config.getServerUrl(`/otp/create?type=${type}`);\n    if (expiresIn > 0) {\n      url += `&expiresIn=${expiresIn}`;\n    }\n    return lastValueFrom(this.http.get<OtpResponse>(url));\n  }\n\n  public async getOtpStatus(id: string) {\n    const url = this.config.getServerUrl(`/otp/status/${id}`);\n    return lastValueFrom(this.http.get<OtpStatus>(url));\n  }\n\n  public getOtpUrl(redirectUrl: string, password: string) {\n    const encoded = encodeURIComponent(redirectUrl);\n    const url = `/otp/auth?otpValue=${password}&returnUrl=${encoded}`;\n    return this.config.getServerUrl(url);\n  }\n\n  public async startServicePrincipalRegistration() {\n    const sp = await this._store.getServicePrincipal();\n    return await this.tokenClient.getRegistrationCode(sp?.id);\n  }\n\n  public async completeServicePrincipalRegistration(deviceCode: DeviceCode) {\n    const tokenRes = await this.waitForDeviceToken(deviceCode);\n    const regRes = await this.tokenClient.registerServicePrincipal(\n      tokenRes.accessToken\n    );\n\n    await this._store.setServicePrincipal({\n      id: regRes.clientId,\n      secret: regRes.clientSecret,\n      expiresAt: regRes.secretExpirationDate,\n    });\n  }\n\n  public removeServicePrincipalRegistration() {\n    return this._store.removeServicePrincipal();\n  }\n\n  public async getServicePrincipalRegistrationStatus() {\n    const sp = await this._store.getServicePrincipal();\n    return new ServicePrincipalRegistrationStatus(sp);\n  }\n\n  public async startDeviceCodeLogin() {\n    const scope = this.prepareScope(true, this.config.requestedScopes);\n    return await this.tokenClient.getDeviceCode(scope);\n  }\n\n  public async completeDeviceCodeLogin(deviceCode: DeviceCode) {\n    const res = await this.waitForDeviceToken(deviceCode);\n    await this._store.setToken(res);\n  }\n\n  private async waitForDeviceToken(deviceCode: DeviceCode) {\n    let res: TokenResponse | null = null;\n    do {\n      if (deviceCode.isExpired()) {\n        throw Error('Device code is expired!');\n      }\n\n      try {\n        res = await this.tokenClient.getByDeviceCode(deviceCode.deviceCode);\n      } catch (error) {\n        if (\n          error instanceof AppAuthError &&\n          error.message === 'authorization_pending'\n        ) {\n          await this.delay(2000);\n        } else {\n          throw error;\n        }\n      }\n    } while (!res);\n    return res;\n  }\n\n  private prepareAuthorizationRequest(): AuthorizationRequest {\n    const redirectUri = this.config.redirectUrl;\n\n    const params = {\n      response_mode: 'fragment',\n      prompt: 'consent',\n      access_type: 'offline',\n      auth_provider_hint: this.config.authProviderHint,\n    };\n\n    return new AuthorizationRequest(\n      {\n        client_id: this.config.clientId,\n        redirect_uri: redirectUri,\n        response_type: AuthorizationRequest.RESPONSE_TYPE_CODE,\n        scope: this.prepareScope(true, this.config.requestedScopes),\n        extras: params as StringMap,\n      },\n      this._crypto,\n      true\n    );\n  }\n\n  private async getServicePrincipalAccessTokenInternal() {\n    let token = await this._store.getToken(this._servicePrincipalTokenId);\n    if (!token?.isValid()) {\n      token = await this.loginServicePrincipal();\n    }\n    return token?.accessToken;\n  }\n\n  private async getAccessTokenInternal() {\n    let token = await this._store.getToken();\n    if (token && !token.isValid()) {\n      token = await this.loginWithRefreshToken(token);\n    }\n    return token?.accessToken ?? null;\n  }\n\n  private async loginWithRefreshToken(token: TokenResponse) {\n    if (!this._refreshTokenPromise) {\n      this._refreshTokenPromise = this.loginWithRefreshTokenInternal(token);\n    }\n    try {\n      return await this._refreshTokenPromise;\n    } finally {\n      this._refreshTokenPromise = null;\n    }\n  }\n\n  private async loginWithRefreshTokenInternal(token: TokenResponse) {\n    if (token?.refreshToken) {\n      try {\n        const res = await this.tokenClient.getByRefreshToken(\n          token.refreshToken\n        );\n        await this._store.setToken(res);\n        return res;\n      } catch (err) {\n        console.warn(\n          'Nucleus.Identity: Failed to login with refresh token.',\n          err\n        );\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if ((err as any).message === 'invalid_grant') {\n          await this.logout();\n        }\n      }\n    } else {\n      console.warn('Nucleus.Identity: There is no refresh token available.');\n    }\n    return null;\n  }\n\n  private getCodeHash(url: string) {\n    const arr = url.split('#');\n    if (arr.length > 1) {\n      const hash = arr[1];\n      if (hash.startsWith('code=')) {\n        return hash;\n      }\n    }\n    return null;\n  }\n\n  private handleLaunchCodeHash() {\n    if (this.appService.isNative && this.appService.launchUrl) {\n      const hash = this.getCodeHash(this.appService.launchUrl);\n      if (hash) {\n        console.log(\n          'Nucleus.Identity: Got authorization code from launchUrl, will assign it to hash.'\n        );\n        window.location.hash = '#' + hash;\n      }\n    }\n  }\n\n  private prepareScope(offlineAccess: boolean, aditionalScope?: string) {\n    let scope = 'openid';\n    if (offlineAccess) {\n      scope += ' offline_access';\n    }\n    if (aditionalScope) {\n      scope += ' ' + aditionalScope;\n    }\n    return scope;\n  }\n\n  private delay(miliseconds: number) {\n    return new Promise<void>((resolve) => {\n      setTimeout(() => {\n        resolve();\n      }, miliseconds);\n    });\n  }\n}\n"]}