@softheon/armature 10.45.5 → 15.0.1

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

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for managing the banner
+ */
+export class BannerService {
+    constructor() {
+        /** Behavior subject for show banner */
+        this.showBanner = new BehaviorSubject(false);
+        /** Behavior subject for banner message */
+        this.message = new BehaviorSubject(undefined);
+        /** Behavior subject for whether to show check mark or not */
+        this.showCheckMark = new BehaviorSubject(true);
+        this.showBanner$ = this.showBanner.asObservable();
+        this.message$ = this.message.asObservable();
+        this.showCheckMark$ = this.showCheckMark.asObservable();
+    }
+    /**
+     * Shows the messaage in the banner
+     * @param message The banner message
+     */
+    showMessage(message, showCheckMark = true) {
+        this.showBanner.next(true);
+        this.message.next(message);
+        this.showCheckMark.next(showCheckMark);
+    }
+    /**
+     * Hide Notification Message
+     */
+    hideMessage() {
+        this.showBanner.next(false);
+    }
+}
+BannerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BannerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BannerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BannerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BannerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/base-config.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** The base config service */
+export class BaseConfigService {
+    /** Gets the configurations */
+    get config() {
+        return this.configBs.value;
+    }
+    /**
+     * sets the configs
+     * @param value The new configuration value
+     */
+    set config(value) {
+        this.configBs.next(value);
+    }
+    /** Constructs the service */
+    constructor() {
+        /** The configuration behavior subject */
+        this.configBs = new BehaviorSubject(undefined);
+        this.config$ = this.configBs.asObservable();
+    }
+}
+BaseConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BaseConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BaseConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BaseConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: BaseConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/custom-auth-config.service.mjs

@@ -0,0 +1,4 @@
+/** Custom Authorization Service */
+export class CustomAuthConfigService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLWF1dGgtY29uZmlnLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL2NvcmUvc2VydmljZXMvY3VzdG9tLWF1dGgtY29uZmlnLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsbUNBQW1DO0FBQ25DLE1BQU0sT0FBZ0IsdUJBQXVCO0NBRzVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXV0aENvbmZpZyB9IGZyb20gJ2FuZ3VsYXItb2F1dGgyLW9pZGMnO1xyXG5cclxuLyoqIEN1c3RvbSBBdXRob3JpemF0aW9uIFNlcnZpY2UgKi9cclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEN1c3RvbUF1dGhDb25maWdTZXJ2aWNlIHtcclxuICAvKiogQ29uZmlndXJlIEF1dGggU2V0dGluZ3MgKi9cclxuICBwdWJsaWMgYWJzdHJhY3QgY29uZmlndXJlQXV0aFNldHRpbmdzKCk6IFByb21pc2U8QXV0aENvbmZpZz5cclxufVxyXG4iXX0=

package/esm2020/lib/core/services/default-config.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { BaseConfigService } from './base-config.service';
+import * as i0 from "@angular/core";
+export class DefaultConfigService extends BaseConfigService {
+    /** Constructs the service */
+    constructor() {
+        super();
+    }
+    ;
+}
+DefaultConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: DefaultConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DefaultConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: DefaultConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: DefaultConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1jb25maWcuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9kZWZhdWx0LWNvbmZpZy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBSzFELE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxpQkFBaUI7SUFFekQsNkJBQTZCO0lBQzdCO1FBQ0UsS0FBSyxFQUFFLENBQUM7SUFDVixDQUFDO0lBQUEsQ0FBQzs7aUhBTFMsb0JBQW9CO3FIQUFwQixvQkFBb0IsY0FGbkIsTUFBTTsyRkFFUCxvQkFBb0I7a0JBSGhDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBCYXNlQ29uZmlnU2VydmljZSB9IGZyb20gJy4vYmFzZS1jb25maWcuc2VydmljZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBEZWZhdWx0Q29uZmlnU2VydmljZSBleHRlbmRzIEJhc2VDb25maWdTZXJ2aWNlIHtcclxuXHJcbiAgLyoqIENvbnN0cnVjdHMgdGhlIHNlcnZpY2UgKi9cclxuICBjb25zdHJ1Y3RvcigpIHtcclxuICAgIHN1cGVyKCk7XHJcbiAgfTtcclxufVxyXG4iXX0=

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

@@ -0,0 +1,385 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { switchMap, take } from 'rxjs/operators';
+import { SESSION_CONFIG, WINDOW } from '../models/constants';
+import { httpVerb } from '../models/http-verbs';
+import { SessionConfig } from '../models/session-config';
+import { newGuid } from '../functions/guid';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../models/session-config";
+/** the data store retrieve complete session key */
+const dataStoreRetrieveCompleteSessionKey = 'dataStoreRetrieve';
+/** The session service */
+export class SessionService {
+    /** True if client side session management */
+    get isClientSessionManagement() {
+        return this.sessionConfig.sessionManagementImplementation === 'client';
+    }
+    /** True if server side session management */
+    get isServerSessionManagement() {
+        return this.sessionConfig.sessionManagementImplementation === 'server';
+    }
+    /** True if using browser local storage */
+    get useBrowserLocalStorage() {
+        return this.sessionConfig.browserStorageImplementation === 'local';
+    }
+    /** True if using browser session storage */
+    get useBrowserSessionStorage() {
+        return this.sessionConfig.browserStorageImplementation === 'session';
+    }
+    /** The session id */
+    get sessionId() {
+        if (!this._sessionId) {
+            this.isClientSessionManagement ? this.initClientSessionId() : this.initServerSessionId();
+        }
+        return this._sessionId;
+    }
+    /** gets the session */
+    get session() {
+        return this.sessionData.value;
+    }
+    /** sets the session */
+    set session(value) {
+        this.sessionData.next(value);
+        this.window.sessionStorage.setItem(this.sessionConfig.keyPath, this.encode(value));
+    }
+    /**
+     * Constructs the service
+     * @param sessionConfig The session configurations
+     * @param _window The window interface
+     * @param authService The OAuth odic 2 service
+     * @param httpClient The http client
+     */
+    constructor(sessionConfig, _window, authService, httpClient) {
+        this.sessionConfig = sessionConfig;
+        this._window = _window;
+        this.authService = authService;
+        this.httpClient = httpClient;
+        /** True when the data store retrieve is complete */
+        this.isDataStoreRetrieveComplete = false;
+        /** The local storage key */
+        this.storageKey = 'Sof-Arm-Session-Id';
+        /** Teh current update data store call */
+        this.currentUpdateDataStoreCall = of({});
+        /** The session data behavior subject */
+        this.sessionData = new BehaviorSubject(undefined);
+        /** True when the service has finished initializing */
+        this.isInitializedBs = new BehaviorSubject(false);
+        /** True if the data store is initialized */
+        this.isDataStoreInitBs = new BehaviorSubject(false);
+        /** True if data store is provided */
+        this.isDataStoreProvided = false;
+        this.isInitialized$ = this.isInitializedBs.asObservable();
+        this.isDataStoreInit$ = this.isDataStoreInitBs.asObservable();
+        if (!this.sessionConfig) {
+            this.sessionConfig = new SessionConfig();
+        }
+        this.isDataStoreProvided = !!this.sessionConfig?.dataStoreConfig;
+        this.window = _window;
+        if (!this.window) {
+            this.window = window;
+        }
+        const dataStoreLoadedValue = this.window.sessionStorage.getItem(dataStoreRetrieveCompleteSessionKey);
+        this.isDataStoreRetrieveComplete = !!dataStoreLoadedValue ? dataStoreLoadedValue.toLowerCase() === 'true' : false;
+        // if not using a data store, update the initialized to true for it
+        if (!this.isDataStoreProvided) {
+            this.isDataStoreInitBs.next(true);
+        }
+        if (!this.sessionConfig?.browserStorageImplementation) {
+            this.sessionConfig.browserStorageImplementation = 'session';
+        }
+        if (!this.sessionConfig?.sessionManagementImplementation) {
+            this.sessionConfig.sessionManagementImplementation = 'client';
+        }
+        if (this.isServerSessionManagement && !this.sessionConfig) {
+            throw new Error('Cannot user server session management with null sessionConfig please provide: GlobalInjectionTokens.sessionConfig');
+        }
+        if (this.isClientSessionManagement) {
+            this.initClientSessionManagement();
+            return;
+        }
+        this.initServerSessionManagement();
+    }
+    /**
+     * Redirects to a url with a ref to the existing session
+     * @param uri The uri to redirect to
+     * @param syncSession Sync session.
+     * @param configs Redirect configs.
+     */
+    redirect(uri, syncSession = false, configs = {}) {
+        // if the host name isn't in the uri, we are going to a different domain, so use the gateway on the other domain's server
+        let formAction = `${this.sessionConfig.transferBasePath}/ssogateway/v2/sso/inbound-transfer/${this.sessionConfig.keyPath}`;
+        if (uri.indexOf(window.location.hostname) === -1) {
+            const uriParts = uri.split('/');
+            // this results in ['https:', '', 'domain.host'], use 0 and 2 to get the base url of the redirect uri
+            formAction = `${uriParts[0]}//${uriParts[2]}/ssogateway/v2/sso/inbound-transfer/${this.sessionConfig.keyPath}`;
+        }
+        const form = document.createElement('form');
+        const input = document.createElement('input');
+        const inputDestination = document.createElement('input');
+        form.method = 'POST';
+        form.action = formAction;
+        if (configs.targetNewTab) {
+            // The parent session should already be present in child window as per browsing context rules, but for whatever reason form.target = '_blank' does not do that.
+            // Need to use window.open here so the parent window's session also gets carried over to the new tab.
+            // For reference: https://stackoverflow.com/questions/17297287/sessionstorage-on-new-window-isnt-empty-when-following-a-link-with-target-bl
+            form.target = 'customWindow';
+            window.open('', 'customWindow');
+        }
+        input.name = 'data';
+        input.value = this.window.sessionStorage.getItem(this.sessionConfig.keyPath);
+        inputDestination.name = 'destination';
+        inputDestination.value = uri;
+        form.appendChild(input);
+        form.appendChild(inputDestination);
+        document.body.appendChild(form);
+        form.submit();
+    }
+    /**
+     * Updates the session
+     * @param body The session put request body
+     */
+    updateSession(body, securableDelegate, skipDataStore) {
+        if (!this._sessionId) {
+            console.error('No session has been initialized, skipping update call');
+            return undefined;
+        }
+        if (!securableDelegate) {
+            throw new Error('SessionService:updateSession -> Argument is null or undefined, arg: securableDelegate');
+        }
+        if (Array.isArray(body.sessionData) && !Array.isArray(securableDelegate)) {
+            throw new Error('SessionService:updateSession -> Type miss match, arg: body.SessionData (type of Array) and arg: securableDelegate (type of (arg: any) => any) both must be array or non-array');
+        }
+        if (!Array.isArray(body.sessionData) && Array.isArray(securableDelegate)) {
+            throw new Error('SessionService:updateSession -> Type miss match, arg: body.SessionData (type of any) and arg: securableDelegate (type of Array)  both must be array or non-array');
+        }
+        // create response model and update observable to emit new session value
+        const model = {
+            initializingOrigin: body.initializingOrigin,
+            branding: body.branding,
+            oAuth: body.oAuth,
+            sessionId: this._sessionId,
+            tracking: body.tracking,
+            sessionData: body.sessionData
+        };
+        this.session = model;
+        const putModel = {
+            initializingOrigin: body.initializingOrigin,
+            sessionData: (Array.isArray(body.sessionData)
+                ? body.sessionData.map((d, index) => securableDelegate[index](d)) : securableDelegate(body.sessionData)),
+            branding: body.branding,
+            tracking: body.tracking,
+            oAuth: body.oAuth
+        };
+        // if data store is provided run the delegate to determine the body and the uri to use for the update
+        if (this.isDataStoreProvided && !skipDataStore) {
+            const updateTuple = this.sessionConfig?.dataStoreConfig.updateRequestDelegate(this.sessionConfig?.dataStoreConfig.baseUri, body.sessionData);
+            // switch map to cancel existing calls with newer ones to avoid reverting data
+            if (this.sessionConfig?.dataStoreConfig.shouldUpdateDataStoreDelegate(body.sessionData)) {
+                this.currentUpdateDataStoreCall.pipe(switchMap(() => {
+                    switch (this.sessionConfig?.dataStoreConfig.updateVerb) {
+                        case httpVerb.POST:
+                            return this.httpClient.post(updateTuple.uri, updateTuple.body);
+                        case httpVerb.PUT:
+                        default:
+                            return this.httpClient.put(updateTuple.uri, updateTuple.body);
+                    }
+                }))
+                    .subscribe(() => {
+                    this.isDataStoreRetrieveComplete = true;
+                    this.window.sessionStorage.setItem(dataStoreRetrieveCompleteSessionKey, 'true');
+                });
+            }
+        }
+        return this.session$;
+    }
+    /** Removes the session */
+    removeSession() {
+        this.sessionData.next(undefined);
+        this.window.sessionStorage.removeItem(dataStoreRetrieveCompleteSessionKey);
+        this.window.sessionStorage.removeItem(this.sessionConfig.keyPath);
+    }
+    /**
+     * @deprecated removing in the next version
+     * Syncs the session
+     * Returns the observable indicating when the session has been synced
+     */
+    syncSession() {
+        return of(true);
+    }
+    /**
+     * @deprecated removing in the next version
+     * Refreshes the session
+     */
+    refreshSession() {
+    }
+    /** Initialize server session management */
+    initServerSessionManagement() {
+        this.session$ = this.sessionData.asObservable();
+        const getFromDataStore = () => {
+            if (!this.sessionConfig?.dataStoreConfig || !this.authService || this.isDataStoreRetrieveComplete) {
+                return;
+            }
+            // load data from data store anon
+            const loadDataStore = () => this.determineDataStoreFunction(this.sessionConfig?.dataStoreConfig.retrieveVerb, this.sessionConfig?.dataStoreConfig.retrieveRequestDelegate, this.sessionConfig?.dataStoreConfig.baseUri, undefined)
+                .subscribe(res => {
+                this.isInitialized$.subscribe(isInit => {
+                    if (!isInit) {
+                        return;
+                    }
+                    this.session$.pipe(take(1))
+                        .subscribe(ses => {
+                        this.updateSession(this.sessionConfig?.dataStoreConfig.retrieveResponseDelegate(res, ses), this.sessionConfig?.dataStoreConfig.retrieveSecurableDelegate(res), true);
+                        this.isDataStoreInitBs.next(true);
+                        this.isDataStoreRetrieveComplete = true;
+                        this.window.sessionStorage.setItem(dataStoreRetrieveCompleteSessionKey, 'true');
+                    });
+                });
+            });
+            if (!this.authService.hasValidAccessToken()) {
+                // HACK: I couldn't do this based on an event so I had to get creative
+                const interval = setInterval(() => {
+                    if (this.authService.hasValidAccessToken()) {
+                        loadDataStore();
+                        clearInterval(interval);
+                    }
+                }, 250);
+            }
+            else {
+                return loadDataStore();
+            }
+        };
+        const body = {
+            sessionData: undefined,
+            branding: undefined
+        };
+        const encodedSession = this.window.sessionStorage.getItem(this.sessionConfig.keyPath);
+        this._sessionId = `Session-${newGuid()}`;
+        if (!encodedSession) {
+            this.session = body;
+            this.isInitializedBs.next(true);
+            getFromDataStore();
+        }
+        else {
+            this.session = this.decode(encodedSession);
+            this.isInitializedBs.next(true);
+            getFromDataStore();
+        }
+    }
+    /** Initializes the server side session id */
+    initServerSessionId() {
+        if (!this._sessionId) {
+            console.warn('Session Initializing, subscribe to session$ to get the session info. Session Id will be populated upon initialization');
+            return;
+        }
+    }
+    /** Initializes client side session management */
+    initClientSessionManagement() {
+        if (this.useBrowserSessionStorage) {
+            const sesId = this.window.sessionStorage.getItem(this.storageKey);
+            this._sessionId = sesId || newGuid();
+            this.setSessionStorage();
+        }
+        else if (this.useBrowserLocalStorage) {
+            const sesId = this.window.localStorage.getItem(this.storageKey);
+            this._sessionId = sesId || newGuid();
+            this.setLocalStorage();
+        }
+        this.isInitializedBs.next(true);
+    }
+    getSessionIdFromStorage() {
+        if (this.useBrowserLocalStorage) {
+            return this.window.localStorage.getItem(this.storageKey);
+        }
+        else if (this.useBrowserSessionStorage) {
+            return this.window.sessionStorage.getItem(this.storageKey);
+        }
+    }
+    /** Initialize the client side session id */
+    initClientSessionId() {
+        this._sessionId = newGuid();
+        if (this.useBrowserSessionStorage) {
+            this.setSessionStorage();
+        }
+        else if (this.useBrowserLocalStorage) {
+            this.setLocalStorage();
+        }
+    }
+    /** Sets session storage */
+    setSessionStorage() {
+        this.window.sessionStorage.setItem(this.storageKey, this._sessionId);
+    }
+    /** Sets local storage */
+    setLocalStorage() {
+        this.window.localStorage.setItem(this.storageKey, this._sessionId);
+    }
+    /**
+     * Determines the type of http call to make for the data store
+     * @param verb The verb
+     * @param delegate The delegate
+     * @param uri The uri
+     */
+    determineDataStoreFunction(verb, delegate, uri, body) {
+        const tuple = delegate(uri, body);
+        const headers = new HttpHeaders({
+            'Content-Type': 'application/json'
+        });
+        switch (verb) {
+            case httpVerb.PUT:
+                return this.httpClient.put(tuple.uri, tuple.body, { headers });
+            case httpVerb.POST:
+                return this.httpClient.post(tuple.uri, tuple.body, { headers });
+            case httpVerb.GET:
+                return this.httpClient.get(tuple.uri, { headers });
+            case httpVerb.PATCH:
+                return this.httpClient.patch(tuple.uri, tuple.body, { headers });
+            case httpVerb.DELETE:
+                return this.httpClient.delete(tuple.uri, { headers });
+            default:
+                throw new Error('Http verb must be one of: PATCH, PUT, POST, DELETE, GET');
+        }
+    }
+    /**
+     * Encodes the object
+     * @param value The object
+     */
+    encode(value) {
+        return window.btoa(unescape(encodeURIComponent(JSON.stringify(value))));
+    }
+    /**
+     * Decodes the string
+     * @param str The string
+     */
+    decode(str) {
+        return JSON.parse(decodeURIComponent(escape(window.atob(str))));
+    }
+}
+SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SessionService, deps: [{ token: SESSION_CONFIG, optional: true }, { token: WINDOW, optional: true }, { token: i1.OAuthService, optional: true }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i3.SessionConfig, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SESSION_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: i1.OAuthService, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HttpClient }]; } });
+/**
+ * Redirect Session Configs.
+ */
+export class RedirectSessionConfigs {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/core/services/session.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Inject, Injectable, Optional } from '@angular/core';\r\nimport { OAuthService } from 'angular-oauth2-oidc';\r\nimport { BehaviorSubject, Observable, of } from 'rxjs';\r\nimport { switchMap, take } from 'rxjs/operators';\r\nimport { SessionPostRequestModel, SessionPutRequestModel, SessionResponseModel } from '../client-generated/model/models';\r\nimport { SESSION_CONFIG, WINDOW } from '../models/constants';\r\nimport { HttpVerb, httpVerb } from '../models/http-verbs';\r\nimport { SessionConfig } from '../models/session-config';\r\nimport { TypedSession } from '../models/typed-session';\r\nimport { newGuid } from '../functions/guid';\r\n\r\n/** the data store retrieve complete session key */\r\nconst dataStoreRetrieveCompleteSessionKey = 'dataStoreRetrieve';\r\n\r\n/** The session service */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SessionService<T = any> {\r\n\r\n  /** The session id */\r\n  private _sessionId: string;\r\n\r\n  /** True when the data store retrieve is complete */\r\n  private isDataStoreRetrieveComplete: boolean = false;\r\n\r\n  /** The local storage key */\r\n  private readonly storageKey: string = 'Sof-Arm-Session-Id';\r\n\r\n  /** Teh current update data store call */\r\n  private readonly currentUpdateDataStoreCall: Observable<any> = of({});\r\n\r\n  /** The session data behavior subject */\r\n  private readonly sessionData: BehaviorSubject<TypedSession<T>> = new BehaviorSubject<TypedSession<T>>(undefined);\r\n\r\n  /** True when the service has finished initializing */\r\n  private readonly isInitializedBs: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  /** True if the data store is initialized */\r\n  private readonly isDataStoreInitBs: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\r\n\r\n  /** True if client side session management */\r\n  private get isClientSessionManagement(): boolean {\r\n    return this.sessionConfig.sessionManagementImplementation === 'client';\r\n  }\r\n\r\n  /** True if server side session management */\r\n  private get isServerSessionManagement(): boolean {\r\n    return this.sessionConfig.sessionManagementImplementation === 'server';\r\n  }\r\n\r\n  /** True if using browser local storage */\r\n  private get useBrowserLocalStorage(): boolean {\r\n    return this.sessionConfig.browserStorageImplementation === 'local';\r\n  }\r\n\r\n  /** True if using browser session storage */\r\n  private get useBrowserSessionStorage(): boolean {\r\n    return this.sessionConfig.browserStorageImplementation === 'session';\r\n  }\r\n\r\n  /** The window */\r\n  private readonly window: Window;\r\n\r\n  /** True if data store is provided */\r\n  private readonly isDataStoreProvided: boolean = false;\r\n\r\n  /** The session id */\r\n  public get sessionId(): string {\r\n    if (!this._sessionId) {\r\n      this.isClientSessionManagement ? this.initClientSessionId() : this.initServerSessionId();\r\n    }\r\n\r\n    return this._sessionId;\r\n  }\r\n\r\n  /** The session */\r\n  public session$: Observable<TypedSession<T>>;\r\n\r\n  /** The session refresh observable */\r\n  public sessionRefresh$: Observable<any>;\r\n\r\n  /** Indicates when the service has finished initializing */\r\n  public isInitialized$: Observable<boolean>;\r\n\r\n  /** True if the data store is initialized */\r\n  public isDataStoreInit$: Observable<boolean>;\r\n\r\n  /** gets the session */\r\n  public get session(): TypedSession<T> {\r\n    return this.sessionData.value;\r\n  }\r\n\r\n  /** sets the session */\r\n  public set session(value: TypedSession<T>) {\r\n    this.sessionData.next(value);\r\n    this.window.sessionStorage.setItem(this.sessionConfig.keyPath, this.encode(value));\r\n  }\r\n\r\n  /**\r\n   * Constructs the service\r\n   * @param sessionConfig The session configurations\r\n   * @param _window The window interface\r\n   * @param authService The OAuth odic 2 service\r\n   * @param httpClient The http client\r\n   */\r\n  constructor(\r\n    @Optional() @Inject(SESSION_CONFIG) readonly sessionConfig: SessionConfig,\r\n    @Optional() @Inject(WINDOW) readonly _window: any,\r\n    @Optional() private readonly authService: OAuthService,\r\n    private readonly httpClient: HttpClient\r\n  ) {\r\n    this.isInitialized$ = this.isInitializedBs.asObservable();\r\n    this.isDataStoreInit$ = this.isDataStoreInitBs.asObservable();\r\n    if (!this.sessionConfig) {\r\n      this.sessionConfig = new SessionConfig();\r\n    }\r\n    this.isDataStoreProvided = !!this.sessionConfig?.dataStoreConfig;\r\n    this.window = _window;\r\n    if (!this.window) {\r\n      this.window = window;\r\n    }\r\n    const dataStoreLoadedValue = this.window.sessionStorage.getItem(dataStoreRetrieveCompleteSessionKey);\r\n    this.isDataStoreRetrieveComplete = !!dataStoreLoadedValue ? dataStoreLoadedValue.toLowerCase() === 'true' : false;\r\n    // if not using a data store, update the initialized to true for it\r\n    if (!this.isDataStoreProvided) {\r\n      this.isDataStoreInitBs.next(true);\r\n    }\r\n    if (!this.sessionConfig?.browserStorageImplementation) {\r\n      this.sessionConfig.browserStorageImplementation = 'session';\r\n    }\r\n    if (!this.sessionConfig?.sessionManagementImplementation) {\r\n      this.sessionConfig.sessionManagementImplementation = 'client';\r\n    }\r\n    if (this.isServerSessionManagement && !this.sessionConfig) {\r\n      throw new Error('Cannot user server session management with null sessionConfig please provide: GlobalInjectionTokens.sessionConfig');\r\n    }\r\n    if (this.isClientSessionManagement) {\r\n      this.initClientSessionManagement();\r\n\r\n      return;\r\n    }\r\n\r\n    this.initServerSessionManagement();\r\n  }\r\n\r\n  /**\r\n   * Redirects to a url with a ref to the existing session\r\n   * @param uri The uri to redirect to\r\n   * @param syncSession Sync session.\r\n   * @param configs Redirect configs.\r\n   */\r\n  public redirect(uri: string, syncSession: boolean = false, configs: RedirectSessionConfigs = {}): void {\r\n    // if the host name isn't in the uri, we are going to a different domain, so use the gateway on the other domain's server\r\n    let formAction = `${this.sessionConfig.transferBasePath}/ssogateway/v2/sso/inbound-transfer/${this.sessionConfig.keyPath}`;\r\n    if (uri.indexOf(window.location.hostname) === -1) {\r\n      const uriParts = uri.split('/');\r\n      // this results in ['https:', '', 'domain.host'], use 0 and 2 to get the base url of the redirect uri\r\n      formAction = `${uriParts[0]}//${uriParts[2]}/ssogateway/v2/sso/inbound-transfer/${this.sessionConfig.keyPath}`;\r\n    }\r\n    const form = document.createElement('form');\r\n    const input = document.createElement('input');\r\n    const inputDestination = document.createElement('input');\r\n    form.method = 'POST';\r\n    form.action = formAction;\r\n    if (configs.targetNewTab) {\r\n      // The parent session should already be present in child window as per browsing context rules, but for whatever reason form.target = '_blank' does not do that.\r\n      // Need to use window.open here so the parent window's session also gets carried over to the new tab.\r\n      // For reference: https://stackoverflow.com/questions/17297287/sessionstorage-on-new-window-isnt-empty-when-following-a-link-with-target-bl\r\n      form.target = 'customWindow';\r\n      window.open('', 'customWindow');\r\n    }\r\n\r\n    input.name = 'data';\r\n    input.value = this.window.sessionStorage.getItem(this.sessionConfig.keyPath);\r\n    inputDestination.name = 'destination';\r\n    inputDestination.value = uri;\r\n    form.appendChild(input);\r\n    form.appendChild(inputDestination);\r\n    document.body.appendChild(form);\r\n    form.submit();\r\n  }\r\n\r\n  /**\r\n   * Updates the session\r\n   * @param body The session put request body\r\n   */\r\n  public updateSession(\r\n    body: TypedSession<T>,\r\n    securableDelegate: Array<(arg: any) => any> | ((arg: any) => any),\r\n    skipDataStore?: boolean): Observable<any> {\r\n    if (!this._sessionId) {\r\n      console.error('No session has been initialized, skipping update call');\r\n\r\n      return undefined;\r\n    }\r\n    if (!securableDelegate) {\r\n      throw new Error('SessionService:updateSession -> Argument is null or undefined, arg: securableDelegate');\r\n    }\r\n    if (Array.isArray(body.sessionData) && !Array.isArray(securableDelegate)) {\r\n      throw new Error(\r\n        'SessionService:updateSession -> Type miss match, arg: body.SessionData (type of Array) and arg: securableDelegate (type of (arg: any) => any) both must be array or non-array'\r\n      );\r\n    }\r\n    if (!Array.isArray(body.sessionData) && Array.isArray(securableDelegate)) {\r\n      throw new Error(\r\n        'SessionService:updateSession -> Type miss match, arg: body.SessionData (type of any) and arg: securableDelegate (type of Array)  both must be array or non-array'\r\n      );\r\n    }\r\n    // create response model and update observable to emit new session value\r\n    const model: SessionResponseModel = {\r\n      initializingOrigin: body.initializingOrigin,\r\n      branding: body.branding,\r\n      oAuth: body.oAuth,\r\n      sessionId: this._sessionId,\r\n      tracking: body.tracking,\r\n      sessionData: body.sessionData\r\n    };\r\n    this.session = model;\r\n\r\n    const putModel: SessionPutRequestModel = {\r\n      initializingOrigin: body.initializingOrigin,\r\n      sessionData:\r\n        (Array.isArray(body.sessionData)\r\n          ? body.sessionData.map((d, index) => securableDelegate[index](d)) : (securableDelegate as ((arg: any) => any))(body.sessionData)),\r\n      branding: body.branding,\r\n      tracking: body.tracking,\r\n      oAuth: body.oAuth\r\n    };\r\n\r\n    // if data store is provided run the delegate to determine the body and the uri to use for the update\r\n    if (this.isDataStoreProvided && !skipDataStore) {\r\n      const updateTuple =\r\n        this.sessionConfig?.dataStoreConfig.updateRequestDelegate(this.sessionConfig?.dataStoreConfig.baseUri, body.sessionData);\r\n      // switch map to cancel existing calls with newer ones to avoid reverting data\r\n      if (this.sessionConfig?.dataStoreConfig.shouldUpdateDataStoreDelegate(body.sessionData)) {\r\n        this.currentUpdateDataStoreCall.pipe(switchMap(() => {\r\n          switch (this.sessionConfig?.dataStoreConfig.updateVerb) {\r\n            case httpVerb.POST:\r\n              return this.httpClient.post(updateTuple.uri, updateTuple.body);\r\n            case httpVerb.PUT:\r\n            default:\r\n              return this.httpClient.put(updateTuple.uri, updateTuple.body);\r\n          }\r\n        }))\r\n          .subscribe(() => {\r\n            this.isDataStoreRetrieveComplete = true;\r\n            this.window.sessionStorage.setItem(dataStoreRetrieveCompleteSessionKey, 'true');\r\n          });\r\n      }\r\n    }\r\n\r\n    return this.session$;\r\n  }\r\n\r\n  /** Removes the session */\r\n  public removeSession(): void {\r\n    this.sessionData.next(undefined);\r\n    this.window.sessionStorage.removeItem(dataStoreRetrieveCompleteSessionKey);\r\n    this.window.sessionStorage.removeItem(this.sessionConfig.keyPath);\r\n  }\r\n\r\n  /**\r\n   * @deprecated removing in the next version\r\n   * Syncs the session\r\n   * Returns the observable indicating when the session has been synced\r\n   */\r\n  public syncSession(): Observable<any> {\r\n    return of(true);\r\n  }\r\n\r\n  /**\r\n   * @deprecated removing in the next version\r\n   * Refreshes the session\r\n   */\r\n  public refreshSession(): void {\r\n  }\r\n\r\n  /** Initialize server session management */\r\n  private initServerSessionManagement(): void {\r\n    this.session$ = this.sessionData.asObservable();\r\n\r\n    const getFromDataStore = (): any => {\r\n      if (!this.sessionConfig?.dataStoreConfig || !this.authService || this.isDataStoreRetrieveComplete) {\r\n        return;\r\n      }\r\n\r\n      // load data from data store anon\r\n      const loadDataStore = () =>\r\n        this.determineDataStoreFunction(this.sessionConfig?.dataStoreConfig.retrieveVerb,\r\n          this.sessionConfig?.dataStoreConfig.retrieveRequestDelegate,\r\n          this.sessionConfig?.dataStoreConfig.baseUri,\r\n          undefined)\r\n          .subscribe(res => {\r\n            this.isInitialized$.subscribe(isInit => {\r\n              if (!isInit) {\r\n                return;\r\n              }\r\n              this.session$.pipe(take(1))\r\n                .subscribe(ses => {\r\n                  this.updateSession(this.sessionConfig?.dataStoreConfig.retrieveResponseDelegate(res, ses),\r\n                    this.sessionConfig?.dataStoreConfig.retrieveSecurableDelegate(res), true);\r\n                  this.isDataStoreInitBs.next(true);\r\n                  this.isDataStoreRetrieveComplete = true;\r\n                  this.window.sessionStorage.setItem(dataStoreRetrieveCompleteSessionKey, 'true');\r\n                });\r\n            });\r\n          });\r\n\r\n      if (!this.authService.hasValidAccessToken()) {\r\n        // HACK: I couldn't do this based on an event so I had to get creative\r\n        const interval = setInterval(() => {\r\n          if (this.authService.hasValidAccessToken()) {\r\n            loadDataStore();\r\n            clearInterval(interval);\r\n          }\r\n        }, 250);\r\n      }\r\n      else {\r\n        return loadDataStore();\r\n      }\r\n    };\r\n\r\n    const body: SessionPostRequestModel = {\r\n      sessionData: undefined,\r\n      branding: undefined\r\n    };\r\n\r\n    const encodedSession = this.window.sessionStorage.getItem(this.sessionConfig.keyPath);\r\n    this._sessionId = `Session-${newGuid()}`;\r\n    if (!encodedSession) {\r\n      this.session = body;\r\n      this.isInitializedBs.next(true);\r\n      getFromDataStore();\r\n    }\r\n    else {\r\n      this.session = this.decode(encodedSession);\r\n      this.isInitializedBs.next(true);\r\n      getFromDataStore();\r\n    }\r\n  }\r\n\r\n  /** Initializes the server side session id */\r\n  private initServerSessionId(): void {\r\n    if (!this._sessionId) {\r\n      console.warn('Session Initializing, subscribe to session$ to get the session info. Session Id will be populated upon initialization');\r\n\r\n      return;\r\n    }\r\n  }\r\n\r\n  /** Initializes client side session management */\r\n  private initClientSessionManagement(): void {\r\n    if (this.useBrowserSessionStorage) {\r\n      const sesId = this.window.sessionStorage.getItem(this.storageKey);\r\n      this._sessionId = sesId || newGuid();\r\n      this.setSessionStorage();\r\n    }\r\n    else if (this.useBrowserLocalStorage) {\r\n      const sesId = this.window.localStorage.getItem(this.storageKey);\r\n      this._sessionId = sesId || newGuid();\r\n      this.setLocalStorage();\r\n    }\r\n    this.isInitializedBs.next(true);\r\n  }\r\n\r\n  private getSessionIdFromStorage(): string {\r\n    if (this.useBrowserLocalStorage) {\r\n      return this.window.localStorage.getItem(this.storageKey);\r\n    }\r\n    else if (this.useBrowserSessionStorage) {\r\n      return this.window.sessionStorage.getItem(this.storageKey);\r\n    }\r\n  }\r\n\r\n  /** Initialize the client side session id */\r\n  private initClientSessionId(): void {\r\n    this._sessionId = newGuid();\r\n    if (this.useBrowserSessionStorage) {\r\n      this.setSessionStorage();\r\n    }\r\n    else if (this.useBrowserLocalStorage) {\r\n      this.setLocalStorage();\r\n    }\r\n  }\r\n\r\n  /** Sets session storage */\r\n  private setSessionStorage(): void {\r\n    this.window.sessionStorage.setItem(this.storageKey, this._sessionId);\r\n  }\r\n\r\n  /** Sets local storage */\r\n  private setLocalStorage(): void {\r\n    this.window.localStorage.setItem(this.storageKey, this._sessionId);\r\n  }\r\n\r\n  /**\r\n   * Determines the type of http call to make for the data store\r\n   * @param verb The verb\r\n   * @param delegate The delegate\r\n   * @param uri The uri\r\n   */\r\n  private determineDataStoreFunction(\r\n    verb: HttpVerb,\r\n    delegate: (baseUri: string, body: T) => { uri: string, body?: any },\r\n    uri: string,\r\n    body: any\r\n  ): Observable<any> {\r\n    const tuple = delegate(uri, body);\r\n    const headers = new HttpHeaders({\r\n      'Content-Type': 'application/json'\r\n    });\r\n    switch (verb) {\r\n      case httpVerb.PUT:\r\n        return this.httpClient.put(tuple.uri, tuple.body, { headers });\r\n      case httpVerb.POST:\r\n        return this.httpClient.post(tuple.uri, tuple.body, { headers });\r\n      case httpVerb.GET:\r\n        return this.httpClient.get(tuple.uri, { headers });\r\n      case httpVerb.PATCH:\r\n        return this.httpClient.patch(tuple.uri, tuple.body, { headers });\r\n      case httpVerb.DELETE:\r\n        return this.httpClient.delete(tuple.uri, { headers });\r\n      default:\r\n        throw new Error('Http verb must be one of: PATCH, PUT, POST, DELETE, GET');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Encodes the object\r\n   * @param value The object\r\n   */\r\n  private encode(value: any): string {\r\n    return window.btoa(unescape(encodeURIComponent(JSON.stringify(value))));\r\n  }\r\n\r\n  /**\r\n   * Decodes the string\r\n   * @param str The string\r\n   */\r\n  private decode(str: string): any {\r\n    return JSON.parse(decodeURIComponent(escape(window.atob(str))));\r\n  }\r\n}\r\n\r\n/**\r\n * Redirect Session Configs.\r\n */\r\nexport class RedirectSessionConfigs {\r\n  /** If session should be synced. */\r\n  syncSession?: boolean;\r\n\r\n  /** If new tab should be targeted. */\r\n  targetNewTab?: boolean;\r\n}"]}