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

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

@@ -0,0 +1,69 @@
+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 && this._interceptUrls.length > 0) {
+            return this.config.httpInterceptorUrls?.some((x) => url.startsWith(x)) ?? false;
+        }
+        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);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusTokenInterceptor, deps: [{ token: i1.NucleusIdentityService }, { token: i2.NucleusIdentityConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusTokenInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusTokenInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NucleusIdentityService }, { type: i2.NucleusIdentityConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/angular-requestor.mjs

@@ -0,0 +1,44 @@
+import { AppAuthError, Requestor } from '@openid/appauth';
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class AngularRequestor extends Requestor {
+    constructor(http) {
+        super();
+        this.http = http;
+    }
+    // eslint-disable-next-line no-undef
+    xhr(settings) {
+        let method = 'GET';
+        if (settings.method) {
+            method = settings.method;
+        }
+        return new Promise((resolve, reject) => {
+            this.http
+                .request(method, settings.url, {
+                body: settings.data,
+                headers: settings.headers,
+            }).
+                subscribe({
+                next: res => resolve(res),
+                error: err => {
+                    let e = new AppAuthError(err);
+                    if (err instanceof HttpErrorResponse) {
+                        e = new AppAuthError(err.error?.error || err.statusText);
+                    }
+                    reject(e);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularRequestor, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularRequestor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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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

package/esm2022/lib/utils/authorization-service-configuration.mjs

@@ -0,0 +1,28 @@
+import { AuthorizationServiceConfiguration, JQueryRequestor, } from '@openid/appauth';
+const WELL_KNOWN_PATH = '.well-known';
+const OPENID_CONFIGURATION = 'openid-configuration';
+export class NucleusAuthorizationServiceConfiguration extends AuthorizationServiceConfiguration {
+    constructor(request) {
+        super(request);
+        this.deviceAuthorizationEndpoint = request.device_authorization_endpoint;
+        this.registrationEndpoint = request.registration_endpoint;
+    }
+    static async fetchFromIssuer(openIdIssuerUrl, requestor) {
+        const fullUrl = `${openIdIssuerUrl}/${WELL_KNOWN_PATH}/${OPENID_CONFIGURATION}`;
+        const requestorToUse = requestor || new JQueryRequestor();
+        const json = await requestorToUse
+            .xhr({
+            url: fullUrl,
+            dataType: 'json',
+            method: 'GET',
+        });
+        return new NucleusAuthorizationServiceConfiguration(json);
+    }
+    toJson() {
+        const res = super.toJson();
+        res.device_authorization_endpoint = this.deviceAuthorizationEndpoint;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return res;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/location.service.mjs

@@ -0,0 +1,72 @@
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { Browser } from '@capacitor/browser';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@kolektor/nucleus-common";
+export class LocationService {
+    constructor(appService) {
+        this.appService = appService;
+    }
+    get hash() {
+        return window.location.hash;
+    }
+    set hash(v) {
+        window.location.hash = v;
+    }
+    get host() {
+        return window.location.host;
+    }
+    set host(v) {
+        window.location.host = v;
+    }
+    get origin() {
+        return window.location.origin;
+    }
+    get hostname() {
+        return window.location.hostname;
+    }
+    set hostname(v) {
+        window.location.hostname = v;
+    }
+    get pathname() {
+        return window.location.pathname;
+    }
+    set pathname(v) {
+        window.location.pathname = v;
+    }
+    get port() {
+        return window.location.port;
+    }
+    set port(v) {
+        window.location.port = v;
+    }
+    get protocol() {
+        return window.location.protocol;
+    }
+    set protocol(v) {
+        window.location.protocol = v;
+    }
+    get search() {
+        return window.location.search;
+    }
+    set search(v) {
+        window.location.search = v;
+    }
+    assign(url) {
+        if (this.appService.isNative) {
+            Browser.open({ url });
+        }
+        else {
+            window.location.assign(url);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocationService, deps: [{ token: i1.NucleusAppService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NucleusAppService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/nucleus-authorization-notifier.mjs

@@ -0,0 +1,15 @@
+import { AuthorizationNotifier } from '@openid/appauth';
+export class NucleusAuthorizationNotifier extends AuthorizationNotifier {
+    constructor() {
+        super();
+        this.response = null;
+        this.error = null;
+        this.setAuthorizationListener((request, response, error) => {
+            console.log('Authorization request complete ', request, response, error);
+            this.response = response;
+            this.request = request;
+            this.error = error;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVjbGV1cy1hdXRob3JpemF0aW9uLW5vdGlmaWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9uZy9udWNsZXVzLWlkZW50aXR5L3NyYy9saWIvdXRpbHMvbnVjbGV1cy1hdXRob3JpemF0aW9uLW5vdGlmaWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBSXhELE1BQU0sT0FBTyw0QkFBNkIsU0FBUSxxQkFBcUI7SUFLckU7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUxWLGFBQVEsR0FBaUMsSUFBSSxDQUFDO1FBRTlDLFVBQUssR0FBOEIsSUFBSSxDQUFDO1FBSXRDLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLEVBQUU7WUFDekQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQ0FBaUMsRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ3pFLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXV0aG9yaXphdGlvbk5vdGlmaWVyIH0gZnJvbSAnQG9wZW5pZC9hcHBhdXRoJztcbmltcG9ydCB7IEF1dGhvcml6YXRpb25SZXNwb25zZSwgQXV0aG9yaXphdGlvbkVycm9yIH0gZnJvbSAnQG9wZW5pZC9hcHBhdXRoJztcbmltcG9ydCB7IEF1dGhvcml6YXRpb25SZXF1ZXN0IH0gZnJvbSAnQG9wZW5pZC9hcHBhdXRoJztcblxuZXhwb3J0IGNsYXNzIE51Y2xldXNBdXRob3JpemF0aW9uTm90aWZpZXIgZXh0ZW5kcyBBdXRob3JpemF0aW9uTm90aWZpZXIge1xuICByZXNwb25zZTogQXV0aG9yaXphdGlvblJlc3BvbnNlIHwgbnVsbCA9IG51bGw7XG4gIHJlcXVlc3QhOiBBdXRob3JpemF0aW9uUmVxdWVzdDtcbiAgZXJyb3I6IEF1dGhvcml6YXRpb25FcnJvciB8IG51bGwgPSBudWxsO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKCk7XG4gICAgdGhpcy5zZXRBdXRob3JpemF0aW9uTGlzdGVuZXIoKHJlcXVlc3QsIHJlc3BvbnNlLCBlcnJvcikgPT4ge1xuICAgICAgY29uc29sZS5sb2coJ0F1dGhvcml6YXRpb24gcmVxdWVzdCBjb21wbGV0ZSAnLCByZXF1ZXN0LCByZXNwb25zZSwgZXJyb3IpO1xuICAgICAgdGhpcy5yZXNwb25zZSA9IHJlc3BvbnNlO1xuICAgICAgdGhpcy5yZXF1ZXN0ID0gcmVxdWVzdDtcbiAgICAgIHRoaXMuZXJyb3IgPSBlcnJvcjtcbiAgICB9KTtcbiAgfVxufVxuIl19

package/esm2022/lib/utils/oidc-configuration.service.mjs

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { NucleusIdentityConfig } from '../nucleus-identity-config';
+import { AngularRequestor } from './angular-requestor';
+import { NucleusAuthorizationServiceConfiguration } from './authorization-service-configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "./angular-requestor";
+import * as i2 from "../nucleus-identity-config";
+import * as i3 from "@kolektor/nucleus-common";
+export class OidcConfigurationService {
+    constructor(requestor, config, appService) {
+        this.requestor = requestor;
+        this.config = config;
+        this.appService = appService;
+        this._configuration = null;
+    }
+    async getConfiguration() {
+        await this.assureConfiguration();
+        if (!this._configuration) {
+            throw Error('Failed to get OIDC configuration!');
+        }
+        return this._configuration;
+    }
+    get clientId() {
+        return this.config.clientId;
+    }
+    get requestedScopes() {
+        return this.config.requestedScopes;
+    }
+    get servicePrincipalRequestedScopes() {
+        return this.config.servicePrincipalRequestedScopes;
+    }
+    get authProviderHint() {
+        return this.config.authProviderHint;
+    }
+    get redirectUrl() {
+        let uri = window.location.href;
+        const platform = this.appService.platform;
+        if (platform === 'android' && this.config.androidRedirectUri) {
+            uri = this.config.androidRedirectUri;
+        }
+        else if (platform === 'ios' && this.config.iOSRedirectUri) {
+            uri = this.config.iOSRedirectUri;
+        }
+        else if (this.config.redirectUri) {
+            uri = this.config.redirectUri;
+        }
+        return this.NormalizeRedirectUri(uri);
+    }
+    getServerUrl(relativeUri = null) {
+        let authority = this.config.authority;
+        if (!authority || authority === 'origin') {
+            authority = window.origin;
+        }
+        let url = new URL(authority);
+        if (relativeUri) {
+            url = new URL(relativeUri, url);
+        }
+        return url.href;
+    }
+    NormalizeRedirectUri(uri) {
+        const i = uri.indexOf('#');
+        if (i > 0) {
+            uri = uri.substring(0, i);
+        }
+        return uri;
+    }
+    async assureConfiguration() {
+        if (this._configuration != null) {
+            return;
+        }
+        let authority = this.getServerUrl();
+        if (authority[authority.length - 1] === '/') {
+            authority = authority.slice(0, -1);
+        }
+        try {
+            this._configuration =
+                await NucleusAuthorizationServiceConfiguration.fetchFromIssuer(authority, this.requestor);
+        }
+        catch (e) {
+            console.error('Nucleus.Identity: Cannot load OIDC configuration: ' +
+                e.message);
+            throw e;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: OidcConfigurationService, deps: [{ token: i1.AngularRequestor }, { token: i2.NucleusIdentityConfig }, { token: i3.NucleusAppService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: OidcConfigurationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: OidcConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AngularRequestor }, { type: i2.NucleusIdentityConfig }, { type: i3.NucleusAppService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/secrets-store.mjs

@@ -0,0 +1,120 @@
+import 'capacitor-secure-storage-plugin';
+import { TokenResponse } from '@openid/appauth';
+import { SecureStoragePlugin } from 'capacitor-secure-storage-plugin';
+import { Identity } from '../models/identity';
+export class SecretsStore {
+    constructor(clientId) {
+        this._tokens = {};
+        this._identities = {};
+        this._servicePrincipal = null;
+        this._tokenStorageKeyPrefix = `Nucleus.Identity.${clientId}`; // do not change this or login with existing tokens will fail
+        this._servicePrincipalKey = `${this._tokenStorageKeyPrefix}.SvcP`;
+        this._defaultIdentityIdStorageKey = `${this._tokenStorageKeyPrefix}.IdId`;
+        this._defaultIdentityId = localStorage.getItem(this._defaultIdentityIdStorageKey);
+    }
+    get defaultIdentityId() {
+        return this._defaultIdentityId;
+    }
+    removeServicePrincipal() {
+        this._servicePrincipal = null;
+        return this.clear(this._servicePrincipalKey);
+    }
+    async setServicePrincipal(servicePrincipal) {
+        this._servicePrincipal = servicePrincipal;
+        await this.save(this._servicePrincipalKey, servicePrincipal);
+    }
+    async getServicePrincipal() {
+        if (!this._servicePrincipal) {
+            this._servicePrincipal = await this.load(this._servicePrincipalKey);
+        }
+        return this._servicePrincipal;
+    }
+    setToken(token, id = null) {
+        return this.setTokenInternal(token, true, id);
+    }
+    getIdentity(id = null) {
+        const key = this.getTokenKey(id);
+        return this._identities[key];
+    }
+    setDefaultIdentityId(id) {
+        this._defaultIdentityId = id;
+        if (this._defaultIdentityId) {
+            localStorage.setItem(this._defaultIdentityIdStorageKey, this._defaultIdentityId);
+        }
+        else {
+            localStorage.removeItem(this._defaultIdentityIdStorageKey);
+        }
+    }
+    async getToken(id = null) {
+        const key = this.getTokenKey(id);
+        // if token is not there or it is invalid we check storage again before returning
+        if (!this._tokens[key] || !this._tokens[key]?.isValid()) {
+            await this.reloadTokenFromStorage(id);
+        }
+        return this._tokens[key];
+    }
+    removeToken(id = null) {
+        const key = this.getTokenKey(id);
+        delete this._tokens[key];
+        delete this._identities[key];
+        return this.clear(key);
+    }
+    async reloadTokenFromStorage(id) {
+        const key = this.getTokenKey(id);
+        const storedToken = await this.load(key);
+        if (storedToken) {
+            const res = new TokenResponse(storedToken);
+            if (res?.accessToken || res?.idToken) {
+                await this.setTokenInternal(res, false, id);
+            }
+        }
+        return null;
+    }
+    async setTokenInternal(token, save, id) {
+        const key = this.getTokenKey(id);
+        if (token == null) {
+            await this.removeToken(id);
+        }
+        else {
+            this._tokens[key] = token;
+            this._identities[key] = new Identity(token);
+            if (save) {
+                try {
+                    await this.save(key, token.toJson());
+                }
+                catch (e) {
+                    console.warn('Nucleus.Identity: Could not save to SecureStorage.');
+                }
+            }
+        }
+    }
+    getTokenKey(id) {
+        if (!id) {
+            id = this._defaultIdentityId;
+        }
+        return id
+            ? `${this._tokenStorageKeyPrefix}.${id}`
+            : this._tokenStorageKeyPrefix;
+    }
+    clear(key) {
+        return SecureStoragePlugin.remove({ key });
+    }
+    save(key, value) {
+        return SecureStoragePlugin.set({ key, value: JSON.stringify(value) });
+    }
+    async load(key) {
+        try {
+            const x = await SecureStoragePlugin.get({ key });
+            if (x?.value) {
+                return JSON.parse(x.value);
+            }
+            else {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secrets-store.js","sourceRoot":"","sources":["../../../../../../../libs/ng/nucleus-identity/src/lib/utils/secrets-store.ts"],"names":[],"mappings":"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","sourcesContent":["import 'capacitor-secure-storage-plugin';\nimport { TokenResponse, TokenResponseJson } from '@openid/appauth';\nimport { ServicePrincipal } from '../models/service-principal';\nimport { SecureStoragePlugin } from 'capacitor-secure-storage-plugin';\nimport { Identity } from '../models/identity';\n\nexport class SecretsStore {\n  constructor(clientId: string) {\n    this._tokenStorageKeyPrefix = `Nucleus.Identity.${clientId}`; // do not change this or login with existing tokens will fail\n    this._servicePrincipalKey = `${this._tokenStorageKeyPrefix}.SvcP`;\n    this._defaultIdentityIdStorageKey = `${this._tokenStorageKeyPrefix}.IdId`;\n    this._defaultIdentityId = localStorage.getItem(\n      this._defaultIdentityIdStorageKey\n    );\n  }\n  private _tokenStorageKeyPrefix: string;\n  private _tokens: { [id: string]: TokenResponse | null } = {};\n  private _identities: { [id: string]: Identity } = {};\n  private _servicePrincipalKey;\n  private _servicePrincipal: ServicePrincipal | null = null;\n  // this specify which identity id is used by default, when If id is not specified in getToken or getIdentity\n  private _defaultIdentityId: string | null;\n  private _defaultIdentityIdStorageKey: string;\n\n  public get defaultIdentityId() {\n    return this._defaultIdentityId;\n  }\n\n  public removeServicePrincipal() {\n    this._servicePrincipal = null;\n    return this.clear(this._servicePrincipalKey);\n  }\n\n  public async setServicePrincipal(servicePrincipal: ServicePrincipal) {\n    this._servicePrincipal = servicePrincipal;\n    await this.save(this._servicePrincipalKey, servicePrincipal);\n  }\n\n  public async getServicePrincipal() {\n    if (!this._servicePrincipal) {\n      this._servicePrincipal = await this.load<ServicePrincipal>(\n        this._servicePrincipalKey\n      );\n    }\n    return this._servicePrincipal;\n  }\n\n  public setToken(token: TokenResponse, id: string | null = null) {\n    return this.setTokenInternal(token, true, id);\n  }\n\n  public getIdentity(id: string | null = null) : Identity | null {\n    const key = this.getTokenKey(id);\n    return this._identities[key];\n  }\n\n  public setDefaultIdentityId(id: string | null) {\n    this._defaultIdentityId = id;\n    if (this._defaultIdentityId) {\n      localStorage.setItem(\n        this._defaultIdentityIdStorageKey,\n        this._defaultIdentityId\n      );\n    } else {\n      localStorage.removeItem(this._defaultIdentityIdStorageKey);\n    }\n  }\n\n  public async getToken(id: string | null = null) {\n    const key = this.getTokenKey(id);\n\n    // if token is not there or it is invalid we check storage again before returning\n    if (!this._tokens[key] || !this._tokens[key]?.isValid()) {\n      await this.reloadTokenFromStorage(id);\n    }\n    return this._tokens[key];\n  }\n\n  public removeToken(id: string | null = null) {\n    const key = this.getTokenKey(id);\n    delete this._tokens[key];\n    delete this._identities[key];\n    return this.clear(key);\n  }\n\n  private async reloadTokenFromStorage(id: string | null) {\n    const key = this.getTokenKey(id);\n    const storedToken = await this.load<TokenResponseJson>(key);\n    if (storedToken) {\n      const res = new TokenResponse(storedToken);\n      if (res?.accessToken || res?.idToken) {\n        await this.setTokenInternal(res, false, id);\n      }\n    }\n    return null;\n  }\n\n  private async setTokenInternal(token: TokenResponse, save: boolean, id: string | null) {\n    const key = this.getTokenKey(id);\n    if (token == null) {\n      await this.removeToken(id);\n    } else {\n      this._tokens[key] = token;\n      this._identities[key] = new Identity(token);\n      if (save) {\n        try {\n          await this.save(key, token.toJson());\n        } catch (e) {\n          console.warn('Nucleus.Identity: Could not save to SecureStorage.');\n        }\n      }\n    }\n  }\n\n  private getTokenKey(id: string | null) {\n    if (!id) {\n      id = this._defaultIdentityId;\n    }\n    return id\n      ? `${this._tokenStorageKeyPrefix}.${id}`\n      : this._tokenStorageKeyPrefix;\n  }\n\n  private clear(key: string) {\n    return SecureStoragePlugin.remove({ key });\n  }\n\n  private save<T>(key: string, value: T): Promise<{ value: boolean }> {\n    return SecureStoragePlugin.set({ key, value: JSON.stringify(value) });\n  }\n\n  private async load<T>(key: string) {\n    try {\n      const x = await SecureStoragePlugin.get({ key });\n      if (x?.value) {\n        return JSON.parse(x.value) as T;\n      } else {\n        return null;\n      }\n    } catch {\n      return null;\n    }\n  }\n}\n"]}