@elite.framework/ng.core 2.0.19 → 2.0.22

package/fesm2022/elite.framework-ng.core-services.mjs

@@ -1,27 +1,68 @@
 import * as i0 from '@angular/core';
-import { inject, Inject, Injectable, InjectionToken, PLATFORM_ID, Optional } from '@angular/core';
-import { throwError, catchError, map, BehaviorSubject } from 'rxjs';
+import { Injectable, inject, Inject, InjectionToken, PLATFORM_ID, Optional, isDevMode, SkipSelf, effect, signal, Injector } from '@angular/core';
+import { throwError, catchError, map as map$1, Subject, BehaviorSubject, combineLatest, from, switchMap as switchMap$1, Subscription, of, timer, firstValueFrom, noop, lastValueFrom } from 'rxjs';
 import * as i1 from '@angular/common/http';
-import { HttpParams } from '@angular/common/http';
-import { ENVIRONMENT, CORE_OPTIONS } from '@elite.framework/ng.core/tokens';
-import { isPlatformBrowser, DOCUMENT } from '@angular/common';
+import { HttpParams, HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { CORE_OPTIONS, INCUDE_LOCALIZATION_RESOURCES_TOKEN, localizations$, DISABLE_PROJECT_NAME, OTHERS_GROUP, TENANT_KEY, TENANT_NOT_FOUND_BY_NAME, CHECK_AUTHENTICATION_STATE_FN_KEY, APP_INIT_ERROR_HANDLERS } from '@elite.framework/ng.core/tokens';
+import { InternalStore, isFunction, transformStringToArray, isPlainObject, createLocalizer, createLocalizerWithFallback, interpolate, createTreeFromList, BaseTreeNode, createGroupMap, pushValueTo, deepMerge, createTokenParser } from '@elite.framework/ng.core/utils';
+import { map, switchMap, tap, take, filter, mapTo, takeUntil, catchError as catchError$1 } from 'rxjs/operators';
+import { isPlatformBrowser, DOCUMENT, registerLocaleData } from '@angular/common';
 import * as i1$1 from '@ngx-translate/core';
 import Swal from 'sweetalert2';
 import * as i2 from '@angular/router';
-import { RouterStateSnapshot } from '@angular/router';
-import { DEFAULT_REDIRECT_KEY } from '@elite.framework/ng.core/models';
-import { isFunction, transformStringToArray, isPlainObject } from '@elite.framework/ng.core/utils';
+import { RouterStateSnapshot, TitleStrategy, NavigationStart, NavigationError, NavigationEnd, NavigationCancel, Router } from '@angular/router';
+import { DEFAULT_REDIRECT_KEY, NavItem, UserMenu } from '@elite.framework/ng.core/models';
+import compare from 'just-compare';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { Title } from '@angular/platform-browser';
+import clone from 'just-clone';
+import { AuthService } from '@elite.framework/ng.core/abstracts';
+
+const mapToApiUrl = (key) => (apis) => ((key && apis[key]) || apis.default).url || apis.default.url;
+const mapToIssuer = (issuer) => {
+    if (!issuer) {
+        return issuer;
+    }
+    return issuer.endsWith('/') ? issuer : issuer + '/';
+};
+class EnvironmentService {
+    store = new InternalStore({});
+    get createOnUpdateStream() {
+        return this.store.sliceUpdate;
+    }
+    getEnvironment$() {
+        return this.store.sliceState(state => state);
+    }
+    getEnvironment() {
+        return this.store.state;
+    }
+    getApiUrl(key) {
+        return mapToApiUrl(key)(this.store.state?.apis);
+    }
+    getApiUrl$(key) {
+        return this.store.sliceState(state => state.apis).pipe(map(mapToApiUrl(key)));
+    }
+    setState(environment) {
+        this.store.set(environment);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class RestService {
     options;
     http;
-    environment = inject(ENVIRONMENT);
+    environment = inject(EnvironmentService);
     constructor(options, http) {
         this.options = options;
         this.http = http;
     }
     getApiFromStore(apiName) {
-        return this.environment.apiUrl;
+        return this.environment.getApiUrl(apiName);
     }
     handleError(err) {
         // this.httpErrorReporter.reportError(err);
@@ -98,7 +139,7 @@ class BaseService {
             url: url,
             params: params,
         }, { apiName: this.apiName })
-            .pipe(map(response => response));
+            .pipe(map$1(response => response));
     };
     get = (id) => this.restService.request({
         method: 'GET',
@@ -536,32 +577,296 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
 
-class PermissionsService {
-    _permissions$ = new BehaviorSubject(new Set());
-    // Load permissions (e.g., from API or token claims)
-    setPermissions(permissions) {
-        this._permissions$.next(new Set(permissions));
+class ApplicationLocalizationService {
+    restService;
+    apiName = 'framework';
+    get = (input, config) => this.restService.request({
+        method: 'GET',
+        url: '/api/asp-net-core/framework-application-localizations/get',
+        params: { cultureName: input.cultureName, onlyDynamics: input.onlyDynamics },
+    }, { apiName: this.apiName, ...config });
+    constructor(restService) {
+        this.restService = restService;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationLocalizationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationLocalizationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationLocalizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RestService }] });
+
+class ApplicationConfigurationService {
+    restService;
+    // apiName = 'framework';
+    apiName = '';
+    get = (options, config) => this.restService.request({
+        method: 'GET',
+        url: '/api/framework/application-configuration',
+        params: { includeLocalizationResources: options.includeLocalizationResources },
+    }, { apiName: this.apiName, ...config });
+    constructor(restService) {
+        this.restService = restService;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationConfigurationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationConfigurationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ApplicationConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RestService }] });
+
+class ConfigStateService {
+    abpConfigService;
+    applicationLocalizationService;
+    includeLocalizationResources;
+    updateSubject = new Subject();
+    store = new InternalStore({});
+    uiCultureFromAuthCodeFlow;
+    setState(config) {
+        this.store.set(config);
+    }
+    get createOnUpdateStream() {
+        return this.store.sliceUpdate;
+    }
+    constructor(abpConfigService, applicationLocalizationService, includeLocalizationResources) {
+        this.abpConfigService = abpConfigService;
+        this.applicationLocalizationService = applicationLocalizationService;
+        this.includeLocalizationResources = includeLocalizationResources;
+        this.initUpdateStream();
+    }
+    initUpdateStream() {
+        this.updateSubject
+            .pipe(switchMap(() => this.abpConfigService.get({
+            includeLocalizationResources: !!this.includeLocalizationResources,
+        })))
+            .pipe(switchMap(appState => this.getLocalizationAndCombineWithAppState(appState)))
+            .subscribe(res => this.store.set(res));
+    }
+    getLocalizationAndCombineWithAppState(appState) {
+        // debugger
+        if (!appState.localization.currentCulture.cultureName) {
+            throw new Error('culture name should defined');
+        }
+        const cultureName = this.uiCultureFromAuthCodeFlow ?? appState.localization.currentCulture.cultureName;
+        return this.getlocalizationResource(cultureName).pipe(map(result => ({ ...appState, localization: { ...appState.localization, ...result } })), tap(() => (this.uiCultureFromAuthCodeFlow = undefined)));
     }
-    getPermissions() {
-        return Array.from(this._permissions$.value);
+    getlocalizationResource(cultureName) {
+        return this.applicationLocalizationService.get({
+            cultureName: cultureName,
+            onlyDynamics: false,
+        });
     }
-    // Synchronous check
-    isGranted(permissionName) {
-        return this._permissions$.value.has(permissionName);
+    refreshAppState() {
+        this.updateSubject.next();
+        return this.createOnUpdateStream(state => state).pipe(take(1));
     }
-    // Async check (optional if needed for guards or effects)
-    isGrantedAsync(permissionName) {
-        return new Promise(resolve => {
-            resolve(this.isGranted(permissionName));
+    refreshLocalization(lang) {
+        if (this.includeLocalizationResources) {
+            return this.refreshAppState().pipe(map(() => null));
+        }
+        return this.getlocalizationResource(lang)
+            .pipe(tap(result => this.store.patch({ localization: { ...this.store.state.localization, ...result } })))
+            .pipe(map(() => { return null; }));
+    }
+    getOne$(key) {
+        return this.store.sliceState(state => state[key]);
+    }
+    getOne(key) {
+        return this.store.state[key];
+    }
+    getAll$() {
+        return this.store.sliceState(state => state);
+    }
+    getAll() {
+        return this.store.state;
+    }
+    getDeep$(keys) {
+        keys = splitKeys(keys);
+        return this.store
+            .sliceState(state => state)
+            .pipe(map(state => {
+            return keys.reduce((acc, val) => {
+                if (acc) {
+                    return acc[val];
+                }
+                return undefined;
+            }, state);
+        }));
+    }
+    getDeep(keys) {
+        keys = splitKeys(keys);
+        return keys.reduce((acc, val) => {
+            if (acc) {
+                return acc[val];
+            }
+            return undefined;
+        }, this.store.state);
+    }
+    getFeature(key) {
+        return this.store.state.features?.values?.[key];
+    }
+    getFeature$(key) {
+        return this.store.sliceState(state => state.features?.values?.[key]);
+    }
+    getFeatures(keys) {
+        const { features } = this.store.state;
+        if (!features)
+            return null;
+        return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
+    }
+    getFeatures$(keys) {
+        return this.store.sliceState(({ features }) => {
+            if (!features?.values)
+                return null;
+            return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionsService, providedIn: 'root' });
+    isFeatureEnabled(key, features) {
+        return features.values[key] === 'true';
+    }
+    getFeatureIsEnabled(key) {
+        return this.isFeatureEnabled(key, this.store.state.features);
+    }
+    getFeatureIsEnabled$(key) {
+        return this.store.sliceState(state => this.isFeatureEnabled(key, state.features));
+    }
+    getSetting(key) {
+        return this.store.state.setting?.values?.[key];
+    }
+    getSetting$(key) {
+        return this.store.sliceState(state => state.setting?.values?.[key]);
+    }
+    getSettings(keyword) {
+        const settings = this.store.state.setting?.values || {};
+        if (!keyword)
+            return settings;
+        const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+        return keysFound.reduce((acc, key) => {
+            acc[key] = settings[key];
+            return acc;
+        }, {});
+    }
+    getSettings$(keyword) {
+        return this.store
+            .sliceState(state => state.setting?.values)
+            .pipe(map((settings = {}) => {
+            if (!keyword)
+                return settings;
+            const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+            return keysFound.reduce((acc, key) => {
+                acc[key] = settings[key];
+                return acc;
+            }, {});
+        }));
+    }
+    getGlobalFeatures() {
+        return this.store.state.globalFeatures;
+    }
+    getGlobalFeatures$() {
+        return this.store.sliceState(state => state.globalFeatures);
+    }
+    isGlobalFeatureEnabled(key, globalFeatures) {
+        const features = globalFeatures.enabledFeatures || [];
+        return features.some(f => key === f);
+    }
+    getGlobalFeatureIsEnabled(key) {
+        return this.isGlobalFeatureEnabled(key, this.store.state.globalFeatures);
+    }
+    getGlobalFeatureIsEnabled$(key) {
+        return this.store.sliceState(state => this.isGlobalFeatureEnabled(key, state.globalFeatures));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ConfigStateService, deps: [{ token: ApplicationConfigurationService }, { token: ApplicationLocalizationService }, { token: INCUDE_LOCALIZATION_RESOURCES_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ConfigStateService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: ConfigStateService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: ApplicationConfigurationService }, { type: ApplicationLocalizationService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INCUDE_LOCALIZATION_RESOURCES_TOKEN]
+                }] }] });
+function splitKeys(keys) {
+    if (typeof keys === 'string') {
+        keys = keys.split('.');
+    }
+    if (!Array.isArray(keys)) {
+        throw new Error('The argument must be a dot string or an string array.');
+    }
+    return keys;
+}
+
+class PermissionCheckerService {
+    configState;
+    constructor(configState) {
+        this.configState = configState;
+    }
+    isPolicyGranted(key, grantedPolicies) {
+        if (!key)
+            return true;
+        const orRegexp = /\|\|/g;
+        const andRegexp = /&&/g;
+        // TODO: Allow combination of ANDs & ORs
+        if (orRegexp.test(key)) {
+            const keys = key.split('||').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
+        }
+        else if (andRegexp.test(key)) {
+            const keys = key.split('&&').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
+        }
+        return this.getPolicy(key, grantedPolicies);
+    }
+    getGrantedPolicy$(key) {
+        return this.getStream().pipe(map$1(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
+    }
+    isGrantedAsync(permissionName) {
+        if (!permissionName)
+            return true;
+        return this.getGrantedPolicy$(permissionName);
+    }
+    isGranted(permissionName) {
+        if (!permissionName)
+            return true;
+        return this.getGrantedPolicy(permissionName);
+    }
+    getGrantedPolicy(key) {
+        const policies = this.getSnapshot();
+        return this.isPolicyGranted(key, policies);
+    }
+    getStream() {
+        return this.configState.getAll$().pipe(map$1(this.mapToPolicies));
+    }
+    getSnapshot() {
+        return this.mapToPolicies(this.configState.getAll());
+    }
+    mapToPolicies(applicationConfiguration) {
+        return applicationConfiguration?.auth?.grantedPolicies || {};
+    }
+    getPolicy(key, grantedPolicies) {
+        return grantedPolicies[key] || false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ConfigStateService }] });
 
 const ngxPermissionsGuard = (route, state) => {
     const guard = inject(NgxPermissionsGuard);
@@ -620,7 +925,7 @@ class NgxPermissionsGuard {
         // EXCEPT check
         if (permissions.except?.length) {
             for (const perm of permissions.except) {
-                if (await this.permissions.isGrantedAsync(perm)) {
+                if (await this.permissions.isGranted(perm)) {
                     this.handleRedirect(permissions, perm, route, state);
                     return false;
                 }
@@ -671,13 +976,13 @@ class NgxPermissionsGuard {
             console.warn('Unknown redirect type', resolvedRedirect);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, deps: [{ token: PermissionsService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, deps: [{ token: PermissionCheckerService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: PermissionsService }, { type: i2.Router }] });
+        }], ctorParameters: () => [{ type: PermissionCheckerService }, { type: i2.Router }] });
 
 // logger.interface.ts
 var LogLevel;
@@ -693,13 +998,13 @@ var LogLevel;
 // Remove the separate LoggerConfig interface since we're using EnvironmentConfig
 // and extend EnvironmentConfig to include logger-specific properties
 class LoggerService {
-    environment;
     level = LogLevel.DEBUG;
     enableConsole = true;
     prefix = '[App]';
     timestamp = true;
-    constructor(environment) {
-        this.environment = environment;
+    environmentService = inject(EnvironmentService);
+    environment = this.environmentService?.getEnvironment();
+    constructor() {
         // Use environment configuration if provided
         if (this.environment) {
             this.configureFromEnvironment(this.environment);
@@ -786,7 +1091,7 @@ class LoggerService {
                 // this.sendToLogRocket(level, message, args);
             }
             // Send to backend if apiUrl is available
-            if (this.environment?.apiUrl) {
+            if (this.environment?.apis.default.url) {
                 // this.http.post(`${this.environment.apiUrl}/logs`, {
                 //   level, message, args, timestamp: new Date()
                 // }).subscribe();
@@ -797,7 +1102,7 @@ class LoggerService {
             console.error('Failed to send log to external service:', error);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, deps: [{ token: ENVIRONMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, decorators: [{
@@ -805,12 +1110,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [ENVIRONMENT]
-                }] }] });
+        }], ctorParameters: () => [] });
 
 class IdParserService {
     /**
@@ -1274,9 +1574,1218 @@ class QueryParser {
     }
 }
 
+class SessionStateService {
+    configState;
+    localStorageService;
+    store = new InternalStore({});
+    document = inject(DOCUMENT);
+    updateLocalStorage = () => {
+        this.localStorageService.set('abpSession', JSON.stringify(this.store.state), { expires: new Date(new Date().getTime() + 365 * 86400000), path: '/' });
+    };
+    constructor(configState, localStorageService) {
+        this.configState = configState;
+        this.localStorageService = localStorageService;
+        this.init();
+        this.setInitialLanguage();
+    }
+    init() {
+        const session = this.localStorageService.get('abpSession');
+        if (session) {
+            this.store.set(JSON.parse(session));
+        }
+        this.store.sliceUpdate(state => state).subscribe(this.updateLocalStorage);
+    }
+    setInitialLanguage() {
+        const appLanguage = this.getLanguage();
+        this.configState
+            .getDeep$('localization.currentCulture.cultureName')
+            .pipe(filter(cultureName => !!cultureName), take(1))
+            .subscribe(lang => {
+            if (lang.includes(';')) {
+                lang = lang.split(';')[0];
+            }
+            this.setLanguage(lang);
+        });
+    }
+    onLanguageChange$() {
+        return this.store.sliceUpdate(state => state.language);
+    }
+    onTenantChange$() {
+        return this.store.sliceUpdate(state => state.tenant);
+    }
+    getLanguage() {
+        return this.store.state.language;
+    }
+    getLanguage$() {
+        return this.store.sliceState(state => state.language);
+    }
+    getTenant() {
+        return this.store.state.tenant;
+    }
+    getTenant$() {
+        return this.store.sliceState(state => state.tenant);
+    }
+    setTenant(tenant) {
+        if (compare(tenant, this.store.state.tenant))
+            return;
+        this.store.set({ ...this.store.state, tenant });
+    }
+    setState(session) {
+        if (compare(session, this.store.state))
+            return;
+        this.store.set({ ...this.store.state, ...session });
+    }
+    setLanguage(language) {
+        const currentLanguage = this.store.state.language;
+        if (language !== currentLanguage) {
+            this.store.patch({ language });
+        }
+        const currentAttribute = this.document.documentElement.getAttribute('lang');
+        if (language !== currentAttribute) {
+            this.document.documentElement.setAttribute('lang', language);
+        }
+    }
+    get application() {
+        return this.store.state.application;
+    }
+    get user() {
+        return this.store.state.user;
+    }
+    get userId() {
+        return this.user ? this.user.id : 0;
+    }
+    get tenant() {
+        return this.store.state.tenant;
+    }
+    get branch() {
+        return this.store.state.branch;
+    }
+    /* get branchName(): BranchLoginInfoDto {
+        return this._branch ? this.branch.Name : '';
+
+    } */
+    get tenancyName() {
+        return this.store.state.tenant ? this.tenant?.tenancyName : '';
+    }
+    get branchId() {
+        // return this.branch ? this.branch.id : this.configState.Session?.branchId ? this.configState.Session.branchId:null;
+        return this.branch ? this.branch.id : 0;
+    }
+    get tenantId() {
+        return this.tenant ? this.tenant.id : 0;
+    }
+    getShownLoginName() {
+        const userName = this.store.state.user?.userName ?? '';
+        if (!this.multiTenancySide) {
+            return userName;
+        }
+        return (this.store.state.tenant ? this.store.state.tenant.tenancyName : '.') + '\\' + userName;
+    }
+    changeTenantIfNeeded(tenantId) {
+        if (this.isCurrentTenant(tenantId)) {
+            return false;
+        }
+        // this.configState.SetTenantIdCookie(tenantId);
+        location.reload();
+        return true;
+    }
+    isCurrentTenant(tenantId) {
+        let isTenant = tenantId ?? 0 > 0;
+        if (!isTenant && !this.tenant) { // this is host
+            return true;
+        }
+        if (!tenantId && this.tenant) {
+            return false;
+        }
+        else if (tenantId && (!this.tenant || this.tenant.id !== tenantId)) {
+            return false;
+        }
+        return true;
+    }
+    get impersonatorUser() {
+        return this.store.state.impersonatorUser;
+    }
+    get impersonatorUserId() {
+        return this.impersonatorUser ? this.impersonatorUser.id : 0;
+    }
+    get impersonatorTenant() {
+        return this.store.state.impersonatorTenant;
+    }
+    get impersonatorTenancyName() {
+        return this.impersonatorTenant ? this.impersonatorTenant?.tenancyName ?? '' : '';
+    }
+    get impersonatorTenantId() {
+        return this.impersonatorTenant ? this.impersonatorTenant.id : 0;
+    }
+    get multiTenancySide() {
+        // return this.configState.session?.multiTenancySide;
+        return 0;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, deps: [{ token: ConfigStateService }, { token: SsrCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: ConfigStateService }, { type: SsrCookieService }] });
+
+class LocalizationService {
+    sessionState;
+    injector;
+    configState;
+    latestLang = 'ar';
+    _languageChange$ = new Subject();
+    uiLocalizations$ = new BehaviorSubject(new Map());
+    localizations$ = new BehaviorSubject(new Map());
+    /**
+     * Returns currently selected language
+     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
+     * it's actually not. This could be invoked any time, and the latestLang could be different from the
+     * sessionState.getLanguage() value.
+     */
+    get currentLanguage() {
+        return this.latestLang || this.sessionState.getLanguage();
+    }
+    get currentLang() {
+        return this.latestLang || this.sessionState.getLanguage();
+    }
+    get currentLang$() {
+        return this.sessionState.getLanguage$();
+    }
+    get languageChange$() {
+        return this._languageChange$.asObservable();
+    }
+    constructor(sessionState, injector, otherInstance, configState) {
+        this.sessionState = sessionState;
+        this.injector = injector;
+        this.configState = configState;
+        if (otherInstance)
+            throw new Error('LocalizationService should have only one instance.');
+        this.listenToSetLanguage();
+        this.initLocalizationValues();
+        this.latestLang = this.sessionState.getLanguage();
+    }
+    initLocalizationValues() {
+        localizations$.subscribe(val => this.addLocalization(val));
+        const legacyResources$ = this.configState.getDeep$('localization.values');
+        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
+        const currentLanguage$ = this.sessionState.getLanguage$();
+        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
+        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
+            .pipe(map(([legacy, resource, local]) => {
+            if (!resource) {
+                return null;
+            }
+            const remote = combineLegacyandNewResources(legacy || {}, resource);
+            if (remote) {
+                if (!local) {
+                    local = new Map();
+                }
+                Object.entries(remote).forEach(entry => {
+                    const resourceName = entry[0];
+                    const remoteTexts = entry[1];
+                    let resource = local?.get(resourceName) || {};
+                    resource = { ...resource, ...remoteTexts };
+                    local?.set(resourceName, resource);
+                });
+            }
+            return local;
+        }), filter(Boolean))
+            .subscribe(val => this.localizations$.next(val));
+    }
+    addLocalization(localizations) {
+        if (!localizations)
+            return;
+        const localizationMap = this.uiLocalizations$.value;
+        localizations.forEach(loc => {
+            const cultureMap = localizationMap.get(loc.culture) || new Map();
+            loc.resources.forEach(res => {
+                let resource = cultureMap.get(res.resourceName) || {};
+                resource = { ...resource, ...res.texts };
+                cultureMap.set(res.resourceName, resource);
+            });
+            localizationMap.set(loc.culture, cultureMap);
+        });
+        this.uiLocalizations$.next(localizationMap);
+    }
+    listenToSetLanguage() {
+        this.sessionState
+            .onLanguageChange$()
+            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap((lang) => this.configState.refreshLocalization(lang).pipe(map(() => lang))), filter(Boolean), switchMap((lang) => from(this.registerLocale(lang).then(() => lang))))
+            .subscribe((lang) => this._languageChange$.next(lang));
+    }
+    registerLocale(locale) {
+        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
+        return registerLocaleFn(locale).then(module => {
+            if (module?.default)
+                registerLocaleData(module.default);
+            this.latestLang = locale;
+        });
+    }
+    /**
+     * Returns an observable localized text with the given interpolation parameters in current language.
+     * @param key Localizaton key to replace with localized text
+     * @param interpolateParams Values to interpolate
+     */
+    get(key, ...interpolateParams) {
+        return this.configState
+            .getAll$()
+            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
+    }
+    getResource(resourceName) {
+        return this.localizations$.value.get(resourceName);
+    }
+    getResource$(resourceName) {
+        return this.localizations$.pipe(map(res => res.get(resourceName)));
+    }
+    /**
+     * Returns localized text with the given interpolation parameters in current language.
+     * @param key Localization key to replace with localized text
+     * @param interpolateParams Values to intepolate.
+     */
+    instant(key, ...interpolateParams) {
+        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
+    }
+    localize(resourceName, key, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizer), map((localize) => localize(resourceName, key, defaultValue)));
+    }
+    get defaultResourceName() {
+        return this.configState.getAll().localization ? this.configState.getAll().localization.defaultResourceName : 'FrameworkLocalization';
+    }
+    l(key) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(this.defaultResourceName ?? '', key, key);
+    }
+    localizeSync(resourceName, key, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(resourceName, key, defaultValue);
+    }
+    localizeWithFallback(resourceNames, keys, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map((localizeWithFallback) => localizeWithFallback(resourceNames, keys, defaultValue)));
+    }
+    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
+    }
+    getLocalization(state, key, ...interpolateParams) {
+        let defaultValue = '';
+        if (!key) {
+            return defaultValue;
+        }
+        if (typeof key !== 'string') {
+            defaultValue = key.defaultValue;
+            key = key.key;
+        }
+        const keys = key.split('::');
+        const warn = (message) => {
+            if (isDevMode())
+                console.warn(message);
+        };
+        if (keys.length < 2) {
+            warn('The localization source separator (::) not found.');
+            return defaultValue || key;
+        }
+        if (!state.localization)
+            return defaultValue || keys[1];
+        const sourceName = keys[0] || state.localization.defaultResourceName;
+        const sourceKey = keys[1];
+        if (sourceName === '_') {
+            return defaultValue || sourceKey;
+        }
+        if (!sourceName) {
+            warn('Localization source name is not specified and the defaultResourceName was not defined!');
+            return defaultValue || sourceKey;
+        }
+        const source = this.localizations$.value.get(sourceName);
+        if (!source) {
+            warn('Could not find localization source: ' + sourceName);
+            return defaultValue || sourceKey;
+        }
+        let localization = source[sourceKey];
+        if (typeof localization === 'undefined') {
+            return defaultValue || sourceKey;
+        }
+        interpolateParams = interpolateParams.filter(params => params != null);
+        if (localization)
+            localization = interpolate(localization, interpolateParams);
+        if (typeof localization !== 'string')
+            localization = '';
+        return localization || defaultValue || key;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: ConfigStateService }] });
+function recursivelyMergeBaseResources(baseResourceName, source) {
+    const item = source[baseResourceName];
+    if (item.baseResources.length === 0) {
+        return item;
+    }
+    return item.baseResources.reduce((acc, baseResource) => {
+        const baseItem = recursivelyMergeBaseResources(baseResource, source);
+        const texts = { ...baseItem.texts, ...item.texts };
+        return { ...acc, texts };
+    }, item);
+}
+function mergeResourcesWithBaseResource(resource) {
+    const entities = Object.keys(resource).map(key => {
+        const newValue = recursivelyMergeBaseResources(key, resource);
+        return [key, newValue];
+    });
+    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+}
+function combineLegacyandNewResources(legacy, resource) {
+    const mergedResource = mergeResourcesWithBaseResource(resource);
+    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
+        return { ...acc, [key]: value.texts };
+    }, legacy);
+}
+
+class LocalStorageListenerService {
+    window = inject(DOCUMENT).defaultView;
+    constructor() {
+        this.window?.addEventListener('storage', event => {
+            if (event.key === 'access_token') {
+                const tokenRemoved = event.newValue === null;
+                const tokenAdded = event.oldValue === null && event.newValue !== null;
+                if (tokenRemoved || tokenAdded) {
+                    this.window?.location.assign('/');
+                }
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageListenerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageListenerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class LocalStorageService {
+    cookieService;
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+    }
+    getItem(key, callback) {
+        if (!this.cookieService) {
+            return '';
+        }
+        var value = this.cookieService.get(key);
+        if (callback) {
+            callback();
+        }
+        return value;
+    }
+    setItem(key, value, callback) {
+        if (!this.cookieService) {
+            return;
+        }
+        if (value === null) {
+            value = undefined;
+        }
+        this.cookieService.set(key, value, { expires: new Date(new Date().getTime() + 365 * 86400000), path: '/' });
+        // debugger
+        if (callback) {
+            callback();
+        }
+    }
+    removeItem(key, callback) {
+        if (!this.cookieService) {
+            return;
+        }
+        this.cookieService.delete(key);
+        if (callback) {
+            callback();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageService, deps: [{ token: SsrCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: SsrCookieService }] });
+
+class FrameworkTitleStrategy extends TitleStrategy {
+    title = inject(Title);
+    localizationService = inject(LocalizationService);
+    disableProjectName = inject(DISABLE_PROJECT_NAME, { optional: true });
+    routerState;
+    langugageChange = toSignal(this.localizationService.languageChange$);
+    constructor() {
+        super();
+        effect(() => {
+            if (this.langugageChange()) {
+                this.updateTitle(this.routerState);
+            }
+        });
+    }
+    updateTitle(routerState) {
+        this.routerState = routerState;
+        const title = this.buildTitle(routerState);
+        const projectName = this.localizationService.instant({
+            key: '::AppName',
+            defaultValue: 'MyProjectName',
+        });
+        if (!title) {
+            return this.title.setTitle(projectName);
+        }
+        let localizedText = this.localizationService.instant({ key: title, defaultValue: title });
+        if (!this.disableProjectName) {
+            localizedText += ` | ${projectName}`;
+        }
+        this.title.setTitle(localizedText);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: FrameworkTitleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: FrameworkTitleStrategy, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: FrameworkTitleStrategy, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+const SORT_COMPARE_FUNC = new InjectionToken('SORT_COMPARE_FUNC');
+function compareFuncFactory() {
+    const localizationService = inject(LocalizationService);
+    const fn = (a, b) => {
+        const aNumber = a.order;
+        const bNumber = b.order;
+        if (aNumber > bNumber)
+            return 1;
+        if (aNumber < bNumber)
+            return -1;
+        if (a.id > b.id)
+            return 1;
+        if (a.id < b.id)
+            return -1;
+        if (!Number.isInteger(aNumber))
+            return 1;
+        if (!Number.isInteger(bNumber))
+            return -1;
+        const aName = localizationService.instant(a.name);
+        const bName = localizationService.instant(b.name);
+        // const aName = localizationService.localize(a.name,'ERP');
+        // const bName = localizationService.localize(b.name,'ERP');
+        if (aName > bName)
+            return 1;
+        if (aName < bName)
+            return -1;
+        return 0;
+    };
+    return fn;
+}
+
+class AbstractTreeService {
+    _flat$ = new BehaviorSubject([]);
+    _tree$ = new BehaviorSubject([]);
+    _visible$ = new BehaviorSubject([]);
+    othersGroup;
+    shouldSingularizeRoutes = true;
+    get flat() {
+        return this._flat$.value;
+    }
+    get flat$() {
+        return this._flat$.asObservable();
+    }
+    get tree() {
+        return this._tree$.value;
+    }
+    get tree$() {
+        return this._tree$.asObservable();
+    }
+    get visible() {
+        return this._visible$.value;
+    }
+    get visible$() {
+        return this._visible$.asObservable();
+    }
+    filterWith(setOrMap) {
+        return this._flat$.value.filter(item => !setOrMap.has(item[this.id]));
+    }
+    findItemsToRemove(set) {
+        return this._flat$.value.reduce((acc, item) => {
+            if (!acc.has(item[this.parentId])) {
+                return acc;
+            }
+            const childSet = new Set([item[this.id]]);
+            const children = this.findItemsToRemove(childSet);
+            return new Set([...acc, ...children]);
+        }, set);
+    }
+    publish(flatItems) {
+        this._flat$.next(flatItems);
+        this._tree$.next(this.createTree(flatItems));
+        this._visible$.next(this.createTree(flatItems.filter(item => !this.hide(item))));
+        return flatItems;
+    }
+    createTree(items) {
+        return createTreeFromList(items, item => item[this.id], item => item[this.parentId], item => BaseTreeNode.create(item));
+    }
+    createGroupedTree(list) {
+        const map = createGroupMap(list, this.othersGroup);
+        if (!map) {
+            return undefined;
+        }
+        return Array.from(map, ([key, items]) => ({ group: key, items }));
+    }
+    add(items) {
+        let flatItems = [];
+        if (!this.shouldSingularizeRoutes) {
+            flatItems = [...this.flat, ...items];
+        }
+        if (this.shouldSingularizeRoutes) {
+            const map = new Map();
+            items.forEach(item => map.set(item[this.id], item));
+            flatItems = this.filterWith(map);
+            map.forEach(pushValueTo(flatItems));
+        }
+        flatItems.sort(this.sort);
+        return this.publish(flatItems);
+    }
+    find(predicate, tree = this.tree) {
+        return tree.reduce((acc, node) => {
+            if (acc) {
+                return acc;
+            }
+            if (predicate(node)) {
+                return node;
+            }
+            return this.find(predicate, node.children);
+        }, null);
+    }
+    patch(identifier, props) {
+        const flatItems = this._flat$.value;
+        const index = flatItems.findIndex(item => item[this.id] === identifier);
+        if (index < 0) {
+            return false;
+        }
+        flatItems[index] = { ...flatItems[index], ...props };
+        flatItems.sort(this.sort);
+        return this.publish(flatItems);
+    }
+    refresh() {
+        return this.add([]);
+    }
+    remove(identifiers) {
+        const set = new Set();
+        identifiers.forEach(id => set.add(id));
+        const setToRemove = this.findItemsToRemove(set);
+        const flatItems = this.filterWith(setToRemove);
+        return this.publish(flatItems);
+    }
+    removeByParam(params) {
+        if (!params) {
+            return null;
+        }
+        const keys = Object.keys(params);
+        if (keys.length === 0) {
+            return null;
+        }
+        const excludedList = this.flat.filter(item => keys.every(key => item[key] === params[key]));
+        if (!excludedList?.length) {
+            return null;
+        }
+        for (const item of excludedList) {
+            this.removeByParam({ [this.parentId]: item[this.id] });
+        }
+        const flatItems = this.flat.filter(item => !excludedList.includes(item));
+        return this.publish(flatItems);
+    }
+    search(params, tree = this.tree) {
+        const searchKeys = Object.keys(params);
+        return tree.reduce((acc, node) => {
+            if (acc) {
+                return acc;
+            }
+            if (searchKeys.every(key => node[key] === params[key])) {
+                return node;
+            }
+            return this.search(params, node.children);
+        }, null);
+    }
+    setSingularizeStatus(singularize = true) {
+        this.shouldSingularizeRoutes = singularize;
+    }
+}
+class AbstractNavTreeService extends AbstractTreeService {
+    injector;
+    subscription;
+    permissionService;
+    compareFunc;
+    id = 'name';
+    parentId = 'parentName';
+    hide = (item) => item.invisible || !this.isGranted(item);
+    sort = (a, b) => {
+        return this.compareFunc(a, b);
+    };
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        // TODO Merge Dynamic Nav Too!
+        const configState = this.injector.get(ConfigStateService);
+        this.subscription = configState
+            .createOnUpdateStream((state) => state)
+            .subscribe(() => this.refresh());
+        this.permissionService = injector.get(PermissionCheckerService);
+        this.othersGroup = injector.get(OTHERS_GROUP);
+        this.compareFunc = injector.get(SORT_COMPARE_FUNC);
+    }
+    isGranted({ requiredPolicy }) {
+        return this.permissionService.getGrantedPolicy(requiredPolicy);
+    }
+    hasChildren(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return Boolean(node?.children?.length);
+    }
+    hasInvisibleChild(identifier) {
+        const node = this.find(item => item[this.id] === identifier);
+        return node?.children?.some(child => child.invisible) || false;
+    }
+    /* istanbul ignore next */
+    ngOnDestroy() {
+        // this.subscription.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AbstractNavTreeService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: AbstractNavTreeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+class RoutesService extends AbstractNavTreeService {
+    hasPathOrChild(item) {
+        return Boolean(item.path) || this.hasChildren(item.name);
+    }
+    get groupedVisible() {
+        return this.createGroupedTree(this.visible.filter(item => this.hasPathOrChild(item)));
+    }
+    get groupedVisible$() {
+        return this.visible$.pipe(map$1(items => items.filter(item => this.hasPathOrChild(item))), map$1(visible => this.createGroupedTree(visible)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class RoutesHandler {
+    routes;
+    router;
+    constructor(routes, router) {
+        this.routes = routes;
+        this.router = router;
+        this.addRoutes();
+    }
+    addRoutes() {
+        this.router?.config?.forEach(({ path = '', data }) => {
+            const routes = data?.routes;
+            if (!routes)
+                return;
+            if (Array.isArray(routes)) {
+                this.routes.add(routes);
+            }
+            else {
+                const routesFlatten = flatRoutes([{ path, ...routes }], { path: '' });
+                this.routes.add(routesFlatten);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesHandler, deps: [{ token: RoutesService }, { token: i2.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesHandler, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RoutesHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RoutesService }, { type: i2.Router, decorators: [{
+                    type: Optional
+                }] }] });
+function flatRoutes(routes, parent) {
+    if (!routes)
+        return [];
+    return routes.reduce((acc, route) => {
+        const { children, ...current } = {
+            ...route,
+            parentName: parent.name,
+            path: (parent.path + '/' + route.path).replace(/\/\//g, '/'),
+        };
+        acc.push(current, ...flatRoutes(children, current));
+        return acc;
+    }, []);
+}
+
+class MultiTenancyService {
+    restService;
+    sessionState;
+    configStateService;
+    tenantKey;
+    get isEnabled() {
+        // return this.framework.multiTenancy.isEnabled;
+        return true;
+    }
+    domainTenant = null;
+    isTenantBoxVisible = true;
+    apiName = 'framework';
+    setTenantToState = (tenant) => {
+        this.sessionState.setTenant({ id: tenant.id, name: tenant.name, /* isAvailable: true */ });
+        return this.configStateService.refreshAppState().pipe(map$1(_ => tenant));
+    };
+    constructor(restService, sessionState, configStateService, tenantKey) {
+        this.restService = restService;
+        this.sessionState = sessionState;
+        this.configStateService = configStateService;
+        this.tenantKey = tenantKey;
+    }
+    setTenantByName(tenantName) {
+        return this
+            .findTenantByName(tenantName)
+            .pipe(switchMap$1(this.setTenantToState));
+    }
+    setTenantById(tenantId) {
+        return this
+            .findTenantById(tenantId)
+            .pipe(switchMap$1(this.setTenantToState));
+    }
+    findTenantById = (id, config) => this.restService.request({
+        method: 'GET',
+        url: `/api/framework/multi-tenancy/tenants/by-id/${id}`,
+    }, { apiName: this.apiName, ...config });
+    findTenantByName = (name, config) => this.restService.request({
+        method: 'GET',
+        url: `/api/framework/multi-tenancy/tenants/by-name/${name}`,
+    }, { apiName: this.apiName, ...config });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: MultiTenancyService, deps: [{ token: RestService }, { token: SessionStateService }, { token: ConfigStateService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: MultiTenancyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: MultiTenancyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: RestService }, { type: SessionStateService }, { type: ConfigStateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }] });
+
+class HttpErrorReporterService {
+    _reporter$ = new Subject();
+    _errors$ = new BehaviorSubject([]);
+    get reporter$() {
+        return this._reporter$.asObservable();
+    }
+    get errors$() {
+        return this._errors$.asObservable();
+    }
+    get errors() {
+        return this._errors$.value;
+    }
+    reportError(error) {
+        this._reporter$.next(error);
+        this._errors$.next([...this.errors, error]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: HttpErrorReporterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: HttpErrorReporterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: HttpErrorReporterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class SubscriptionService {
+    subscription = new Subscription();
+    get isClosed() {
+        return this.subscription.closed;
+    }
+    addOne(source$, nextOrObserver, error) {
+        const subscription = source$.subscribe(nextOrObserver, error);
+        this.subscription.add(subscription);
+        return subscription;
+    }
+    closeAll() {
+        this.subscription.unsubscribe();
+    }
+    closeOne(subscription) {
+        this.removeOne(subscription);
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    removeOne(subscription) {
+        if (!subscription)
+            return;
+        this.subscription.remove(subscription);
+    }
+    reset() {
+        this.subscription.unsubscribe();
+        this.subscription = new Subscription();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SubscriptionService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable
+        }] });
+
+const NavigationEvent = {
+    Cancel: NavigationCancel,
+    End: NavigationEnd,
+    Error: NavigationError,
+    Start: NavigationStart,
+};
+class RouterEvents {
+    router = inject(Router);
+    #previousNavigation = signal(undefined, ...(ngDevMode ? [{ debugName: "#previousNavigation" }] : []));
+    previousNavigation = this.#previousNavigation.asReadonly();
+    #currentNavigation = signal(undefined, ...(ngDevMode ? [{ debugName: "#currentNavigation" }] : []));
+    currentNavigation = this.#currentNavigation.asReadonly();
+    constructor() {
+        this.listenToNavigation();
+    }
+    listenToNavigation() {
+        const routerEvent$ = this.router.events.pipe(filter(e => e instanceof NavigationEvent.End && !e.url.includes('error')));
+        routerEvent$.subscribe(event => {
+            this.#previousNavigation.set(this.currentNavigation());
+            this.#currentNavigation.set(event.url);
+        });
+    }
+    getEvents(...eventTypes) {
+        const filterRouterEvents = (event) => eventTypes.some(type => event instanceof type);
+        return this.router.events.pipe(filter(filterRouterEvents));
+    }
+    getNavigationEvents(...navigationEventKeys) {
+        const filterNavigationEvents = (event) => navigationEventKeys.some(key => event instanceof NavigationEvent[key]);
+        return this.router.events.pipe(filter(filterNavigationEvents));
+    }
+    getAllEvents() {
+        return this.router.events;
+    }
+    getAllNavigationEvents() {
+        const keys = Object.keys(NavigationEvent);
+        return this.getNavigationEvents(...keys);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterEvents, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterEvents, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterEvents, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class RouterWaitService {
+    routerEvents;
+    store = new InternalStore({ loading: false });
+    destroy$ = new Subject();
+    delay;
+    constructor(routerEvents, injector) {
+        this.routerEvents = routerEvents;
+        // this.delay = injector.get(LOADER_DELAY, 500);
+        this.delay = 500;
+        this.updateLoadingStatusOnNavigationEvents();
+    }
+    updateLoadingStatusOnNavigationEvents() {
+        this.routerEvents
+            .getAllNavigationEvents()
+            .pipe(map(event => event instanceof NavigationStart), switchMap(condition => condition
+            ? this.delay === 0
+                ? of(true)
+                : timer(this.delay || 0).pipe(mapTo(true), takeUntil(this.destroy$))
+            : of(false)), tap(() => this.destroy$.next()))
+            .subscribe(status => {
+            this.setLoading(status);
+        });
+    }
+    getLoading() {
+        return this.store.state.loading;
+    }
+    getLoading$() {
+        return this.store.sliceState(({ loading }) => loading);
+    }
+    updateLoading$() {
+        return this.store.sliceUpdate(({ loading }) => loading);
+    }
+    setLoading(loading) {
+        this.store.patch({ loading });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterWaitService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: RouterWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RouterEvents }, { type: i0.Injector }] });
+
+class AbstractMenuService {
+    sortFn;
+    _items$ = new BehaviorSubject([]);
+    get items() {
+        return this._items$.value;
+    }
+    get items$() {
+        return this._items$.asObservable();
+    }
+    constructor() {
+        this.sortFn = inject(SORT_COMPARE_FUNC);
+    }
+    addItems(newItems) {
+        const items = [...this.items];
+        newItems.forEach(item => {
+            const index = items.findIndex(i => i.id === item.id);
+            // const data = new this.baseClass(item);
+            // const data = new this.baseClass(item);
+            if (index > -1) {
+                items[index] = item;
+                return;
+            }
+            items.push(item);
+        });
+        items.sort(this.sortItems);
+        this._items$.next(items);
+    }
+    removeItem(id) {
+        const index = this.items.findIndex(item => item.id === id);
+        if (index < 0)
+            return;
+        const items = [...this.items.slice(0, index), ...this.items.slice(index + 1)];
+        this._items$.next(items);
+    }
+    patchItem(id, item) {
+        const index = this.items.findIndex(i => i.id === id);
+        if (index < 0)
+            return;
+        const items = [...this.items];
+        items[index] = new this.baseClass({ ...items[index], ...item });
+        items.sort(this.sortItems);
+        this._items$.next(items);
+    }
+    sortItems = (a, b) => {
+        return this.sortFn(a, b);
+    };
+}
+
+class NavItemsService extends AbstractMenuService {
+    baseClass = NavItem;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NavItemsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NavItemsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NavItemsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class UserMenuService extends AbstractMenuService {
+    baseClass = UserMenu;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: UserMenuService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: UserMenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: UserMenuService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function getRemoteEnv(injector, environment) {
+    const environmentService = injector.get(EnvironmentService);
+    const { remoteEnv } = environment;
+    const { headers = {}, method = 'GET', url } = remoteEnv || {};
+    if (!url)
+        return Promise.resolve();
+    const http = injector.get(HttpClient);
+    const httpErrorReporter = injector.get(HttpErrorReporterService);
+    return http
+        .request(method, url, { headers })
+        .pipe(catchError$1(err => {
+        httpErrorReporter.reportError(err);
+        return of(null);
+    }), // TODO: Consider get handle function from a provider
+    tap(env => environmentService.setState(mergeEnvironments(environment, env || {}, remoteEnv))))
+        .toPromise();
+}
+function mergeEnvironments(local, remote, config) {
+    switch (config.mergeStrategy) {
+        case 'deepmerge':
+            return deepMerge(local, remote);
+        case 'overwrite':
+        case null:
+        case undefined:
+            return remote;
+        default:
+            return config.mergeStrategy(local, remote);
+    }
+}
+
+const tenancyPlaceholder = '{0}';
+function getCurrentTenancyName(appBaseUrl, injector) {
+    const cookieService = injector.get(SsrCookieService);
+    if (appBaseUrl.charAt(appBaseUrl.length - 1) !== '/')
+        appBaseUrl += '/';
+    const parseTokens = createTokenParser(appBaseUrl);
+    const token = tenancyPlaceholder.replace(/[}{]/g, '');
+    try {
+        return parseTokens(cookieService.url)[token]?.[0];
+    }
+    catch (error) {
+        return '';
+    }
+    // return parseTokens(window.location.href)[token]?.[0];
+    // const pattern = /^http?:\/\/([^.]+)\.localhost\:4200/;
+    // const match = cookieService.url.match(pattern);
+    // if (match && match.length > 1) {
+    //   return match[1];
+    // }
+    //  return '';
+}
+function getCurrentTenancyNameFromUrl(tenantKey) {
+    if (typeof window === 'undefined') {
+        return null; // or fallback like: return '';
+    }
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.get(tenantKey);
+}
+//
+async function parseTenantFromUrl(injector) {
+    const environmentService = injector.get(EnvironmentService);
+    const multiTenancyService = injector.get(MultiTenancyService);
+    const tenantNotFoundHandler = injector.get(TENANT_NOT_FOUND_BY_NAME, null);
+    const baseUrl = environmentService.getEnvironment()?.application?.baseUrl || '';
+    const tenancyName = getCurrentTenancyName(baseUrl, injector);
+    const hideTenantBox = () => {
+        multiTenancyService.isTenantBoxVisible = false;
+    };
+    const setDomainTenant = (tenant) => {
+        multiTenancyService.domainTenant = {
+            id: tenant.id,
+            name: tenant.name,
+            isAvailable: true,
+        };
+    };
+    const setEnvironmentWithDomainTenant = (tenant) => {
+        hideTenantBox();
+        setDomainTenant(tenant);
+    };
+    if (tenancyName) {
+        /**
+         * We have to replace tenant name within the urls from environment,
+         * because the code below will make a http request to find information about the domain tenant.
+         * Before this request takes place, we need to replace placeholders aka "{0}".
+         */
+        replaceTenantNameWithinEnvironment(injector, tenancyName);
+        const tenant$ = multiTenancyService.setTenantByName(tenancyName);
+        try {
+            const result = await firstValueFrom(tenant$);
+            setEnvironmentWithDomainTenant(result);
+            return Promise.resolve(result);
+        }
+        catch (httpError) {
+            if (httpError instanceof HttpErrorResponse &&
+                httpError.status === 404 &&
+                tenantNotFoundHandler) {
+                tenantNotFoundHandler(httpError);
+            }
+            return Promise.reject();
+        }
+    }
+    /**
+     * If there is no tenant, we still have to clean up {0}. from baseUrl to avoid incorrect http requests.
+     */
+    replaceTenantNameWithinEnvironment(injector, '', tenancyPlaceholder + '.');
+    const tenantIdFromQueryParams = getCurrentTenancyNameFromUrl(multiTenancyService.tenantKey);
+    if (tenantIdFromQueryParams) {
+        const tenantById$ = multiTenancyService.setTenantById(tenantIdFromQueryParams);
+        return firstValueFrom(tenantById$);
+    }
+    return Promise.resolve();
+}
+function replaceTenantNameWithinEnvironment(injector, tenancyName, placeholder = tenancyPlaceholder) {
+    const environmentService = injector.get(EnvironmentService);
+    const environment = clone(environmentService.getEnvironment());
+    if (environment.application.baseUrl) {
+        environment.application.baseUrl = environment.application.baseUrl.replace(placeholder, tenancyName);
+    }
+    if (environment.oAuthConfig?.redirectUri) {
+        environment.oAuthConfig.redirectUri = environment.oAuthConfig.redirectUri.replace(placeholder, tenancyName);
+    }
+    if (!environment.oAuthConfig) {
+        environment.oAuthConfig = {};
+    }
+    environment.oAuthConfig.issuer = (environment.oAuthConfig.issuer || '').replace(placeholder, tenancyName);
+    Object.keys(environment.apis).forEach(api => {
+        Object.keys(environment.apis[api]).forEach(key => {
+            environment.apis[api][key] = (environment.apis[api][key] || '').replace(placeholder, tenancyName);
+        });
+    });
+    return environmentService.setState(environment);
+}
+
+async function getInitialData() {
+    const injector = inject(Injector);
+    const environmentService = injector.get(EnvironmentService);
+    const configState = injector.get(ConfigStateService);
+    const options = injector.get(CORE_OPTIONS);
+    environmentService.setState(options.environment);
+    await getRemoteEnv(injector, options.environment);
+    await parseTenantFromUrl(injector);
+    const authService = injector.get(AuthService, undefined, { optional: true });
+    const checkAuthenticationState = injector.get(CHECK_AUTHENTICATION_STATE_FN_KEY, noop, {
+        optional: true,
+    });
+    if (!options.skipInitAuthService && authService) {
+        await authService.init();
+    }
+    if (options.skipGetAppConfiguration)
+        return;
+    const result$ = configState.refreshAppState().pipe(tap(() => checkAuthenticationState(injector)), tap(() => {
+        const currentTenant = configState.getOne('currentTenant');
+        injector.get(SessionStateService).setTenant(currentTenant);
+        //  const currentSession= configState.getOne('currentT') as Session.State;
+        // injector.get(SessionStateService).setState(currentSession);
+    }), catchError$1(error => {
+        const appInitErrorHandlers = injector.get(APP_INIT_ERROR_HANDLERS, null);
+        if (appInitErrorHandlers && appInitErrorHandlers.length) {
+            appInitErrorHandlers.forEach(func => func(error));
+        }
+        return throwError(() => error);
+        // Don't rethrow to avoid breaking the app
+        // return of(null); // ✅ suppresses the error
+    }));
+    await lastValueFrom(result$);
+}
+function localeInitializer() {
+    const injector = inject(Injector);
+    const sessionState = injector.get(SessionStateService);
+    const { registerLocaleFn } = injector.get(CORE_OPTIONS);
+    const lang = sessionState.getLanguage() || 'en';
+    return new Promise((resolve, reject) => {
+        registerLocaleFn(lang).then(module => {
+            if (module?.default)
+                registerLocaleData(module.default);
+            return resolve('resolved');
+        }, reject);
+    });
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BaseService, GenericService, IdParserService, LogLevel, LoggerService, NgxPermissionsGuard, PermissionsService, QueryParser, REQUEST, RestService, SsrCookieService, SwalService, isUndefinedOrEmptyString, ngxPermissionsGuard };
+export { AbstractMenuService, AbstractNavTreeService, AbstractTreeService, ApplicationConfigurationService, ApplicationLocalizationService, BaseService, ConfigStateService, EnvironmentService, FrameworkTitleStrategy, GenericService, HttpErrorReporterService, IdParserService, LocalStorageListenerService, LocalStorageService, LocalizationService, LogLevel, LoggerService, MultiTenancyService, NavItemsService, NavigationEvent, NgxPermissionsGuard, PermissionCheckerService, QueryParser, REQUEST, RestService, RouterEvents, RouterWaitService, RoutesHandler, RoutesService, SORT_COMPARE_FUNC, SessionStateService, SsrCookieService, SubscriptionService, SwalService, UserMenuService, compareFuncFactory, getCurrentTenancyNameFromUrl, getInitialData, getRemoteEnv, isUndefinedOrEmptyString, localeInitializer, ngxPermissionsGuard, parseTenantFromUrl };
 //# sourceMappingURL=elite.framework-ng.core-services.mjs.map