@openmfp/portal-ui-lib 0.0.0 → 0.182.2

package/fesm2022/openmfp-portal-ui-lib.mjs

@@ -0,0 +1,2716 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, Optional, Inject, provideAppInitializer, signal, ChangeDetectionStrategy, Component, ViewEncapsulation, provideZoneChangeDetection, makeEnvironmentProviders } from '@angular/core';
+import * as i1$1 from '@angular/common/http';
+import { HttpHeaders, HttpErrorResponse, HttpClient, provideHttpClient } from '@angular/common/http';
+import { firstValueFrom, Subject, lastValueFrom, tap, filter } from 'rxjs';
+import * as i1 from '@angular/router';
+import { NavigationEnd, NavigationStart, RouterOutlet, provideRouter, RouteReuseStrategy } from '@angular/router';
+import { jwtDecode } from 'jwt-decode';
+import { isEqual, isMatch } from 'lodash';
+import oAuth2 from '@luigi-project/plugin-auth-oauth2';
+import { filter as filter$1 } from 'rxjs/operators';
+import { search } from 'jmespath';
+import { $localize } from '@angular/localize/init';
+
+const luigi = globalThis.Luigi;
+class LuigiCoreService {
+    setConfig(config) {
+        return luigi.setConfig(config);
+    }
+    get config() {
+        return luigi.getConfig();
+    }
+    getConfigValue(key) {
+        return luigi.getConfigValue(key);
+    }
+    unloadConfig() {
+        return luigi.unload();
+    }
+    sendCustomMessage(customMessage) {
+        return luigi.sendCustomMessage(customMessage);
+    }
+    configChanged(scope) {
+        luigi.configChanged(scope);
+    }
+    customMessages() {
+        return luigi.customMessages();
+    }
+    navigation() {
+        return luigi.navigation();
+    }
+    resetLuigi() {
+        luigi.reset();
+    }
+    clearNavigationCache() {
+        if (luigi.clearNavigationCache) {
+            luigi.clearNavigationCache();
+        }
+    }
+    showAlert(alert) {
+        return luigi.showAlert(alert);
+    }
+    ux() {
+        return luigi.ux();
+    }
+    theming() {
+        return luigi.theming();
+    }
+    i18n() {
+        return luigi.i18n();
+    }
+    globalSearch() {
+        return luigi.globalSearch();
+    }
+    getGlobalContext() {
+        return luigi.getGlobalContext();
+    }
+    getWcExtendedContext() {
+        return document
+            .querySelector('.wcContainer')
+            ?.querySelector('[lui_web_component]')?.extendedContext?.context;
+    }
+    getWcModalExtendedContext() {
+        return document
+            .querySelector('.iframeModalCtn')
+            ?.querySelector('[lui_web_component]')?.extendedContext?.context;
+    }
+    setGlobalContext(globalContext, preventUpdate = false) {
+        luigi.setGlobalContext(globalContext, preventUpdate);
+    }
+    setInGlobalContext(context, preventUpdate = false) {
+        luigi.setGlobalContext({ ...this.getGlobalContext(), ...context }, preventUpdate);
+    }
+    routing() {
+        return luigi.routing();
+    }
+    setFeatureToggle(featureToggleName) {
+        luigi.featureToggles().setFeatureToggle(featureToggleName);
+    }
+    unsetFeatureToggle(featureToggleName) {
+        luigi.featureToggles().unsetFeatureToggle(featureToggleName);
+    }
+    unsetAllFeatureToggles() {
+        luigi
+            .featureToggles()
+            .getActiveFeatureToggleList()
+            .forEach((ft) => {
+            this.unsetFeatureToggle(ft);
+        });
+    }
+    setFeatureToggles(featureToggles) {
+        if (!featureToggles) {
+            return;
+        }
+        for (const featureToggleName of Object.keys(featureToggles)) {
+            if (featureToggles[featureToggleName]) {
+                this.setFeatureToggle(featureToggleName);
+            }
+        }
+    }
+    isFeatureToggleActive(ft) {
+        return luigi.featureToggles().getActiveFeatureToggleList().includes(ft);
+    }
+    getActiveFeatureToggleList() {
+        return luigi.featureToggles().getActiveFeatureToggleList();
+    }
+    setAuthData(authData) {
+        luigi.auth().store.setAuthData(authData);
+        luigi.auth().store.setNewlyAuthorized();
+    }
+    removeAuthData() {
+        luigi.auth().store.removeAuthData();
+    }
+    getAuthData() {
+        return luigi.auth().store.getAuthData();
+    }
+    setCurrentLocale(language) {
+        luigi.i18n().setCurrentLocale(language);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiCoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiCoreService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiCoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var AuthEvent;
+(function (AuthEvent) {
+    AuthEvent["AUTH_SUCCESSFUL"] = "AuthSuccessful";
+    AuthEvent["AUTH_ERROR"] = "AuthError";
+    AuthEvent["AUTH_EXPIRED"] = "AuthExpired";
+    AuthEvent["AUTH_REFRESHED"] = "AuthRefreshed";
+    AuthEvent["AUTH_EXPIRE_SOON"] = "AuthExpireSoon";
+    AuthEvent["AUTH_CONFIG_ERROR"] = "AuthConfigError";
+    AuthEvent["LOGOUT"] = "Logout";
+})(AuthEvent || (AuthEvent = {}));
+
+var EntityType;
+(function (EntityType) {
+    EntityType["GLOBAL"] = "global";
+    EntityType["GLOBAL_TOPNAV"] = "global.topnav";
+    EntityType["ENTITY_ERROR"] = "entity.error";
+})(EntityType || (EntityType = {}));
+
+var NetworkVisibility;
+(function (NetworkVisibility) {
+    NetworkVisibility["INTERNAL"] = "internal";
+    NetworkVisibility["INTERNET"] = "internet";
+})(NetworkVisibility || (NetworkVisibility = {}));
+
+class RequestHeadersService {
+    constructor(luigiCoreService, route) {
+        this.luigiCoreService = luigiCoreService;
+        this.route = route;
+    }
+    createOptionsWithAuthHeader() {
+        let language = this.luigiCoreService.i18n().getCurrentLocale();
+        const authData = this.luigiCoreService.getAuthData();
+        this.route.queryParams.subscribe((params) => {
+            if (params['language']) {
+                language = params['language'];
+            }
+        });
+        if (!authData?.idToken) {
+            throw new Error('Unable to create authorization header, no id token present.');
+        }
+        return {
+            headers: new HttpHeaders({
+                authorization: 'Bearer ' + authData.idToken,
+                'Accept-Language': language || '',
+            }),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RequestHeadersService, deps: [{ token: LuigiCoreService }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RequestHeadersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RequestHeadersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: LuigiCoreService }, { type: i1.ActivatedRoute }] });
+
+class ConfigService {
+    constructor(http, requestHeadersService) {
+        this.http = http;
+        this.requestHeadersService = requestHeadersService;
+        this.entityConfigCache = {};
+    }
+    async getPortalConfig() {
+        if (this.portalConfigCachePromise) {
+            return this.portalConfigCachePromise;
+        }
+        const options = this.requestHeadersService.createOptionsWithAuthHeader();
+        this.portalConfigCachePromise = firstValueFrom(this.http.get('/rest/config', options)).catch((e) => {
+            if (e instanceof HttpErrorResponse && e.status === 403) {
+                window.location.assign('/logout?error=invalidToken');
+            }
+            throw e;
+        });
+        return this.portalConfigCachePromise;
+    }
+    async reloadConfig(entity, context) {
+        if (!entity) {
+            this.portalConfigCachePromise = undefined;
+            await this.getPortalConfig();
+        }
+        else {
+            const entityCacheKey = JSON.stringify(context);
+            delete this.entityConfigCache[entity][entityCacheKey];
+            await this.getEntityConfig(entity, context);
+        }
+    }
+    async getEntityConfig(entity, context) {
+        if (!this.entityConfigCache[entity]) {
+            this.entityConfigCache[entity] = {};
+        }
+        const entityCacheKey = JSON.stringify(context);
+        if (this.entityConfigCache[entity][entityCacheKey]) {
+            return this.entityConfigCache[entity][entityCacheKey];
+        }
+        const options = this.requestHeadersService.createOptionsWithAuthHeader();
+        const entityConfig = firstValueFrom(this.http.get(`/rest/config/${entity}`, {
+            ...options,
+            ...{ params: context },
+        }));
+        this.entityConfigCache[entity][entityCacheKey] = entityConfig;
+        return entityConfig;
+    }
+    clearEntityConfigCache() {
+        this.entityConfigCache = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConfigService, deps: [{ token: i1$1.HttpClient }, { token: RequestHeadersService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: RequestHeadersService }] });
+
+class AuthService {
+    constructor(http) {
+        this.http = http;
+        this.authEventSubject = new Subject();
+        this.parseJwt = (token) => {
+            try {
+                return jwtDecode(token);
+            }
+            catch (Error) {
+                return null;
+            }
+        };
+        this.getToken = () => {
+            const auth = this.getAuthData();
+            if (auth) {
+                return auth.idToken;
+            }
+            return {};
+        };
+    }
+    get authEvents() {
+        return this.authEventSubject.asObservable();
+    }
+    authEvent(event) {
+        this.authEventSubject.next(event);
+    }
+    async refresh() {
+        const response = await lastValueFrom(this.http.post('/rest/auth/refresh', {}));
+        this.setAuthData(response);
+        return response;
+    }
+    setAuthData(authTokenData) {
+        if (!authTokenData) {
+            return;
+        }
+        this.authData = {
+            accessTokenExpirationDate: this.processExpDate(authTokenData.expires_in),
+            idToken: authTokenData.id_token,
+        };
+    }
+    getAuthData() {
+        return this.authData;
+    }
+    getUser() {
+        const auth = this.getAuthData();
+        if (auth) {
+            return this.parseJwt(auth.idToken);
+        }
+        return {};
+    }
+    getUserInfo() {
+        const user = this.getUser() || {};
+        const firstName = user.first_name || user.given_name || '';
+        const lastName = user.last_name || user.family_name || '';
+        const initialsFirstName = firstName[0] || '';
+        const initialsLastName = lastName[0] || '';
+        return {
+            name: `${firstName} ${lastName}`,
+            email: user.mail || user.email || '',
+            description: user.mail || user.email || '',
+            picture: '',
+            icon: false,
+            initials: initialsFirstName + initialsLastName,
+            userId: user.sub || '',
+        };
+    }
+    processExpDate(expiresInSeconds) {
+        const expiresIn = Number(expiresInSeconds);
+        return new Date().getTime() + expiresIn * 1000;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthService, deps: [{ token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }] });
+
+class EnvConfigService {
+    constructor() {
+        this.http = inject(HttpClient);
+    }
+    async getEnvConfig() {
+        if (this.envConfigCache) {
+            return this.envConfigCache;
+        }
+        await lastValueFrom(this.http
+            .get('/rest/envconfig')
+            .pipe(tap((result) => (this.envConfigCache = result))));
+        return this.envConfigCache;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: EnvConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: EnvConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: EnvConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LocalNodesService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.luigiCoreService = inject(LuigiCoreService);
+    }
+    async getLuigiNodesFromConfigurations(contentConfigurations) {
+        if (contentConfigurations.length === 0) {
+            return null;
+        }
+        const language = this.luigiCoreService.i18n().getCurrentLocale();
+        return await lastValueFrom(this.http.post(`/rest/localnodes`, {
+            language,
+            contentConfigurations,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalNodesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalNodesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalNodesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const ERROR_COMPONENT_CONFIG = 'OPENMFP_ERROR_COMPONENT_CONFIG';
+const THEMING_SERVICE = 'OPENMFP_THEMING_SERVICE';
+const LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_STATIC_SETTINGS_CONFIG_SERVICE';
+const LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN = 'OPENMFP_LUIGI_CUSTOM_MESSAGE_LISTENERS';
+const LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE';
+const LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_APP_SWITCHER_CONFIG_SERVICE';
+const LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_USER_PROFILE_CONFIG_SERVICE';
+const LUIGI_BREADCRUMB_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_BREADCRUMB_CONFIG_SERVICE';
+const LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_NODE_CHANGE_HOOK_CONFIG_SERVICE';
+const LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_NODES_EXTENDED_CONTEXT_SERVICE';
+const LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN = 'OPENMFP_LOCAL_CONFIGURATION_SERVICE';
+const LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_NODES_CUSTOM_GLOBAL_SERVICE';
+const LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_CUSTOM_NODE_PROCESSING_SERVICE';
+const LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE';
+const LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE';
+const HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_HEADER_BAR_CONFIG_SERVICE';
+const LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN = 'OPENMFP_LUIGI_ROUTING_CONFIG_SERVICE';
+
+class GlobalContextConfigService {
+    constructor() {
+        this.authService = inject(AuthService);
+        this.configService = inject(ConfigService);
+        this.luigiExtendedGlobalContextConfigService = inject(LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    async getGlobalContext() {
+        const portalConfig = await this.configService.getPortalConfig();
+        const userInfo = this.authService.getUserInfo();
+        return {
+            ...(await this.luigiExtendedGlobalContextConfigService?.createLuigiExtendedGlobalContext()),
+            portalBaseUrl: window.location.origin,
+            portalContext: portalConfig.portalContext,
+            userId: userInfo.userId,
+            userEmail: userInfo.email,
+            token: this.authService.getToken(),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: GlobalContextConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: GlobalContextConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: GlobalContextConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class SessionRefreshService {
+    constructor(authService, luigiCoreService, navigationGlobalContextConfigService) {
+        this.authService = authService;
+        this.luigiCoreService = luigiCoreService;
+        this.navigationGlobalContextConfigService = navigationGlobalContextConfigService;
+    }
+    async refresh() {
+        const isRefreshed = await this.authService.refresh();
+        if (!isRefreshed) {
+            return;
+        }
+        this.authService.authEvent(AuthEvent.AUTH_REFRESHED);
+        this.luigiCoreService.setAuthData(this.authService.getAuthData());
+        this.luigiCoreService.setGlobalContext(await this.navigationGlobalContextConfigService.getGlobalContext(), true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: SessionRefreshService, deps: [{ token: AuthService }, { token: LuigiCoreService }, { token: GlobalContextConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: SessionRefreshService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: SessionRefreshService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: AuthService }, { type: LuigiCoreService }, { type: GlobalContextConfigService }] });
+
+class I18nService {
+    constructor() {
+        this.envConfigService = inject(EnvConfigService);
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.fallbackLanguage = 'en';
+        this.translationTable = {};
+        this.currentLanguage = '';
+    }
+    afterInit() {
+        this.currentLanguage = this.luigiCoreService.i18n().getCurrentLocale();
+        this.luigiCoreService
+            .i18n()
+            .addCurrentLocaleChangeListener((locale) => {
+            this.currentLanguage = locale;
+        });
+    }
+    /**
+     * get translation synchronously. If nothing is found for current locale try to get tranlsation for fallback language
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns returns translated search key or search key, if nothing matched
+     */
+    getTranslation(key, interpolations, locale) {
+        let result = this.getInternalTranslation(key, interpolations, locale);
+        // fallback language
+        if (!result) {
+            result = this.findTranslation(key, this.translationTable, this.fallbackLanguage, interpolations);
+        }
+        return result ? result : key;
+    }
+    /**
+     * Get translation asynchronously (especially for logout and theming translation in user settings dialog).
+     * If nothing is found for current locale try to get translation for fallback language
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns returns translated search key or search key, if nothing matched
+     */
+    async getTranslationAsync(key, interpolations, locale) {
+        return new Promise((res) => {
+            let result = this.getInternalTranslation(key, interpolations, locale);
+            // fallback language
+            if (!result) {
+                if (this.translationTable &&
+                    !this.translationTable[this.fallbackLanguage]) {
+                    this.fetchTranslationFile(this.fallbackLanguage).then(() => {
+                        result = this.findTranslation(key, this.translationTable, this.fallbackLanguage, interpolations);
+                        res(result ? result : key);
+                    });
+                }
+                else {
+                    result = this.findTranslation(key, this.translationTable, this.fallbackLanguage, interpolations);
+                    res(result ? result : key);
+                }
+            }
+            else {
+                res(result ? result : key);
+            }
+        });
+    }
+    /**
+     * Finds the translated value based on given key.
+     *
+     * @param key key to be translated
+     * @param translationTable translation table
+     * @param locale current language
+     * @param interpolations in translation table
+     * @returns translation value
+     */
+    findTranslation(key, translationTable, locale, interpolations) {
+        if (translationTable[locale]) {
+            const translation = typeof translationTable[locale][key] === 'object'
+                ? translationTable[locale][key].join('<br>')
+                : translationTable[locale][key];
+            if (interpolations) {
+                return this.findInterpolations(translation, interpolations);
+            }
+            return translation;
+        }
+    }
+    /**
+     * Replaces values that are defined in translation strings
+     *
+     * @param value to be translated
+     * @param interpolations in translation table
+     * @returns interpolation
+     * @example
+     * findInterpolations('Environment {num}', {num: 1})
+     */
+    findInterpolations(value, interpolations) {
+        if (value) {
+            Object.keys(interpolations).forEach((item) => {
+                value = value.replace(new RegExp('{' + item + '}', 'gi'), interpolations[item]);
+            });
+            return value;
+        }
+        return undefined;
+    }
+    /**
+     * wraps fetched translation table to a specific locale
+     *
+     * @param locale current language
+     * @param data translation json object for specific locale
+     */
+    addTranslationFile(locale, data) {
+        if (data && locale) {
+            this.translationTable[locale] = data;
+        }
+    }
+    /**
+     * fetch generated translation json files
+     *
+     * @param locale current language
+     * @returns translationTable for a specific language
+     */
+    async fetchTranslationFile(locale) {
+        return new Promise((res) => {
+            fetch(`/assets/translation-files/${locale}.json`)
+                .then((response) => {
+                return response.json();
+            })
+                .then((data) => {
+                this.addTranslationFile(locale, data);
+                res(true);
+            })
+                .catch((error) => {
+                console.error('Error:', error);
+                this.addTranslationFile(locale, {});
+                res(false);
+            });
+        });
+    }
+    /**
+     *
+     * @param key search key
+     * @param interpolations in translation table
+     * @param locale
+     * @returns tranlsated search key or search key, if nothing matched
+     */
+    getInternalTranslation(key, interpolations, locale) {
+        if (!key)
+            return '';
+        this.currentLanguage =
+            locale ||
+                this.currentLanguage ||
+                this.luigiCoreService.i18n().getCurrentLocale();
+        return this.findTranslation(key, this.translationTable, this.currentLanguage, interpolations);
+    }
+    async getValidLanguages() {
+        const languages = [
+            { value: 'en', label: 'USERSETTINGSDIALOG_LANGUAGE_EN' },
+        ];
+        try {
+            const { developmentInstance } = await this.envConfigService.getEnvConfig();
+            if (developmentInstance) {
+                languages.push({
+                    value: 'de',
+                    label: 'USERSETTINGSDIALOG_LANGUAGE_DE',
+                });
+            }
+        }
+        finally {
+            return languages;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: I18nService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: I18nService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var LoginEventType;
+(function (LoginEventType) {
+    LoginEventType["LOGIN_TRIGGERED"] = "LoginTriggered";
+    LoginEventType["LOGOUT_TRIGGERED"] = "LogoutTriggered";
+})(LoginEventType || (LoginEventType = {}));
+class LoginEventService {
+    constructor() {
+        this.events = new Subject();
+    }
+    get loginEvents() {
+        return this.events.asObservable();
+    }
+    loginEvent(event) {
+        this.events.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LoginEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LoginEventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LoginEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var LocalStorageKeys;
+(function (LocalStorageKeys) {
+    LocalStorageKeys["LAST_NAVIGATION_URL"] = "openmfp.navigation.lastUrl";
+    LocalStorageKeys["USER_SETTINGS"] = "openmfp.settings.userSettings";
+    LocalStorageKeys["LOCAL_DEVELOPMENT_SETTINGS"] = "openmfp.settings.localDevelopmentSettings";
+    LocalStorageKeys["FEATURE_TOGGLE_SETTINGS"] = "openmfp.settings.featureToggleSettings";
+    // deprecated to be removed
+    LocalStorageKeys["DEVELOPMENT_MODE_CONFIG"] = "dev-mode-settings";
+})(LocalStorageKeys || (LocalStorageKeys = {}));
+const localDevelopmentSettingsLocalStorage = {
+    read: (localStorageKey) => {
+        let localDevelopmentSettingsFromLocalStore;
+        try {
+            localDevelopmentSettingsFromLocalStore = localStorage.getItem(localStorageKey || LocalStorageKeys.LOCAL_DEVELOPMENT_SETTINGS);
+            localStorageKey && localStorage.removeItem(localStorageKey);
+        }
+        catch (e) {
+            console.warn('localStorage is not available:', e);
+            return null;
+        }
+        try {
+            return JSON.parse(localDevelopmentSettingsFromLocalStore);
+        }
+        catch (e) {
+            console.error('Failed to parse the local development settings in your localstorage.', e);
+        }
+        return null;
+    },
+    store: (localDevelopmentSetting) => {
+        try {
+            localStorage.setItem(LocalStorageKeys.LOCAL_DEVELOPMENT_SETTINGS, JSON.stringify(localDevelopmentSetting));
+        }
+        catch (e) {
+            console.error('Failed to stringify the local development settings setting into your localstorage.', e);
+        }
+    },
+};
+const userSettingsLocalStorage = {
+    read: async (userInfo) => {
+        const transientSettings = {
+            frame_userAccount: {
+                name: userInfo.name || '',
+                email: userInfo.email || '',
+            },
+        };
+        return new Promise((resolve, reject) => {
+            try {
+                const storedSettings = localStorage.getItem(LocalStorageKeys.USER_SETTINGS);
+                const settings = storedSettings ? JSON.parse(storedSettings) : {};
+                const resultingSettings = { ...settings, ...transientSettings };
+                if (settings.frame_userAccount && transientSettings.frame_userAccount) {
+                    resultingSettings.frame_userAccount = {
+                        ...settings.frame_userAccount,
+                        ...transientSettings.frame_userAccount,
+                    };
+                }
+                if (resultingSettings.frame_userAccount?.language === undefined) {
+                    resultingSettings.frame_userAccount.language = 'en';
+                }
+                resolve(resultingSettings);
+            }
+            catch (e) {
+                console.error('Error reading user settings', e);
+                reject({
+                    closeDialog: true,
+                    message: 'Could not read userSettings from storage...',
+                });
+            }
+        });
+    },
+    store: async (settings) => {
+        if (settings.frame_userAccount && settings.frame_userAccount.language) {
+            delete settings.frame_userAccount.name;
+            delete settings.frame_userAccount.email;
+        }
+        else {
+            delete settings.frame_userAccount;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                localStorage.setItem(LocalStorageKeys.USER_SETTINGS, JSON.stringify(settings));
+                resolve(settings);
+            }
+            catch (e) {
+                console.error('Error storing user settings', e);
+                reject({
+                    closeDialog: true,
+                    message: 'Could not write userSettings to storage...',
+                });
+            }
+        });
+    },
+};
+const featureToggleLocalStorage = {
+    read: () => {
+        try {
+            const storedSettings = localStorage.getItem(LocalStorageKeys.FEATURE_TOGGLE_SETTINGS);
+            return storedSettings ? JSON.parse(storedSettings) : {};
+        }
+        catch (e) {
+            console.error('Error reading feature toggle settings', e);
+            return {};
+        }
+    },
+    store: (featureToggleSettings) => {
+        try {
+            localStorage.setItem(LocalStorageKeys.FEATURE_TOGGLE_SETTINGS, JSON.stringify(featureToggleSettings));
+        }
+        catch (e) {
+            console.error('Error storing feature toggle settings', e);
+        }
+    },
+};
+
+class IframeService {
+    constructor() {
+        this.luigiCoreService = inject(LuigiCoreService);
+    }
+    isIFrameFeaturePolicyAllowed(policy, iframeURL) {
+        // should be connected to a still to be developed permission management logic
+        return true;
+    }
+    isIFrameSandboxPermissionAllowed(policy, iframeURL) {
+        // should be connected to a still to be developed permission management logic
+        return true;
+    }
+    iFrameCreationInterceptor() {
+        return (iframe, viewGroup, navigationNode, microFrontendType) => {
+            this.applyIframePermissions(iframe, navigationNode, viewGroup);
+        };
+    }
+    applyIframePermissions(iframe, node, viewGroup) {
+        let permissions = node?.requiredIFramePermissions;
+        if (!permissions && viewGroup) {
+            const viewGroupSettings = this.luigiCoreService.getConfigValue('navigation.viewGroupSettings');
+            const viewGroupConfig = (viewGroupSettings && viewGroupSettings[viewGroup]) || {};
+            permissions = viewGroupConfig.requiredIFramePermissions;
+        }
+        if (!permissions) {
+            return;
+        }
+        if (permissions.allow) {
+            let allow = (iframe.getAttribute('allow') || '').trim();
+            if (allow.length > 0 && !allow.endsWith(';')) {
+                allow += ';';
+            }
+            permissions.allow.forEach((policy) => {
+                if (this.isIFrameFeaturePolicyAllowed(policy, iframe.getAttribute('src'))) {
+                    // feature policies are separated by semicolon
+                    allow += ` ${policy};`;
+                }
+            });
+            iframe.setAttribute('allow', allow.trim());
+        }
+        if (permissions.sandbox) {
+            let sandbox = (iframe.getAttribute('sandbox') || '').trim();
+            permissions.sandbox.forEach((permission) => {
+                if (this.isIFrameSandboxPermissionAllowed(permission, iframe.getAttribute('src'))) {
+                    // sandbox permission are separated by whitespace
+                    sandbox += ' ' + permission;
+                }
+            });
+            iframe.setAttribute('sandbox', sandbox.trim());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IframeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IframeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IframeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class StaticSettingsConfigServiceImpl {
+    constructor() {
+        this.customStaticSettingsConfigService = inject(LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN, {
+            optional: true,
+        });
+        this.i18nService = inject(I18nService);
+        this.iframeService = inject(IframeService);
+    }
+    async getStaticSettingsConfig() {
+        const logo = 'assets/images/logo.png';
+        const favicon = 'assets/images/favicon.ico';
+        return {
+            header: {
+                title: 'OpenMFP Portal',
+                logo,
+                favicon,
+            },
+            globalSideNavigation: true,
+            experimental: {
+                btpToolLayout: true,
+                globalNav: true,
+            },
+            btpToolLayout: true,
+            responsiveNavigation: 'Fiori3',
+            featureToggles: {
+                queryStringParam: 'ft',
+            },
+            appLoadingIndicator: {
+                hideAutomatically: true,
+            },
+            iframeCreationInterceptor: this.iframeService.iFrameCreationInterceptor(),
+            customTranslationImplementation: this.i18nService,
+            ...(await this.customStaticSettingsConfigService?.getStaticSettingsConfig()),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: StaticSettingsConfigServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: StaticSettingsConfigServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: StaticSettingsConfigServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class ReloadLuigiConfigListener {
+    constructor() {
+        this.configService = inject(ConfigService);
+        this.luigiCoreService = inject(LuigiCoreService);
+    }
+    messageId() {
+        return 'openmfp.reload-luigi-config';
+    }
+    async onCustomMessageReceived(customMessage, mfObject, mfNodesObject) {
+        console.debug(`Reloading Luigi config from ${customMessage.origin}, action: ${customMessage.action}
+      for entity: ${customMessage.entity ?? 'global'} 
+      with context: ${JSON.stringify(customMessage.context)}`);
+        await this.configService.reloadConfig(customMessage.entity, customMessage.context);
+        this.luigiCoreService.resetLuigi();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ReloadLuigiConfigListener, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ReloadLuigiConfigListener, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ReloadLuigiConfigListener, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * This class holds the customMessageListeners for custom messages used by the application portal.
+ * See also {@link https://docs.luigi-project.io/docs/communication/?section=luigi-core-to-luigi-client}
+ * See also {@link https://docs.luigi-project.io/docs/luigi-core-api/?section=custommessages}
+ */
+class CustomMessageListenersService {
+    constructor(messageListeners, customMessageListeners) {
+        this.messageListeners = messageListeners;
+        this.customMessageListeners = customMessageListeners;
+        this.listeners = [this.messageListeners, ...(this.customMessageListeners || []).filter((l) => !!l)];
+    }
+    /**
+     * An object containing the property 'listeners' in which the message-id and listener assignments are made.
+     * See also {@link https://docs.luigi-project.io/docs/communication/?section=luigi-core-to-luigi-client}
+     */
+    getMessageListeners() {
+        const result = { customMessagesListeners: {} };
+        for (const listener of this.listeners) {
+            const obj = {
+                [listener.messageId()]: (msg, mf, mfNodes) => {
+                    listener.onCustomMessageReceived(msg, mf, mfNodes);
+                },
+            };
+            Object.assign(result.customMessagesListeners, obj);
+        }
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CustomMessageListenersService, deps: [{ token: ReloadLuigiConfigListener }, { token: LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CustomMessageListenersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CustomMessageListenersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: ReloadLuigiConfigListener }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN]
+                }] }] });
+
+class DependenciesVersionsService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+    }
+    read() {
+        return firstValueFrom(this.httpClient.get('/assets/dependencies-versions.json'));
+    }
+    transformVersionsConfig(versionsConfig) {
+        return Object.entries(versionsConfig).reduce((acc, [key, value]) => {
+            const label = key
+                .replace(/([A-Z])/g, ' $1')
+                .replace(/^./, (char) => char.toUpperCase());
+            acc[key] = {
+                type: 'string',
+                label,
+                value,
+                isEditable: false,
+            };
+            return acc;
+        }, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: DependenciesVersionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: DependenciesVersionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: DependenciesVersionsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class UserSettingsConfigService {
+    constructor() {
+        this.luigiThemingService = inject(THEMING_SERVICE, {
+            optional: true,
+        });
+        this.authService = inject(AuthService);
+        this.i18nService = inject(I18nService);
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.dependenciesVersionsService = inject(DependenciesVersionsService);
+        this.envConfigService = inject(EnvConfigService);
+        this.versionsConfig = {};
+    }
+    async getUserSettings(childrenByEntity) {
+        const userSettingsConfig = this.extractUserSettings(childrenByEntity);
+        const groupsFromNodes = this.getGroupsFromUserSettings(userSettingsConfig);
+        this.versionsConfig = await this.readDependenciesVersions();
+        const envConfig = await this.envConfigService.getEnvConfig();
+        let coreGroups = await this.getCoreUserSettingsGroups();
+        const userSettings = {
+            userSettingsProfileMenuEntry: {
+                label: 'USERSETTINGSPROFILEMENUENTRY_SETTINGS',
+            },
+            userSettingsDialog: {
+                dismissBtn: 'USERSETTINGSDIALOG_CANCEL',
+                saveBtn: 'USERSETTINGSDIALOG_SAVE',
+                dialogHeader: 'USERSETTINGSDIALOG_HEADER',
+            },
+            userSettingGroups: { ...coreGroups, ...groupsFromNodes },
+            readUserSettings: async () => {
+                const setting = (await userSettingsLocalStorage.read(this.authService.getUserInfo())) || {};
+                setting.frame_versions = this.versionsConfig;
+                return setting;
+            },
+            storeUserSettings: async (settings, previous) => {
+                userSettingsLocalStorage.store(settings);
+                this.applyNewTheme(settings, previous);
+                this.changeToSelectedLanguage(settings, previous);
+                this.saveLocalDevelopmentSettings(settings, previous);
+                if (envConfig.uiOptions.includes('enableFeatureToggleSetting')) {
+                    this.saveFeatureToggleSettings(settings);
+                }
+            },
+        };
+        return userSettings;
+    }
+    async getCoreUserSettingsGroups() {
+        const envConfig = await this.envConfigService.getEnvConfig();
+        const settings = {};
+        await this.addUserSettings(settings);
+        await this.addThemingSettings(settings);
+        this.addLocalDevelopmentSettings(settings);
+        if (envConfig.uiOptions.includes('enableFeatureToggleSetting')) {
+            this.addFeatureToggleSettings(settings);
+        }
+        this.addInfoSettings(settings);
+        return settings;
+    }
+    saveFeatureToggleSettings(settings) {
+        const currentFeatureToggleSettings = settings?.frame_featureToggle?.featureToggleSettings;
+        featureToggleLocalStorage.store(currentFeatureToggleSettings);
+        this.luigiCoreService.unsetAllFeatureToggles();
+        this.luigiCoreService.setFeatureToggles(currentFeatureToggleSettings);
+        globalThis.location.reload();
+    }
+    saveLocalDevelopmentSettings(settings, previous) {
+        const currentLocalDevelopmentSettings = settings?.frame_development?.localDevelopmentSettings;
+        const previousLocalDevelopmentSettings = previous?.frame_development?.localDevelopmentSettings;
+        if (currentLocalDevelopmentSettings &&
+            (!localDevelopmentSettingsLocalStorage.read() ||
+                !isEqual(currentLocalDevelopmentSettings, previousLocalDevelopmentSettings))) {
+            localDevelopmentSettingsLocalStorage.store(currentLocalDevelopmentSettings);
+            globalThis.location.reload();
+        }
+    }
+    extractUserSettings(childrenByEntity) {
+        const userSettings = Object.values(childrenByEntity)
+            .reduce((accumulator, value) => accumulator.concat(value), [])
+            .reduce((accu, n) => {
+            if (n._userSettingsConfig) {
+                accu.push(n._userSettingsConfig);
+            }
+            return accu;
+        }, []);
+        return userSettings;
+    }
+    changeToSelectedLanguage(settings, previous) {
+        if (settings?.frame_userAccount?.language &&
+            previous?.frame_userAccount?.language !==
+                settings?.frame_userAccount?.language) {
+            globalThis.location.reload();
+        }
+    }
+    applyNewTheme(settings, previous) {
+        if (settings?.frame_appearance?.selectedTheme &&
+            previous?.frame_appearance?.selectedTheme !==
+                settings?.frame_appearance?.selectedTheme) {
+            this.luigiThemingService?.applyTheme(settings.frame_appearance.selectedTheme);
+        }
+    }
+    getGroupsFromUserSettings(luigiUserSettings) {
+        const settingsGroups = {};
+        luigiUserSettings.forEach((userConfig) => {
+            if (userConfig?.groups) {
+                Object.keys(userConfig.groups).forEach((groupId) => {
+                    const groupConfig = userConfig.groups[groupId];
+                    settingsGroups[groupId] = groupConfig;
+                });
+            }
+        });
+        return settingsGroups;
+    }
+    async getSelectedThemeDisplayName() {
+        const user = this.authService.getUserInfo();
+        const userSettings = await userSettingsLocalStorage.read(user);
+        const selectedTheme = userSettings?.frame_appearance?.selectedTheme ||
+            this.luigiThemingService.getDefaultThemeId();
+        return this.luigiThemingService
+            .getAvailableThemes()
+            .find((t) => t.id === selectedTheme)?.name;
+    }
+    async addThemingSettings(settings) {
+        if (this.luigiThemingService) {
+            settings.frame_appearance = {
+                label: 'USERSETTINGSDIALOG__APPEARANCE',
+                sublabel: await this.getSelectedThemeDisplayName(),
+                icon: 'palette',
+                title: 'USERSETTINGSDIALOG__APPEARANCE',
+                viewUrl: '/settings-theming#disable_loading_indicator',
+                settings: {},
+            };
+        }
+    }
+    addLocalDevelopmentSettings(settings) {
+        settings.frame_development = {
+            label: 'LOCAL_DEVELOPMENT_SETTINGS_DIALOG_LABEL',
+            sublabel: 'LOCAL_DEVELOPMENT_SETTINGS_DIALOG_SUBLABEL',
+            icon: 'developer-settings',
+            iconClassAttribute: localDevelopmentSettingsLocalStorage.read()?.isActive
+                ? 'settings-icon-active'
+                : '',
+            title: 'LOCAL_DEVELOPMENT_SETTINGS_DIALOG_TITLE',
+            viewUrl: '/assets/openmfp-portal-ui-wc.js#development-settings',
+            webcomponent: {
+                selfRegistered: true,
+            },
+            context: {
+                translationTable: this.i18nService.translationTable,
+            },
+        };
+    }
+    async addUserSettings(settings) {
+        const userInfo = this.authService.getUserInfo();
+        settings.frame_userAccount = {
+            label: 'USERSETTINGSDIALOG_USER_ACCOUNT',
+            sublabel: userInfo.name,
+            icon: `https://avatars.wdf.sap.corp/avatar/${userInfo.userId}`,
+            title: userInfo.name,
+            initials: userInfo.initials,
+            iconClassAttribute: 'fd-avatar fd-avatar--s fd-avatar--circle fd-avatar--thumbnail lui-avatar-space',
+            settings: {
+                name: {
+                    type: 'string',
+                    label: 'USERSETTINGSDIALOG_NAME',
+                    isEditable: false,
+                },
+                email: {
+                    type: 'string',
+                    label: 'USERSETTINGSDIALOG_EMAIL',
+                    isEditable: false,
+                },
+            },
+        };
+        const validLanguages = await this.i18nService.getValidLanguages();
+        if (validLanguages.length > 1) {
+            settings.frame_userAccount.settings['language'] = {
+                type: 'enum',
+                label: 'USERSETTINGSDIALOG_LANGUAGE',
+                options: validLanguages,
+            };
+        }
+    }
+    addInfoSettings(settings) {
+        const settingsTransformed = this.dependenciesVersionsService.transformVersionsConfig(this.versionsConfig);
+        settings.frame_versions = {
+            label: 'INFO_SETTINGS_DIALOG_LABEL',
+            sublabel: 'INFO_SETTINGS_DIALOG_SUBLABEL',
+            title: 'INFO_SETTINGS_DIALOG_TITLE',
+            icon: 'message-information',
+            settings: settingsTransformed,
+        };
+    }
+    addFeatureToggleSettings(settings) {
+        const isActive = this.luigiCoreService.getActiveFeatureToggleList().length > 0;
+        settings.frame_featureToggle = {
+            label: 'FEATURE_TOGGLE_SETTINGS_DIALOG_LABEL',
+            sublabel: 'FEATURE_TOGGLE_SETTINGS_DIALOG_SUBLABEL',
+            title: 'FEATURE_TOGGLE_SETTINGS_DIALOG_TITLE',
+            icon: 'activate',
+            iconClassAttribute: isActive ? 'settings-icon-active' : '',
+            viewUrl: '/assets/openmfp-portal-ui-wc.js#feature-toggle',
+            webcomponent: {
+                selfRegistered: true,
+            },
+            context: {
+                translationTable: this.i18nService.translationTable,
+            },
+        };
+    }
+    async readDependenciesVersions() {
+        const versions = { browser: navigator.userAgent };
+        try {
+            return {
+                ...(await this.dependenciesVersionsService.read()),
+                ...versions,
+            };
+        }
+        catch (error) { }
+        return versions;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: UserSettingsConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: UserSettingsConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: UserSettingsConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class NodeUtilsService {
+    constructor(luigiCoreService) {
+        this.luigiCoreService = luigiCoreService;
+    }
+    retrieveGlobalHelpContext() {
+        return (node) => {
+            const ctx = this.luigiCoreService.getGlobalContext();
+            node.context.helpContext = ctx.helpContext;
+            return true;
+        };
+    }
+    isVisible(node) {
+        if (!node.visibleForFeatureToggles) {
+            return true;
+        }
+        return node.visibleForFeatureToggles.every((ft) => {
+            if (ft.startsWith('!')) {
+                return !this.luigiCoreService.isFeatureToggleActive(ft.slice(1));
+            }
+            return this.luigiCoreService.isFeatureToggleActive(ft);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeUtilsService, deps: [{ token: LuigiCoreService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeUtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeUtilsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: LuigiCoreService }] });
+
+class AppSwitcherConfigServiceImpl {
+    constructor() {
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.nodeUtilsService = inject(NodeUtilsService);
+    }
+    getAppSwitcher(luigiNodes) {
+        return {
+            keepMainTitle: true,
+            showSubTitle: false,
+            itemRenderer: (item, slot, appSwitcherApiObj) => {
+                const a = document.createElement('a');
+                a.setAttribute('class', 'fd-menu__link');
+                a.addEventListener('click', (e) => {
+                    this.luigiCoreService.navigation().navigate(item.link);
+                    appSwitcherApiObj.closeDropDown();
+                    e.stopPropagation();
+                });
+                const span = document.createElement('span');
+                span.setAttribute('class', 'fd-menu__addon-before');
+                const i = document.createElement('i');
+                i.setAttribute('class', 'sap-icon--' + item.icon);
+                span.appendChild(i);
+                const spanText = document.createElement('span');
+                spanText.setAttribute('class', 'fd-menu__title');
+                spanText.innerText = item.title;
+                a.appendChild(span);
+                a.appendChild(spanText);
+                slot.innerHTML = '';
+                slot.appendChild(a);
+            },
+            items: this.getNodeItems(luigiNodes),
+        };
+    }
+    getNodeItems(luigiNodes) {
+        const items = (luigiNodes || [])
+            .filter((node) => {
+            return (!node.hideFromNav &&
+                node.entityType === EntityType.GLOBAL &&
+                this.nodeUtilsService.isVisible(node));
+        })
+            .map((node) => {
+            const nodeConfig = {
+                title: node.label,
+                icon: node.icon,
+                link: '/' + node.pathSegment,
+            };
+            return nodeConfig;
+        });
+        return items?.length === 1 ? [] : items;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AppSwitcherConfigServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AppSwitcherConfigServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AppSwitcherConfigServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class HeaderBarService {
+    constructor(headerBarConfig) {
+        this.headerBarConfig = headerBarConfig;
+    }
+    async getConfig() {
+        if (!this.headerBarConfig) {
+            return undefined;
+        }
+        const { leftRenderers, rightRenderers, ...rest } = await this.headerBarConfig.getConfig();
+        return {
+            ...rest,
+            renderer: (containerElement, nodeItems, clickHandler) => {
+                containerElement.style.display = 'flex';
+                containerElement.style.position = 'static';
+                containerElement.style.height = 'min-content';
+                const parrent = containerElement.parentElement;
+                if (parrent) {
+                    this.setParrentStyles(parrent);
+                }
+                const { rightContainer, leftContainer } = this.createRendererContainers();
+                containerElement.appendChild(leftContainer);
+                containerElement.appendChild(rightContainer);
+                this.executeRenderes(leftContainer, leftRenderers, [nodeItems, clickHandler]);
+                this.executeRenderes(rightContainer, rightRenderers, [nodeItems, clickHandler]);
+                return containerElement;
+            },
+        };
+    }
+    ;
+    setParrentStyles(parrent) {
+        parrent.style.display = 'flex';
+        parrent.style.flexDirection = 'column';
+        parrent.style.height = '100%';
+        parrent.style.marginTop = '0';
+    }
+    executeRenderes(rootContainer, renderers, params) {
+        renderers.forEach((renderer) => {
+            const rendererContainer = document.createElement('div');
+            rootContainer.appendChild(rendererContainer);
+            renderer(rendererContainer, ...params);
+        });
+    }
+    createRendererContainers() {
+        const rightContainer = document.createElement('div');
+        const leftContainer = document.createElement('div');
+        rightContainer.style.display = 'flex';
+        rightContainer.style.justifyContent = 'flex-end';
+        rightContainer.style.gap = '1em';
+        leftContainer.style.display = 'flex';
+        leftContainer.style.justifyContent = 'flex-start';
+        leftContainer.style.gap = '1em';
+        leftContainer.style.flexGrow = '1';
+        return { rightContainer, leftContainer };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HeaderBarService, deps: [{ token: HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HeaderBarService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HeaderBarService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN]
+                }] }] });
+
+class AuthConfigService {
+    constructor() {
+        this.authService = inject(AuthService);
+        this.envConfigService = inject(EnvConfigService);
+        this.luigiAuthEventsCallbacksService = inject(LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    async getAuthConfig() {
+        const { oauthServerUrl, clientId } = await this.envConfigService.getEnvConfig();
+        return {
+            use: 'oAuth2AuthCode',
+            storage: 'none',
+            oAuth2AuthCode: {
+                idpProvider: oAuth2,
+                authorizeUrl: oauthServerUrl,
+                logoutUrl: '/rest/logout',
+                post_logout_redirect_uri: '/logout',
+                oAuthData: {
+                    client_id: clientId,
+                    scope: 'openid',
+                    redirect_uri: '/callback',
+                    response_type: 'code',
+                },
+                accessTokenExpiringNotificationTime: 60,
+                expirationCheckInterval: 5,
+                userInfoFn: () => {
+                    const userInfo = this.authService.getUserInfo();
+                    return new Promise((resolve) => {
+                        fetch(userInfo.picture, {
+                            method: 'HEAD',
+                            mode: 'no-cors',
+                        })
+                            .then(() => {
+                            resolve(userInfo);
+                        })
+                            .catch(() => {
+                            userInfo.picture = '';
+                            resolve(userInfo);
+                        });
+                    });
+                },
+            },
+            disableAutoLogin: false,
+            events: {
+                onAuthSuccessful: (settings, authData) => {
+                    this.authService.authEvent(AuthEvent.AUTH_SUCCESSFUL);
+                    this.luigiAuthEventsCallbacksService?.onAuthSuccessful(settings, authData);
+                },
+                onAuthError: (settings, err) => {
+                    this.authService.authEvent(AuthEvent.AUTH_ERROR);
+                    this.luigiAuthEventsCallbacksService?.onAuthError(settings, err);
+                },
+                onAuthExpired: (settings) => {
+                    this.authService.authEvent(AuthEvent.AUTH_EXPIRED);
+                    this.luigiAuthEventsCallbacksService?.onAuthExpired(settings);
+                },
+                onLogout: (settings) => {
+                    this.authService.authEvent(AuthEvent.LOGOUT);
+                    this.luigiAuthEventsCallbacksService?.onLogout(settings);
+                },
+                onAuthExpireSoon: (settings) => {
+                    this.authService.authEvent(AuthEvent.AUTH_EXPIRE_SOON);
+                    this.luigiAuthEventsCallbacksService?.onAuthExpireSoon(settings);
+                },
+                onAuthConfigError: (settings, err) => {
+                    this.authService.authEvent(AuthEvent.AUTH_CONFIG_ERROR);
+                    this.luigiAuthEventsCallbacksService?.onAuthConfigError(settings, err);
+                },
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: AuthConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LocalConfigurationServiceImpl {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.luigiConfigService = inject(LocalNodesService);
+        this.i18nService = inject(I18nService);
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.customLocalConfigurationService = inject(LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    async getLocalNodes() {
+        const localDevelopmentSettings = localDevelopmentSettingsLocalStorage.read();
+        if (!localDevelopmentSettings?.isActive) {
+            return ((await this.customLocalConfigurationService?.getLocalNodes()) || []);
+        }
+        this.addLocalDevelopmentModeOnIndicator();
+        if (this.cachedLocalNodes?.length) {
+            return this.cachedLocalNodes;
+        }
+        try {
+            const configurations = await this.getLocalConfigurations(localDevelopmentSettings);
+            const result = (await this.luigiConfigService.getLuigiNodesFromConfigurations(configurations)) || {};
+            if (result.errors) {
+                this.alertErrors(result.errors);
+            }
+            (result.nodes || []).forEach((node) => {
+                node.context = {
+                    ...node.context,
+                    serviceProviderConfig: {
+                        ...node.context?.serviceProviderConfig,
+                        ...localDevelopmentSettings.serviceProviderConfig,
+                    },
+                };
+            });
+            return (this.cachedLocalNodes = result.nodes || []);
+        }
+        catch (e) {
+            console.warn(`Failed to retrieve local luigi config.`, e);
+            return [];
+        }
+    }
+    addLocalDevelopmentModeOnIndicator() {
+        const popoverControl = document.querySelector('#profilePopover');
+        if (popoverControl && popoverControl.parentNode) {
+            const newSpan = document.createElement('span');
+            newSpan.classList.add('sap-icon--developer-settings', 'local-development-settings-indication');
+            newSpan.title = this.i18nService.getTranslation('LOCAL_DEVELOPMENT_SETTINGS_ACTIVE_INDICATOR');
+            popoverControl.parentNode.appendChild(newSpan);
+        }
+    }
+    alertErrors(errors) {
+        const message = errors
+            .map((e) => {
+            return `For configuration with url:
+            ${e.url} <br/><br/>
+            ${(e.validationErrors || [])
+                .map((v) => v.message)
+                .filter((v) => !v.includes('The document is not valid'))
+                .join('<br/>')}`;
+        })
+            .join('<br/><br/><br/>');
+        this.luigiCoreService.showAlert({
+            text: `
+            Your local development configuration contains error(s).
+            You will not be able to see your local changes and local development results unless you correct the data and reload the page. 
+            Please see below the detailed information: <br/><br/>
+            
+            ${message}
+          `,
+            type: 'error',
+        });
+    }
+    async replaceServerNodesWithLocalOnes(serverLuigiNodes, currentEntities) {
+        const localNodes = await this.getLocalNodes();
+        console.debug(`Processing local nodes for currentEntities: ${currentEntities}`);
+        if (!localNodes || localNodes.length == 0) {
+            console.debug('No local nodes found');
+            return serverLuigiNodes;
+        }
+        this.logNodesState(serverLuigiNodes, localNodes);
+        const localReplacingNodes = [];
+        const filteredServerNodes = serverLuigiNodes.filter((serverNode) => {
+            const index = localNodes.findIndex((localNode) => {
+                return this.localNodeMatchesServerNode(localNode, serverNode);
+            });
+            if (index !== -1) {
+                const [localFoundNode] = localNodes.splice(index, 1);
+                localReplacingNodes.push(localFoundNode);
+                localFoundNode.context = {
+                    ...serverNode.context,
+                    ...localFoundNode.context,
+                };
+            }
+            return index === -1;
+        });
+        const localNewNodes = localNodes.filter((n) => {
+            const entity = n.entityType?.includes('::compound')
+                ? 'global'
+                : n.entityType || 'home';
+            return currentEntities.includes(entity);
+        });
+        console.debug(`${filteredServerNodes.length} server nodes have no matching local nodes.
+      Found ${localReplacingNodes.length} matching local nodes.
+      Adding ${localNewNodes.length} new local nodes.`);
+        return filteredServerNodes
+            .concat(localReplacingNodes)
+            .concat(localNewNodes);
+    }
+    logNodesState(serverLuigiNodes, localNodes) {
+        const serverEntityTypes = [
+            ...new Set(serverLuigiNodes.map((n) => n.entityType)),
+        ]
+            .filter(Boolean)
+            .join(',');
+        const localEntityTypes = [...new Set(localNodes.map((n) => n.entityType))]
+            .filter(Boolean)
+            .join(',');
+        console.debug(`Found '${serverLuigiNodes.length}' server nodes. 
+       Found '${localNodes.length}' local luigi nodes. 
+       The entities of the server node are: [${serverEntityTypes}]
+       The entities of local nodes are: [${localEntityTypes}]`);
+    }
+    localNodeMatchesServerNode(localNode, node) {
+        return (localNode.pathSegment === node.pathSegment &&
+            localNode.entityType === node.entityType);
+    }
+    async getLocalConfigurations(localDevelopmentSettings) {
+        const initialConfigurations = localDevelopmentSettings.configs
+            .filter((config) => config.data)
+            .map((config) => config.data);
+        const configurations = (await Promise.allSettled(localDevelopmentSettings.configs
+            .filter((config) => config.url)
+            .map((config) => lastValueFrom(this.http.get(config.url)).then((contentConfiguration) => ({
+            ...contentConfiguration,
+            url: config.url,
+        })))))
+            .filter((result) => result.status === 'fulfilled')
+            .map((result) => result.value)
+            .concat(initialConfigurations);
+        return configurations;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalConfigurationServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalConfigurationServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LocalConfigurationServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LuigiNodesService {
+    constructor() {
+        this.i18nService = inject(I18nService);
+        this.configService = inject(ConfigService);
+        this.localConfigurationService = inject(LocalConfigurationServiceImpl);
+        this.errorComponentConfig = inject(ERROR_COMPONENT_CONFIG, {
+            optional: true,
+        });
+    }
+    getChildrenByEntity(allChildren) {
+        const childrenByEntity = {
+            home: [],
+        };
+        for (const child of allChildren) {
+            // default to home to stay backward compatible
+            const entityType = child.entityType || 'home';
+            if (!childrenByEntity[entityType]) {
+                childrenByEntity[entityType] = [];
+            }
+            childrenByEntity[entityType].push(child);
+        }
+        return childrenByEntity;
+    }
+    async retrieveChildrenByEntity() {
+        try {
+            const portalConfig = await this.configService.getPortalConfig();
+            const serverLuigiNodes = portalConfig.providers.flatMap((p) => p.nodes);
+            const luigiNodes = await this.localConfigurationService.replaceServerNodesWithLocalOnes(serverLuigiNodes, ['global', 'main', 'home']);
+            return this.getChildrenByEntity(luigiNodes);
+        }
+        catch (e) {
+            console.warn('Could not retrieve nodes, error: ', e);
+            throw e;
+        }
+    }
+    async retrieveEntityChildren(entityDefinition, additionalContext) {
+        let errorCode = 0;
+        let configsForEntity;
+        const entityType = entityDefinition.dynamicFetchId;
+        try {
+            configsForEntity = await this.configService.getEntityConfig(entityType, additionalContext);
+        }
+        catch (e) {
+            errorCode = e.status || 500;
+            console.warn(`Could not retrieve nodes for entity: ${entityType}, error: `, e);
+        }
+        if (errorCode) {
+            return this.createErrorNodes(entityDefinition, additionalContext, errorCode);
+        }
+        return configsForEntity.providers.flatMap((p) => p.nodes);
+    }
+    createErrorNodes(entityDefinition, additionalContext, errorCode) {
+        return [
+            {
+                pathSegment: 'error',
+                entityType: EntityType.ENTITY_ERROR,
+                hideFromNav: true,
+                hideSideNav: true,
+                viewUrl: '/assets/openmfp-portal-ui-wc.js#error-component',
+                context: {
+                    error: {
+                        code: errorCode,
+                        errorComponentConfig: this.errorComponentConfig,
+                        entityDefinition,
+                        additionalContext,
+                    },
+                    translationTable: this.i18nService.translationTable,
+                },
+                isolateView: true,
+                showBreadcrumbs: false,
+                webcomponent: {
+                    selfRegistered: true,
+                },
+            },
+        ];
+    }
+    nodePolicyResolver(nodeToCheckPermissionFor) {
+        const mockPermissions = ['projectMember'];
+        const permissions = nodeToCheckPermissionFor.requiredPolicies;
+        return (!permissions ||
+            permissions.every((item) => mockPermissions.includes(item)));
+    }
+    clearNodeCache() {
+        this.configService.clearEntityConfigCache();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiNodesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiNodesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiNodesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class RoutingConfigServiceImpl {
+    constructor() {
+        this.customRoutingConfigService = inject(LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    getInitialRoutingConfig() {
+        return {
+            useHashRouting: false,
+            showModalPathInUrl: false,
+            modalPathParam: 'modalPathParamDisabled',
+            skipRoutingForUrlPatterns: [/.*/],
+            pageNotFoundHandler: () => { },
+            ...(this.customRoutingConfigService?.getInitialRoutingConfig?.() || {}),
+        };
+    }
+    getRoutingConfig() {
+        return {
+            useHashRouting: false,
+            showModalPathInUrl: true,
+            modalPathParam: 'modal',
+            pageNotFoundHandler: (notFoundPath, isAnyPathMatched) => {
+                return {
+                    redirectTo: 'error/404',
+                    keepURL: true,
+                };
+            },
+            ...(this.customRoutingConfigService?.getRoutingConfig?.() || {}),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RoutingConfigServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RoutingConfigServiceImpl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: RoutingConfigServiceImpl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+async function bootstrap(authService) {
+    try {
+        await authService.refresh();
+    }
+    catch (error) {
+        console.error('Error bootstrapping the app:', error);
+    }
+}
+const provideBootstrap = () => provideAppInitializer(() => bootstrap(inject(AuthService)));
+
+async function initializeAutomaticSessionRefresh(sessionRefreshService, authService, luigiCoreService) {
+    authService.authEvents
+        .pipe(filter((event) => event === AuthEvent.AUTH_EXPIRE_SOON), filter(() => luigiCoreService.isFeatureToggleActive('enableSessionAutoRefresh')))
+        .subscribe({
+        next: async () => {
+            try {
+                await sessionRefreshService.refresh();
+            }
+            catch (error) {
+                console.error('Error executing session refresh: ', error);
+            }
+        },
+    });
+}
+const provideSessionRefresh = () => provideAppInitializer(() => initializeAutomaticSessionRefresh(inject(SessionRefreshService), inject(AuthService), inject(LuigiCoreService)));
+
+class NavigationService {
+    constructor(router, authService, loginEventService) {
+        this.router = router;
+        this.authService = authService;
+        this.loginEventService = loginEventService;
+    }
+    track() {
+        this.router.events
+            .pipe(filter$1((event) => event instanceof NavigationEnd))
+            .subscribe((event) => {
+            this.currentUrl = event.url;
+        });
+        this.router.events
+            .pipe(filter$1((event) => event instanceof NavigationStart))
+            .subscribe((event) => {
+            this.previousUrl = event.url;
+        });
+        this.authService.authEvents
+            .pipe(filter$1((event) => event === AuthEvent.AUTH_EXPIRED))
+            .subscribe({ next: () => this.saveCurrentUrl() });
+        this.authService.authEvents
+            .pipe(filter$1((event) => event === AuthEvent.LOGOUT))
+            .subscribe({
+            next: () => {
+                this.saveLastNavigationUrl();
+            },
+        });
+        this.loginEventService.loginEvents
+            .pipe(filter$1((event) => event.type === LoginEventType.LOGIN_TRIGGERED))
+            .subscribe({
+            next: (event) => {
+                this.router.navigate([this.getRedirectUrl()], {
+                    queryParams: event.queryParams,
+                });
+                this.clearCurrentUrl();
+            },
+        });
+    }
+    clearCurrentUrl() {
+        localStorage.setItem(LocalStorageKeys.LAST_NAVIGATION_URL, '');
+    }
+    saveCurrentUrl() {
+        localStorage.setItem(LocalStorageKeys.LAST_NAVIGATION_URL, this.currentUrl);
+    }
+    saveLastNavigationUrl() {
+        localStorage.setItem(LocalStorageKeys.LAST_NAVIGATION_URL, this.previousUrl);
+    }
+    getRedirectUrl() {
+        return localStorage.getItem(LocalStorageKeys.LAST_NAVIGATION_URL) || '/';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationService, deps: [{ token: i1.Router }, { token: AuthService }, { token: LoginEventService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: AuthService }, { type: LoginEventService }] });
+
+async function track(navigationService) {
+    navigationService.track();
+}
+const provideNavigationTracker = () => provideAppInitializer(() => {
+    track(inject(NavigationService));
+});
+
+async function initLanguage(i18nService, authService, luigiCoreService) {
+    const userSettings = await userSettingsLocalStorage.read(authService.getUserInfo());
+    const storedLanguage = userSettings?.frame_userAccount?.language;
+    const validLanguages = (await i18nService.getValidLanguages()).map((l) => l.value);
+    let language = i18nService.fallbackLanguage;
+    if (storedLanguage && validLanguages.includes(storedLanguage)) {
+        language = storedLanguage;
+    }
+    luigiCoreService.setCurrentLocale(language);
+    await i18nService.fetchTranslationFile(language);
+}
+const provideLanguageServices = () => provideAppInitializer(() => initLanguage(inject(I18nService), inject(AuthService), inject(LuigiCoreService)));
+
+class LogoutComponent {
+    constructor(route, luigiCoreService, i18nService, loginEventService) {
+        this.route = route;
+        this.luigiCoreService = luigiCoreService;
+        this.i18nService = i18nService;
+        this.loginEventService = loginEventService;
+        this.headline = signal('', ...(ngDevMode ? [{ debugName: "headline" }] : []));
+        this.hint = signal('', ...(ngDevMode ? [{ debugName: "hint" }] : []));
+        this.btnText = signal('', ...(ngDevMode ? [{ debugName: "btnText" }] : []));
+    }
+    async ngOnInit() {
+        this.luigiCoreService.ux().hideAppLoadingIndicator();
+        const error = this.route.snapshot.queryParams['error'];
+        const translations = await this.getTranslations();
+        this.headline.set(translations.headlineSuccessfullyLoggedOut);
+        this.hint.set(translations.hintSignIn);
+        this.btnText.set(translations.btnTextLoginAgain);
+        switch (error) {
+            case 'tokenExpired':
+                this.headline.set(translations.headlineSessionExpired);
+                break;
+            case 'loginError':
+                this.headline.set(translations.headlineSigInError);
+                this.hint.set(translations.hintSignInError);
+                break;
+            case 'invalidToken':
+                this.luigiCoreService.removeAuthData();
+                this.headline.set(translations.headlineInvalidTokenError);
+                this.hint.set(translations.hintInvalidTokenError);
+                break;
+            default:
+                break;
+        }
+    }
+    login() {
+        this.loginEventService.loginEvent({ type: LoginEventType.LOGIN_TRIGGERED });
+    }
+    async getTranslations() {
+        return {
+            headlineSuccessfullyLoggedOut: await this.i18nService.getTranslationAsync('SUCCESSFULLY_LOGGED_OUT'),
+            hintSignIn: await this.i18nService.getTranslationAsync('SIGN_IN_HINT'),
+            btnTextLoginAgain: await this.i18nService.getTranslationAsync('LOGIN_AGAIN'),
+            headlineSessionExpired: await this.i18nService.getTranslationAsync('SESSION_EXPIRED'),
+            headlineSigInError: await this.i18nService.getTranslationAsync('SIGN_IN_ERROR'),
+            hintSignInError: await this.i18nService.getTranslationAsync('SIGN_IN_ERROR_HINT'),
+            headlineInvalidTokenError: await this.i18nService.getTranslationAsync('INVALID_TOKEN_ERROR'),
+            hintInvalidTokenError: await this.i18nService.getTranslationAsync('INVALID_TOKEN_ERROR_HINT'),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LogoutComponent, deps: [{ token: i1.ActivatedRoute }, { token: LuigiCoreService }, { token: I18nService }, { token: LoginEventService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.9", type: LogoutComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: "<div class=\"fd-page\">\n  <link rel=\"stylesheet\" href=\"/fundamental-styles/fundamental-styles.css\" />\n  <div class=\"fd-page__content\">\n    <div class=\"fd-container fd-container--centered\">\n      <div class=\"content\">\n        <span class=\"sap-icon--log\"></span>\n\n        <div class=\"info\" data-e2e=\"logout-headline\">{{ headline() }}</div>\n        <div class=\"hint\" data-e2e=\"logout-message\">{{ hint() }}</div>\n\n        <p class=\"fd-has-text-align-center\">\n          <button\n            class=\"fd-button fd-button--action-bar fd-button--l\"\n            (click)=\"login()\"\n          >\n            {{ btnText() }}\n          </button>\n        </p>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Light-full.woff) format(\"woff\");font-weight:300;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Light-full.woff2) format(\"woff2\");font-weight:300;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Bold-full.woff) format(\"woff\");font-weight:700;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Bold-full.woff2) format(\"woff2\");font-weight:700;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Regular-full.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Regular-full.woff2) format(\"woff2\");font-weight:400;font-style:normal}@font-face{font-family:SAP-icons;src:url(/fundamental-styles/SAP-icons.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:SAP-icons;src:url(/fundamental-styles/SAP-icons.woff2) format(\"woff2\");font-weight:400;font-style:normal}body{margin:0}.sap-icon--log:before{font-size:150px;color:#a0a0a0}.fd-container--centered{text-align:center}a.fd-button{color:#fff}.fd-page{margin-top:32px;height:100vh;overflow-y:auto;overflow-x:hidden}.content{width:100%}.fd-has-text-align-center{text-align:center}.info,.hint{text-align:center;margin:0}.info{padding-top:30px;font-size:36px}.hint{font-size:18px;color:#6f7275;padding-bottom:30px}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LogoutComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"fd-page\">\n  <link rel=\"stylesheet\" href=\"/fundamental-styles/fundamental-styles.css\" />\n  <div class=\"fd-page__content\">\n    <div class=\"fd-container fd-container--centered\">\n      <div class=\"content\">\n        <span class=\"sap-icon--log\"></span>\n\n        <div class=\"info\" data-e2e=\"logout-headline\">{{ headline() }}</div>\n        <div class=\"hint\" data-e2e=\"logout-message\">{{ hint() }}</div>\n\n        <p class=\"fd-has-text-align-center\">\n          <button\n            class=\"fd-button fd-button--action-bar fd-button--l\"\n            (click)=\"login()\"\n          >\n            {{ btnText() }}\n          </button>\n        </p>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: ["@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Light-full.woff) format(\"woff\");font-weight:300;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Light-full.woff2) format(\"woff2\");font-weight:300;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Bold-full.woff) format(\"woff\");font-weight:700;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Bold-full.woff2) format(\"woff2\");font-weight:700;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Regular-full.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:\"72\";src:url(/fundamental-styles/72-Regular-full.woff2) format(\"woff2\");font-weight:400;font-style:normal}@font-face{font-family:SAP-icons;src:url(/fundamental-styles/SAP-icons.woff) format(\"woff\");font-weight:400;font-style:normal}@font-face{font-family:SAP-icons;src:url(/fundamental-styles/SAP-icons.woff2) format(\"woff2\");font-weight:400;font-style:normal}body{margin:0}.sap-icon--log:before{font-size:150px;color:#a0a0a0}.fd-container--centered{text-align:center}a.fd-button{color:#fff}.fd-page{margin-top:32px;height:100vh;overflow-y:auto;overflow-x:hidden}.content{width:100%}.fd-has-text-align-center{text-align:center}.info,.hint{text-align:center;margin:0}.info{padding-top:30px;font-size:36px}.hint{font-size:18px;color:#6f7275;padding-bottom:30px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }, { type: LuigiCoreService }, { type: I18nService }, { type: LoginEventService }] });
+
+class IntentNavigationService {
+    constructor() { }
+    /**
+     * This function builds the Luigi based intent mapping configuration from the pre-built intent target knowledge
+     * It iterates existing intentMappings and constructs pathSegment from the relative path of the defined entity and the target
+     * that uses the entity as a reference
+     *
+     * @param nodes the nodes to fetch intentMapping initial configuration from
+     * @returns a list of luigi intent objects
+     */
+    buildIntentMappings(nodes) {
+        let intentMappings = [];
+        let entityRelativePaths = {};
+        // find mapping on config from node[0] --> not 0 anymore need to traverse fully
+        for (const item of nodes) {
+            if (item._intentMappings) {
+                intentMappings = [...intentMappings, ...item._intentMappings];
+            }
+            if (item._entityRelativePaths) {
+                entityRelativePaths = {
+                    ...entityRelativePaths,
+                    ...item._entityRelativePaths,
+                };
+            }
+        }
+        for (const intentElement of intentMappings) {
+            if (entityRelativePaths && intentElement.baseEntityId) {
+                let entityPath = '';
+                intentElement.baseEntityId.split('.').forEach((entity) => {
+                    if (entityRelativePaths[entity] &&
+                        entityRelativePaths[entity].pathSegment) {
+                        entityPath += '/' + entityRelativePaths[entity].pathSegment;
+                    }
+                });
+                intentElement.pathSegment = this.removeDuplicateSlash(entityPath + '/' + intentElement.relativePath);
+            }
+        }
+        return intentMappings;
+    }
+    /**
+     * Removes duplicate slashes if exist
+     *
+     * @param url the url string to modify
+     * @returns
+     */
+    removeDuplicateSlash(url) {
+        return url.replace(/\/+/g, '/');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IntentNavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IntentNavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: IntentNavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Evaluates the JMESPath expression on the context and returns true if the result is true, otherwise false
+ * @param context The context to evaluate
+ * @param jmesPathExpression The JMESPath expression to evaluate
+ * @returns true if the result of the JMESPath expression is true, otherwise (or if there was an exception while matching with JMESPath) false
+ * */
+function matchesJMESPath(context, jmesPathExpression) {
+    if (!jmesPathExpression) {
+        return true;
+    }
+    try {
+        return search(context, jmesPathExpression) === true;
+    }
+    catch (e) {
+        logJMESException(context, jmesPathExpression, e);
+        return false;
+    }
+}
+function logJMESException(context, jmesPathExpression, error) {
+    console.warn('Error while evaluating JMESPath expression.', 'Please check your visibleForContext or configurationMissing key in your Configuration.', '\n', '\n', 'Context:', '\n', context, '\n', '\n', 'JMESPath expression:', '\n', jmesPathExpression, '\n', '\n', 'Exception: ', '\n', error);
+}
+
+const visibleForContext = (ctx, node) => {
+    // visibleForEntityContext is deprecated
+    if (!isMatch(ctx.entityContext, node.visibleForEntityContext)) {
+        return false;
+    }
+    return matchesJMESPath(ctx, node.visibleForContext);
+};
+const computeDynamicFetchContext = (entityNode, ctx) => {
+    const contextForEntityConfig = new Map();
+    function addToAll(key, value) {
+        contextForEntityConfig.forEach((record) => {
+            record[key] = value;
+        });
+    }
+    let node = entityNode;
+    while (node) {
+        if (node.defineEntity?.contextKey && node.defineEntity?.dynamicFetchId) {
+            contextForEntityConfig.set(node.defineEntity.dynamicFetchId, {});
+            addToAll(node.defineEntity.dynamicFetchId, ctx[node.defineEntity.contextKey]);
+        }
+        node = node.parent;
+    }
+    addToAll('user', ctx.userId || ctx.userid);
+    return contextForEntityConfig;
+};
+
+class NodeSortingService {
+    constructor() { }
+    markEntityRootChildren(nodes) {
+        nodes.forEach((child) => {
+            child._entityRootChild = true;
+        });
+    }
+    nodeComparison(a, b) {
+        // set default order to the end if not defined
+        a.order = a.dxpOrder || a.order || '999';
+        b.order = b.dxpOrder || b.order || '999';
+        const orderA = isNaN(parseFloat(a?.order)) ? 999 : parseFloat(a.order);
+        const orderB = isNaN(parseFloat(b?.order)) ? 999 : parseFloat(b.order);
+        if (orderA < orderB) {
+            return -1;
+        }
+        else if (orderA > orderB) {
+            return 1;
+        }
+        // if orders are equal -> sort alphabetically by label
+        if (!a.label && !b.label) {
+            return 0; // both undefined, keep original order
+        }
+        else if (!a.label) {
+            return 1; // a has no label, goes after b
+        }
+        else if (!b.label) {
+            return -1; // b has no label, a goes before b
+        }
+        return a.label.localeCompare(b.label);
+    }
+    appendChildrenToSlot(nodes, slotNode, children) {
+        const slotIndex = nodes.indexOf(slotNode);
+        if (slotNode.category) {
+            const cat = slotNode.category.id ||
+                slotNode.category.label ||
+                (slotNode.category.length > 0
+                    ? slotNode.category
+                    : undefined);
+            if (cat) {
+                children.forEach((node) => {
+                    node.category = cat;
+                });
+            }
+        }
+        nodes.splice(slotIndex + 1, 0, ...children);
+    }
+    sortNodes(nodes) {
+        const entityRootNodes = [];
+        const slottedChildrenMap = {};
+        const otherChildren = [];
+        const slotNodes = [];
+        let defaultSlot;
+        nodes.forEach((node) => {
+            if (node._entityRootChild) {
+                entityRootNodes.push(node);
+                if (node.defineSlot) {
+                    slotNodes.push(node);
+                }
+                else if (node.defineSlot === '') {
+                    defaultSlot = node;
+                }
+            }
+            else if (node.navSlot) {
+                if (!slottedChildrenMap[node.navSlot]) {
+                    slottedChildrenMap[node.navSlot] = [];
+                }
+                slottedChildrenMap[node.navSlot].push(node);
+            }
+            else {
+                otherChildren.push(node);
+            }
+        });
+        const sortedNodes = [...entityRootNodes];
+        const sortedOther = otherChildren.sort(this.nodeComparison);
+        if (slotNodes.length > 0) {
+            slotNodes.forEach((slotNode) => {
+                if (slottedChildrenMap[slotNode.defineSlot]) {
+                    this.appendChildrenToSlot(sortedNodes, slotNode, slottedChildrenMap[slotNode.defineSlot].sort(this.nodeComparison));
+                    delete slottedChildrenMap[slotNode.defineSlot];
+                }
+            });
+        }
+        // collect unassigned slotted nodes and add to default slot
+        for (const slotId in slottedChildrenMap) {
+            if (Object.prototype.hasOwnProperty.call(slottedChildrenMap, slotId)) {
+                const unassignedSlotChildren = slottedChildrenMap[slotId];
+                sortedOther.push(...unassignedSlotChildren.sort(this.nodeComparison));
+            }
+        }
+        if (defaultSlot) {
+            this.appendChildrenToSlot(sortedNodes, defaultSlot, sortedOther);
+        }
+        else {
+            sortedNodes.push(...sortedOther);
+        }
+        // move nodes without categories to top
+        const singleNodes = [];
+        const catNodes = [];
+        sortedNodes.forEach((node) => {
+            (node.category ? catNodes : singleNodes).push(node);
+        });
+        return [...singleNodes, ...catNodes];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeSortingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeSortingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodeSortingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class ChildrenNodesService {
+    constructor() {
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.configService = inject(ConfigService);
+        this.nodeUtilsService = inject(NodeUtilsService);
+        this.nodeSortingService = inject(NodeSortingService);
+        this.customNodeProcessingService = inject(LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    async processChildrenForEntity(entityNode, childrenNodes, ctx) {
+        if (entityNode.defineEntity?.useBack &&
+            this.luigiCoreService.isFeatureToggleActive('navheader-up') &&
+            entityNode.navHeader) {
+            entityNode.navHeader.showUpLink = true;
+        }
+        this.addNavigationHeader(entityNode);
+        if (!childrenNodes) {
+            return [];
+        }
+        const entityContext = {};
+        const fetchContext = computeDynamicFetchContext(entityNode, ctx);
+        await Promise.all(Array.from(fetchContext.entries()).map(async ([dynamicFetchId, context]) => {
+            try {
+                entityContext[dynamicFetchId] = (await this.configService.getEntityConfig(dynamicFetchId, context)).entityContext;
+            }
+            catch (error) {
+                console.error(entityNode.defineEntity.id, 'does not exist', context);
+            }
+        }));
+        childrenNodes.forEach((child) => {
+            child.context = { ...child.context, entityContext };
+            child.onNodeActivation =
+                this.nodeUtilsService.retrieveGlobalHelpContext();
+        });
+        const nodes = await Promise.all(childrenNodes
+            .filter((child) => visibleForContext(child.context, child))
+            .map((child) => this.customNodeProcessingService?.processNode(child.context, child) || child));
+        return this.nodeSortingService.sortNodes(nodes);
+    }
+    addNavigationHeader(entityNode) {
+        if (entityNode.defineEntity) {
+            if (!entityNode.navHeader) {
+                entityNode.navHeader = {};
+            }
+            entityNode.navHeader.renderer = (containerElement, nodeItem, clickHandler, navHeader) => {
+                if (!containerElement || !navHeader?.label) {
+                    return;
+                }
+                const label = this.sanitizeString(navHeader.label);
+                const type = this.getSideNavigationHeaderType(navHeader.context, nodeItem);
+                containerElement.classList.add('entity-nav-header');
+                containerElement.innerHTML = `
+            <ui5-text class="entity-nav-header-type">${type}</ui5-text>
+            <ui5-title class="entity-nav-header-label" level="H6" size="H6">${label}</ui5-title>
+        `;
+            };
+        }
+    }
+    getSideNavigationHeaderType(nodeContext = {}, nodeItem) {
+        const dynamicFetchId = nodeItem.defineEntity?.dynamicFetchId || '';
+        let type = (nodeContext.entityContext?.[dynamicFetchId] || {}).type;
+        if (!type || typeof type !== 'string') {
+            type = nodeItem.defineEntity?.label || dynamicFetchId || 'Extension';
+        }
+        type = type.replace(/Id/i, '');
+        return type.at(0).toUpperCase() + type.slice(1);
+    }
+    sanitizeString(inputString) {
+        // Prevent XSS attacks by removing any tags
+        const tempSpan = document.createElement('span');
+        tempSpan.textContent = inputString;
+        return tempSpan.innerHTML;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ChildrenNodesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ChildrenNodesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: ChildrenNodesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class CommonGlobalLuigiNodesService {
+    constructor() {
+        this.i18nService = inject(I18nService);
+        this.errorComponentConfig = inject(ERROR_COMPONENT_CONFIG, {
+            optional: true,
+        });
+    }
+    getContentNotFoundGlobalNode() {
+        return [
+            {
+                pathSegment: 'error',
+                label: 'Content not found',
+                order: '1000',
+                hideFromNav: true,
+                children: [
+                    {
+                        pathSegment: ':id',
+                        entityType: EntityType.ENTITY_ERROR,
+                        hideFromNav: true,
+                        hideSideNav: true,
+                        viewUrl: '/assets/openmfp-portal-ui-wc.js#error-component',
+                        context: {
+                            error: {
+                                code: 404,
+                                errorComponentConfig: this.errorComponentConfig,
+                            },
+                            translationTable: this.i18nService.translationTable,
+                        },
+                        webcomponent: {
+                            selfRegistered: true,
+                        },
+                    },
+                ],
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CommonGlobalLuigiNodesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CommonGlobalLuigiNodesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: CommonGlobalLuigiNodesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class NodesProcessingService {
+    constructor() {
+        this.nodeContextProcessingService = inject(LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN, { optional: true });
+        this.luigiNodesService = inject(LuigiNodesService);
+        this.localConfigurationService = inject(LocalConfigurationServiceImpl);
+        this.nodeSortingService = inject(NodeSortingService);
+        this.childrenNodesService = inject(ChildrenNodesService);
+        this.commonGlobalLuigiNodesService = inject(CommonGlobalLuigiNodesService);
+        this.customNodeProcessingService = inject(LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN, { optional: true });
+        this.customGlobalNodesService = inject(LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    async processNodes(childrenByEntity) {
+        const globalNodes = [
+            ...(childrenByEntity[EntityType.GLOBAL] || []),
+            ...(childrenByEntity[EntityType.GLOBAL_TOPNAV] || []),
+            ...((await this.customGlobalNodesService?.getCustomGlobalNodes()) || []),
+            ...this.commonGlobalLuigiNodesService.getContentNotFoundGlobalNode(),
+        ];
+        globalNodes.forEach((node) => {
+            node.context = { ...node.context };
+            node.globalNav = this.isGlobalNavNode(node);
+            this.applyEntityChildrenRecursively(node, childrenByEntity, '');
+        });
+        globalNodes.sort(this.nodeSortingService.nodeComparison);
+        return globalNodes;
+    }
+    isGlobalNavNode(node) {
+        return !node.hideFromNav && node.entityType === EntityType.GLOBAL;
+    }
+    applyEntityChildrenRecursively(node, childrenByEntity, parentEntityPath) {
+        if (Array.isArray(node.children)) {
+            this.nodeSortingService.markEntityRootChildren(node.children);
+            node._portalDirectChildren = node.children;
+        }
+        const directChildren = node._portalDirectChildren || [];
+        if (node.defineEntity) {
+            this.processNodeDefineEntity(node, childrenByEntity, parentEntityPath, directChildren);
+        }
+        else {
+            directChildren.forEach((child) => {
+                this.applyEntityChildrenRecursively(child, childrenByEntity, parentEntityPath);
+            });
+            node.children = async (ctx) => await Promise.all(directChildren
+                .filter((child) => visibleForContext(ctx, child))
+                .map((child) => this.customNodeProcessingService?.processNode(ctx, child) ||
+                child));
+        }
+        if (node.virtualTree) {
+            node.children = undefined;
+        }
+    }
+    processNodeDefineEntity(node, childrenByEntity, parentEntityPath, directChildren) {
+        let newEntityPath = parentEntityPath;
+        if (parentEntityPath?.length > 0) {
+            newEntityPath = parentEntityPath + '.' + node.defineEntity.id;
+        }
+        else {
+            newEntityPath = node.defineEntity.id;
+        }
+        node.children = (ctx) => {
+            return this.entityChildrenProvider(node, ctx, childrenByEntity, directChildren, newEntityPath);
+        };
+        this.processCompoundNode(node, childrenByEntity, newEntityPath);
+    }
+    processCompoundNode(node, childrenByEntity, newEntityPath) {
+        if (node.compound) {
+            if (!node.compound._staticChildren) {
+                node.compound._staticChildren = node.compound.children || [];
+            }
+            const additionalChildren = childrenByEntity[newEntityPath + '::compound'] || [];
+            let children = [
+                ...node.compound._staticChildren,
+                ...additionalChildren,
+            ].sort(this.nodeSortingService.nodeComparison);
+            Object.defineProperty(node.compound, 'children', {
+                set: (newValue) => (children = newValue),
+                get: () => {
+                    children.forEach((child) => {
+                        child.context.entityContext = {
+                            ...child.context.entityContext,
+                            ...node.context?.entityContext,
+                        };
+                    });
+                    return children.filter((child) => visibleForContext(child.context, child));
+                },
+                configurable: true,
+            });
+        }
+    }
+    entityChildrenProvider(entityNode, ctx, childrenByEntity, directChildren, entityPath) {
+        return new Promise(async (resolve, reject) => {
+            const entityTypeId = entityPath || entityNode?.defineEntity?.id;
+            const entityId = ctx[entityNode?.defineEntity?.contextKey];
+            const staticChildren = [
+                ...(directChildren || []),
+                ...(childrenByEntity[entityTypeId] || []),
+            ];
+            await this.nodeContextProcessingService?.processNodeContext(entityId, entityNode, ctx);
+            if (!entityTypeId || !entityNode.defineEntity?.dynamicFetchId) {
+                const serverAndLocalNodes = await this.localConfigurationService.replaceServerNodesWithLocalOnes(staticChildren, [entityPath]);
+                const childrenList = await this.createChildrenList(entityNode, ctx, childrenByEntity, entityPath, serverAndLocalNodes);
+                resolve(childrenList);
+                return;
+            }
+            let dynamicRetrievedChildren, staticRetrievedChildren;
+            try {
+                const fetchContext = computeDynamicFetchContext(entityNode, ctx);
+                const dynamicFetchId = entityNode.defineEntity.dynamicFetchId;
+                dynamicRetrievedChildren =
+                    await this.luigiNodesService.retrieveEntityChildren(entityNode.defineEntity, fetchContext.get(dynamicFetchId));
+                const serverAndLocalNodes = await this.localConfigurationService.replaceServerNodesWithLocalOnes(dynamicRetrievedChildren, [entityPath]);
+                dynamicRetrievedChildren = [...staticChildren, ...serverAndLocalNodes];
+                staticRetrievedChildren = staticChildren;
+            }
+            catch (error) {
+                dynamicRetrievedChildren = staticChildren;
+                staticRetrievedChildren = null;
+            }
+            const childrenList = await this.createChildrenList(entityNode, ctx, childrenByEntity, entityPath, dynamicRetrievedChildren, staticRetrievedChildren);
+            resolve(childrenList);
+        });
+    }
+    createChildrenList(entityNode, ctx, childrenByEntity, entityPath, children, staticChildren) {
+        const entityRootChildren = staticChildren ? [] : children;
+        let mergedChildrenByEntity = childrenByEntity;
+        if (staticChildren) {
+            const entityChildrenByEntity = {};
+            children?.forEach((child) => {
+                if (child.entityType === entityPath ||
+                    child.entityType === EntityType.ENTITY_ERROR ||
+                    staticChildren.includes(child)) {
+                    entityRootChildren.push(child);
+                }
+                else if (child.entityType) {
+                    if (!entityChildrenByEntity[child.entityType]) {
+                        entityChildrenByEntity[child.entityType] = [];
+                    }
+                    entityChildrenByEntity[child.entityType].push(child);
+                }
+                else {
+                    console.warn('Ignored entity child, no entity type defined', child);
+                }
+            });
+            mergedChildrenByEntity = { ...childrenByEntity };
+            Object.keys(entityChildrenByEntity).forEach((key) => {
+                const existingNodes = mergedChildrenByEntity[key];
+                mergedChildrenByEntity[key] = existingNodes
+                    ? [...existingNodes, ...entityChildrenByEntity[key]]
+                    : entityChildrenByEntity[key];
+            });
+        }
+        entityRootChildren.forEach((child) => {
+            this.applyEntityChildrenRecursively(child, mergedChildrenByEntity, entityPath);
+        });
+        return this.childrenNodesService.processChildrenForEntity(entityNode, entityRootChildren, ctx);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodesProcessingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodesProcessingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NodesProcessingService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class NavigationConfigService {
+    constructor(configService, luigiCoreService, luigiNodesService, intentNavigationService, navigationGlobalContextConfigService, userProfileConfigService, appSwitcherConfigService, nodeChangeHookConfigService, nodesProcessingService, headerBarService) {
+        this.configService = configService;
+        this.luigiCoreService = luigiCoreService;
+        this.luigiNodesService = luigiNodesService;
+        this.intentNavigationService = intentNavigationService;
+        this.navigationGlobalContextConfigService = navigationGlobalContextConfigService;
+        this.userProfileConfigService = userProfileConfigService;
+        this.appSwitcherConfigService = appSwitcherConfigService;
+        this.nodeChangeHookConfigService = nodeChangeHookConfigService;
+        this.nodesProcessingService = nodesProcessingService;
+        this.headerBarService = headerBarService;
+    }
+    async getNavigationConfig(childrenByEntity, envConfig) {
+        const allNodes = Object.values(childrenByEntity).reduce((accumulator, value) => accumulator.concat(value), []);
+        const portalConfig = await this.configService.getPortalConfig();
+        this.initFeatureToggles(portalConfig.featureToggles, envConfig);
+        const context = await this.navigationGlobalContextConfigService.getGlobalContext();
+        const luigiNodes = await this.nodesProcessingService.processNodes(childrenByEntity);
+        return {
+            nodes: luigiNodes,
+            viewGroupSettings: this.buildViewGroups(allNodes),
+            appSwitcher: this.appSwitcherConfigService?.getAppSwitcher(luigiNodes),
+            globalContext: context,
+            profile: await this.userProfileConfigService?.getProfile(),
+            addNavHrefs: true,
+            contextSwitcher: undefined,
+            nodeAccessibilityResolver: this.luigiNodesService.nodePolicyResolver,
+            validWebcomponentUrls: envConfig.validWebcomponentUrls,
+            intentMapping: this.intentNavigationService.buildIntentMappings(allNodes),
+            nodeChangeHook: function (prevNode, nextNode) {
+                this.nodeChangeHookConfigService?.nodeChangeHook(prevNode, nextNode);
+            }.bind(this),
+            breadcrumbs: await this.headerBarService.getConfig(),
+        };
+    }
+    initFeatureToggles(configFeatureToggles, envConfig) {
+        if (envConfig.uiOptions.includes('enableFeatureToggleSetting')) {
+            const featureToggleSettings = featureToggleLocalStorage.read();
+            this.luigiCoreService.setFeatureToggles({
+                ...configFeatureToggles,
+                ...featureToggleSettings,
+            });
+            return;
+        }
+        this.luigiCoreService.setFeatureToggles(configFeatureToggles);
+    }
+    buildViewGroups(nodes) {
+        const viewGroups = {};
+        nodes.forEach((node) => {
+            if (node.viewGroup && node._preloadUrl) {
+                viewGroups[node.viewGroup] = {
+                    preloadUrl: node._preloadUrl,
+                    requiredIFramePermissions: node._requiredIFramePermissionsForViewGroup,
+                };
+            }
+        });
+        return viewGroups;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationConfigService, deps: [{ token: ConfigService }, { token: LuigiCoreService }, { token: LuigiNodesService }, { token: IntentNavigationService }, { token: GlobalContextConfigService }, { token: LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN, optional: true }, { token: LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN, optional: true }, { token: LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN, optional: true }, { token: NodesProcessingService }, { token: HeaderBarService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: NavigationConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: ConfigService }, { type: LuigiCoreService }, { type: LuigiNodesService }, { type: IntentNavigationService }, { type: GlobalContextConfigService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN]
+                }] }, { type: NodesProcessingService }, { type: HeaderBarService }] });
+
+class LifecycleHooksConfigService {
+    constructor() {
+        this.authConfigService = inject(AuthConfigService);
+        this.customMessageListenersService = inject(CustomMessageListenersService);
+        this.envConfigService = inject(EnvConfigService);
+        this.i18nService = inject(I18nService);
+        this.luigiNodesService = inject(LuigiNodesService);
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.routingConfigService = inject(RoutingConfigServiceImpl);
+        this.navigationConfigService = inject(NavigationConfigService);
+        this.userSettingsConfigService = inject(UserSettingsConfigService);
+        this.staticSettingsConfigService = inject(StaticSettingsConfigServiceImpl);
+        this.globalSearchConfigService = inject(LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN, { optional: true });
+    }
+    getLifecycleHooksConfig() {
+        return {
+            luigiAfterInit: async () => {
+                await this.constructLuigiConfiguration();
+            },
+        };
+    }
+    async constructLuigiConfiguration() {
+        this.i18nService.afterInit();
+        const envConfig = await this.envConfigService.getEnvConfig();
+        let childrenByEntity;
+        try {
+            childrenByEntity =
+                await this.luigiNodesService.retrieveChildrenByEntity();
+        }
+        catch (e) {
+            console.error('Error retrieving Luigi navigation nodes', e);
+            this.openErrorDialog();
+            return;
+        }
+        const config = {
+            auth: await this.authConfigService.getAuthConfig(),
+            settings: await this.staticSettingsConfigService.getStaticSettingsConfig(),
+            communication: this.customMessageListenersService.getMessageListeners(),
+            navigation: await this.navigationConfigService.getNavigationConfig(childrenByEntity, envConfig),
+            routing: this.routingConfigService.getRoutingConfig(),
+            userSettings: await this.userSettingsConfigService.getUserSettings(childrenByEntity),
+            globalSearch: this.globalSearchConfigService?.getGlobalSearchConfig(),
+        };
+        this.luigiCoreService.setConfig(config);
+        this.luigiCoreService.ux().hideAppLoadingIndicator();
+    }
+    openErrorDialog() {
+        const appTitle = this.luigiCoreService.config.settings.header.title;
+        this.luigiCoreService.showAlert({
+            text: $localize `There was an error loading the ${appTitle}`,
+            type: 'error',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LifecycleHooksConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LifecycleHooksConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LifecycleHooksConfigService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class LuigiComponent {
+    constructor() {
+        this.lifecycleHooksConfigService = inject(LifecycleHooksConfigService);
+        this.luigiCoreService = inject(LuigiCoreService);
+        this.authService = inject(AuthService);
+        this.routingConfigService = inject(RoutingConfigServiceImpl);
+        this.authConfigService = inject(AuthConfigService);
+        this.staticSettingsConfigService = inject(StaticSettingsConfigServiceImpl);
+    }
+    async ngOnInit() {
+        try {
+            this.luigiCoreService.setConfig({
+                auth: await this.authConfigService.getAuthConfig(),
+                routing: this.routingConfigService.getInitialRoutingConfig(),
+                lifecycleHooks: this.lifecycleHooksConfigService.getLifecycleHooksConfig(),
+                settings: await this.staticSettingsConfigService.getStaticSettingsConfig(),
+            });
+            this.luigiCoreService.setAuthData(this.authService.getAuthData());
+        }
+        catch (e) {
+            console.error(`Luigi Component init failed: ${e.toString()}`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.9", type: LuigiComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: LuigiComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    standalone: true,
+                }]
+        }] });
+
+document.body.classList.add('ui5-content-density-compact');
+class PortalComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: PortalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.9", type: PortalComponent, isStandalone: true, selector: "app-portal", ngImport: i0, template: "<div class=\"fd-page__content\">\n  <router-outlet></router-outlet>\n</div>\n", styles: [".fd-page__header{padding-left:1.5rem}.settings-icon-active{color:#0064d9!important}.local-development-settings-indication{position:absolute;top:-4px;right:-4px;width:12px;height:12px;font-size:12px}.entity-nav-header{padding-left:var(--fdNavigation_Padding_X);padding-right:var(--fdNavigation_Padding_X);padding-bottom:1.25rem!important}.entity-nav-header-type{font-size:12px}.entity-nav-header-label{color:var(--sapAccentColor6);padding-top:8px}.fd-container.fd-form-layout-grid-container .fd-row .fd-col{white-space:inherit!important}\n"], dependencies: [{ kind: "directive", type: RouterOutlet, selector: "router-outlet", inputs: ["name", "routerOutletData"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: PortalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-portal', standalone: true, imports: [RouterOutlet], encapsulation: ViewEncapsulation.None, template: "<div class=\"fd-page__content\">\n  <router-outlet></router-outlet>\n</div>\n", styles: [".fd-page__header{padding-left:1.5rem}.settings-icon-active{color:#0064d9!important}.local-development-settings-indication{position:absolute;top:-4px;right:-4px;width:12px;height:12px;font-size:12px}.entity-nav-header{padding-left:var(--fdNavigation_Padding_X);padding-right:var(--fdNavigation_Padding_X);padding-bottom:1.25rem!important}.entity-nav-header-type{font-size:12px}.entity-nav-header-label{color:var(--sapAccentColor6);padding-top:8px}.fd-container.fd-form-layout-grid-container .fd-row .fd-col{white-space:inherit!important}\n"] }]
+        }] });
+
+const portalRouts = [
+    { path: 'logout', component: LogoutComponent },
+    { path: '', component: LuigiComponent },
+    { path: '**', component: LuigiComponent },
+];
+
+class CustomReuseStrategy {
+    shouldDetach(route) {
+        // Optionally, you can customize which routes should be detached (stored)
+        return false; // Not detaching any routes for now
+    }
+    store(route, handle) {
+        // Optional: Store the detached route here if needed
+    }
+    shouldAttach(route) {
+        // Optional: Specify which routes to reattach
+        return false; // Not attaching any routes for now
+    }
+    retrieve(route) {
+        // Optional: Retrieve the stored route if needed
+        return null; // Returning null means no route is retrieved
+    }
+    shouldReuseRoute(future, curr) {
+        return (future.routeConfig === curr.routeConfig ||
+            future.routeConfig?.component === curr.routeConfig?.component);
+    }
+}
+
+function providePortal(options = {}) {
+    const providers = [
+        provideHttpClient(),
+        provideZoneChangeDetection({ eventCoalescing: true }),
+        provideBootstrap(),
+        provideSessionRefresh(),
+        provideNavigationTracker(),
+        provideLanguageServices(),
+        provideRouter(portalRouts),
+        { provide: RouteReuseStrategy, useClass: CustomReuseStrategy },
+        ...addOptionalProviders(options),
+    ];
+    return makeEnvironmentProviders(providers);
+}
+const addOptionalProviders = (options) => {
+    const providers = [];
+    (options.customMessageListeners || []).forEach((customMessageListenerClass) => providers.push({
+        provide: LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN,
+        multi: true,
+        useClass: customMessageListenerClass,
+    }));
+    providers.push({
+        provide: LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN,
+        useClass: options.appSwitcherConfigService || AppSwitcherConfigServiceImpl,
+    });
+    if (options.userProfileConfigService) {
+        providers.push({
+            provide: LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.userProfileConfigService,
+        });
+    }
+    if (options.luigiExtendedGlobalContextConfigService) {
+        providers.push({
+            provide: LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.luigiExtendedGlobalContextConfigService,
+        });
+    }
+    if (options.nodeChangeHookConfigService) {
+        providers.push({
+            provide: LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN,
+            useClass: options.nodeChangeHookConfigService,
+        });
+    }
+    if (options.nodeContextProcessingService) {
+        providers.push({
+            provide: LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN,
+            useClass: options.nodeContextProcessingService,
+        });
+    }
+    if (options.localConfigurationService) {
+        providers.push({
+            provide: LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN,
+            useClass: options.localConfigurationService,
+        });
+    }
+    if (options.staticSettingsConfigService) {
+        providers.push({
+            provide: LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.staticSettingsConfigService,
+        });
+    }
+    if (options.luigiAuthEventsCallbacksService) {
+        providers.push({
+            provide: LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN,
+            useClass: options.luigiAuthEventsCallbacksService,
+        });
+    }
+    if (options.customNodeProcessingService) {
+        providers.push({
+            provide: LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN,
+            useClass: options.customNodeProcessingService,
+        });
+    }
+    if (options.customGlobalNodesService) {
+        providers.push({
+            provide: LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN,
+            useClass: options.customGlobalNodesService,
+        });
+    }
+    if (options.themingService) {
+        providers.push({
+            provide: THEMING_SERVICE,
+            useClass: options.themingService,
+        });
+    }
+    if (options.globalSearchConfigService) {
+        providers.push({
+            provide: LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.globalSearchConfigService,
+        });
+    }
+    if (options.errorComponentConfig) {
+        providers.push({
+            provide: ERROR_COMPONENT_CONFIG,
+            useValue: options.errorComponentConfig,
+        });
+    }
+    if (options.headerBarConfigService) {
+        providers.push({
+            provide: HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.headerBarConfigService,
+        });
+    }
+    if (options.routingConfigService) {
+        providers.push({
+            provide: LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN,
+            useClass: options.routingConfigService,
+        });
+    }
+    return providers;
+};
+
+/*
+ * Public API Surface of lib
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppSwitcherConfigServiceImpl, AuthConfigService, AuthEvent, AuthService, ConfigService, CustomMessageListenersService, CustomReuseStrategy, ERROR_COMPONENT_CONFIG, EntityType, EnvConfigService, GlobalContextConfigService, HEADER_BAR_CONFIG_SERVICE_INJECTION_TOKEN, HeaderBarService, I18nService, IframeService, LOCAL_CONFIGURATION_SERVICE_INJECTION_TOKEN, LUIGI_APP_SWITCHER_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_AUTH_EVENTS_CALLBACKS_SERVICE_INJECTION_TOKEN, LUIGI_BREADCRUMB_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_CUSTOM_MESSAGE_LISTENERS_INJECTION_TOKEN, LUIGI_CUSTOM_NODE_CONTEXT_PROCESSING_SERVICE_INJECTION_TOKEN, LUIGI_CUSTOM_NODE_PROCESSING_SERVICE_INJECTION_TOKEN, LUIGI_EXTENDED_GLOBAL_CONTEXT_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_GLOBAL_SEARCH_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_NODES_CUSTOM_GLOBAL_SERVICE_INJECTION_TOKEN, LUIGI_NODE_CHANGE_HOOK_SERVICE_INJECTION_TOKEN, LUIGI_ROUTING_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_STATIC_SETTINGS_CONFIG_SERVICE_INJECTION_TOKEN, LUIGI_USER_PROFILE_CONFIG_SERVICE_INJECTION_TOKEN, LocalConfigurationServiceImpl, LocalNodesService, LocalStorageKeys, LoginEventService, LoginEventType, LuigiCoreService, LuigiNodesService, NetworkVisibility, NodeUtilsService, PortalComponent, RequestHeadersService, RoutingConfigServiceImpl, SessionRefreshService, StaticSettingsConfigServiceImpl, THEMING_SERVICE, UserSettingsConfigService, featureToggleLocalStorage, localDevelopmentSettingsLocalStorage, matchesJMESPath, providePortal, userSettingsLocalStorage };
+//# sourceMappingURL=openmfp-portal-ui-lib.mjs.map