@acorex/platform 19.1.7 → 19.1.9

package/fesm2022/acorex-platform-common.mjs

@@ -1,15 +1,12 @@
 import * as i0 from '@angular/core';
 import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Directive, Input, EventEmitter, Output, runInInjectionContext, NgModule, Optional, Inject, Component, ViewEncapsulation } from '@angular/core';
-import { kebabCase, sortBy, merge, cloneDeep, get, omit } from 'lodash-es';
+import { kebabCase, sortBy, omit, merge, cloneDeep, get } from 'lodash-es';
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
-import * as i5 from '@acorex/platform/workflow';
-import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
-import * as i2$1 from '@angular/router';
+import * as i4 from '@acorex/platform/workflow';
+import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
 import { Router, RouterModule } from '@angular/router';
-import * as i1$1 from '@ngrx/effects';
-import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
 import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 import Dexie from 'dexie';
 import * as i3 from '@acorex/components/decorators';
@@ -19,9 +16,10 @@ import { AXImageModule } from '@acorex/components/image';
 import * as i1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
-import { createAction, props, Store } from '@ngrx/store';
-import { Subject, switchMap, of } from 'rxjs';
 import { AXTranslationService } from '@acorex/core/translation';
+import { Store, createAction } from '@ngrx/store';
+import { AXFormatService } from '@acorex/core/format';
+import { Subject } from 'rxjs';
 import { AXDialogService } from '@acorex/components/dialog';
 
 class AXPAppStartUpService {
@@ -1277,471 +1275,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-const AXPNavigateAction = createAction('[Navigate] Action', props());
-const AXPSignOutAction = createAction('[SignOut] Action');
-const AXPSignInAction = createAction('[SignIn] Action');
-
-var AXPSettingScope;
-(function (AXPSettingScope) {
-    AXPSettingScope["Environment"] = "C";
-    AXPSettingScope["Global"] = "G";
-    AXPSettingScope["Tenant"] = "T";
-    AXPSettingScope["User"] = "U";
-})(AXPSettingScope || (AXPSettingScope = {}));
-;
-
-class AXPSettingDefinitionProviderContext {
-    constructor() {
-        this.rootGroups = [];
-        this.groupMap = new Map();
-    }
-    addGroup(name, title, description, icon) {
-        const newGroup = {
-            name,
-            title,
-            description,
-            icon,
-            groups: [],
-            sections: [],
-        };
-        this.rootGroups.push(newGroup);
-        this.groupMap.set(name, newGroup); // Index by name
-        return new AXPSettingDefinitionGroupBuilder(this, newGroup);
-    }
-    group(name) {
-        const foundGroup = this.groupMap.get(name);
-        if (!foundGroup) {
-            throw new Error(`Group with name "${name}" not found.`);
-        }
-        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
-    }
-    getGroups() {
-        return this.rootGroups;
-    }
-    // Expose groupMap for controlled access
-    hasGroup(name) {
-        return this.groupMap.has(name);
-    }
-    getGroup(name) {
-        return this.groupMap.get(name);
-    }
-}
-class AXPSettingDefinitionGroupBuilder {
-    constructor(context, group) {
-        this.context = context;
-        this.group = group;
-    }
-    addSection(name, title, description) {
-        const newSection = {
-            name,
-            title,
-            description: description,
-            settings: [],
-        };
-        this.group.sections.push(newSection);
-        return new AXPSettingDefinitionSectionBuilder(this, newSection);
-    }
-    section(name) {
-        const foundSection = this.group.sections.find((section) => section.name === name);
-        if (!foundSection) {
-            throw new Error(`Section with name "${name}" not found in group "${this.group.name}".`);
-        }
-        return new AXPSettingDefinitionSectionBuilder(this, foundSection);
-    }
-    addGroup(name, title, description, icon) {
-        const newGroup = {
-            name,
-            title,
-            description: description,
-            icon,
-            groups: [],
-            sections: [],
-        };
-        this.group.groups.push(newGroup);
-        if (this.context.hasGroup(name)) {
-            throw new Error(`Group with name "${name}" already exists.`);
-        }
-        this.context['groupMap'].set(name, newGroup);
-        return new AXPSettingDefinitionGroupBuilder(this.context, newGroup);
-    }
-    endGroup() {
-        return this.context;
-    }
-}
-class AXPSettingDefinitionSectionBuilder {
-    constructor(groupBuilder, section) {
-        this.groupBuilder = groupBuilder;
-        this.section = section;
-    }
-    addSetting(setting) {
-        const newSetting = {
-            name: setting.key,
-            title: setting.title,
-            description: setting.description,
-            isRequired: setting.isRequired ?? false,
-            isInherited: setting.isInherited ?? false,
-            isEncrypted: setting.isEncrypted ?? false,
-            defaultValue: setting.defaultValue,
-            scope: setting.scope ?? 'G',
-            widget: {
-                type: setting.widget.type,
-                name: setting.key,
-                path: setting.key,
-                defaultValue: setting.defaultValue,
-                options: merge(setting.widget.options ?? {}, {
-                    label: setting.widget.options?.['label'] ?? setting.title,
-                    validationRules: setting.validationRules ?? [],
-                }),
-                valueTransforms: setting.valueTransforms,
-                triggers: setting.widget.triggers,
-            },
-        };
-        this.section.settings.push(newSetting);
-        return this;
-    }
-    endSection() {
-        return this.groupBuilder;
-    }
-}
-
-// Injection token for setting providers
-const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
-class AXPSettingDefinitionProviderService {
-    constructor() {
-        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
-        this.cache = null;
-    }
-    async load() {
-        if (this.cache) {
-            return;
-        }
-        const context = new AXPSettingDefinitionProviderContext();
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                await provider.provide(context);
-            }
-        }
-        this.cache = context.getGroups();
-    }
-    async getListAsync(scope) {
-        await this.load();
-        return this.getList(scope);
-    }
-    getList(scope) {
-        if (!this.cache) {
-            return [];
-        }
-        const scopeOrder = ['C', 'G', 'T', 'U']; // Scopes hierarchy in ascending order
-        const filterByScope = (groups, currentScope) => {
-            const currentScopeIndex = scopeOrder.indexOf(currentScope);
-            return groups
-                .map((group) => ({
-                ...group,
-                sections: group.sections.map((section) => ({
-                    ...section,
-                    settings: section.settings.filter((setting) => {
-                        const settingScopeIndex = scopeOrder.indexOf(setting.scope);
-                        // Include settings where:
-                        // 1. The scope matches the requested scope.
-                        if (setting.scope === currentScope)
-                            return true;
-                        // 2. The setting scope is higher (closer to 'U') and is inherited.
-                        if (setting.isInherited &&
-                            settingScopeIndex > currentScopeIndex // Higher scope
-                        ) {
-                            return true;
-                        }
-                        // 3. Exclude settings with a lower or irrelevant scope.
-                        return false;
-                    }),
-                })).filter((section) => section.settings.length > 0), // Keep only sections with settings
-                groups: filterByScope(group.groups, currentScope), // Recursively filter nested groups
-            }))
-                .filter((group) => group.sections.length > 0 || group.groups.length > 0); // Keep groups with valid sections or nested groups
-        };
-        return filterByScope(this.cache, scope);
-    }
-    async defaultValues() {
-        const defaults = {};
-        const collectDefaults = (groups) => {
-            groups.forEach((group) => {
-                group.sections.forEach((section) => {
-                    section.settings.forEach((setting) => {
-                        if (setting.defaultValue !== undefined) {
-                            defaults[setting.name] = setting.defaultValue;
-                        }
-                    });
-                });
-                collectDefaults(group.groups);
-            });
-        };
-        if (!this.cache) {
-            await this.load();
-        }
-        collectDefaults(this.cache);
-        return defaults;
-    }
-    findGroup(scope, groupName) {
-        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
-    }
-    searchRecursive(groups, groupName, breadcrumb) {
-        for (const group of groups) {
-            const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title, description: group.description }];
-            // If the group name matches, return its details
-            if (group.name === groupName) {
-                return {
-                    breadcrumb: currentBreadcrumb,
-                    sections: group.sections.length > 0 ? group.sections : null,
-                    groups: group.groups.length > 0 ? group.groups : null,
-                };
-            }
-            // Recursively search in nested groups
-            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
-            if (nestedResult.breadcrumb.length > 0) {
-                return nestedResult;
-            }
-        }
-        // If no matching group is found
-        return {
-            breadcrumb: [],
-            groups: [],
-            sections: []
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class AXPSettingDefaultValueProvider {
-    constructor() {
-        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
-    }
-    get scope() {
-        return AXPSettingScope.Global;
-    }
-    async load() {
-        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
-    }
-    set(key, value) {
-        throw new Error('Method not implemented.');
-    }
-}
-
-const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
-    providedIn: 'root',
-    factory: () => {
-        return [
-            //new AXPSettingDefaultValueProvider(),
-            new AXPSettingValueProviderDefault(AXPSettingScope.Tenant),
-            new AXPSettingValueProviderDefault(AXPSettingScope.User)
-        ];
-    }
-});
-class AXPSettingValueProviderDefault {
-    get scope() {
-        return this._scope;
-    }
-    constructor(_scope) {
-        this._scope = _scope;
-        this.cache = new Map();
-        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
-    }
-    async load() {
-        // Load settings from localStorage as a single key
-        const storedSettings = localStorage.getItem(this.localStorageKey);
-        if (storedSettings) {
-            const parsedSettings = JSON.parse(storedSettings);
-            Object.entries(parsedSettings).forEach(([key, value]) => {
-                this.cache.set(key, value);
-            });
-            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
-        }
-        return Promise.resolve([]);
-    }
-    async set(keyOrValues, value) {
-        if (typeof keyOrValues === 'string') {
-            // Single value update
-            this.cache.set(keyOrValues, value);
-        }
-        else {
-            // Bulk update
-            for (const [key, val] of Object.entries(keyOrValues)) {
-                this.cache.set(key, val);
-            }
-        }
-        await this.saveToLocalStorage();
-    }
-    async saveToLocalStorage() {
-        const settingsObject = {};
-        this.cache.forEach((value, key) => {
-            settingsObject[key] = value;
-        });
-        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
-    }
-}
-
-class AXPSettingValueProviderService {
-    constructor() {
-        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
-        this.definitionService = inject(AXPSettingDefinitionProviderService);
-        this.scopedSettingsCache = new Map();
-        this.onChanged = new Subject();
-        // Initialize scoped caches for dynamic scopes
-        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
-        staticScopes.forEach((scope) => {
-            if (!this.scopedSettingsCache.has(scope)) {
-                this.scopedSettingsCache.set(scope, new Map());
-            }
-        });
-    }
-    async load() {
-        try {
-            const settingsList = [];
-            for (const provider of this.providers) {
-                const scopeCache = this.scopedSettingsCache.get(provider.scope);
-                const providerSettings = await provider.load();
-                providerSettings.forEach((setting) => {
-                    scopeCache.set(setting.key, setting.value);
-                });
-                settingsList.push(...providerSettings);
-            }
-            return settingsList;
-        }
-        catch (error) {
-            console.error('Error loading settings', error);
-            throw error;
-        }
-    }
-    async get(key) {
-        if (this.scopedSettingsCache.size === 0) {
-            await this.load();
-        }
-        const scopeOrder = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
-        for (const scope of scopeOrder) {
-            const scopeCache = this.scopedSettingsCache.get(scope);
-            if (scopeCache && scopeCache.has(key)) {
-                const value = scopeCache.get(key);
-                if (value !== undefined && value !== null) {
-                    return cloneDeep(value);
-                }
-            }
-        }
-        const defaults = await this.definitionService.defaultValues();
-        return get(defaults, key); // Fallback if no value is found
-    }
-    async defaultValues(scope) {
-        let scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User].reverse();
-        const scopeIndex = scopeOrder.indexOf(scope);
-        if (scopeIndex === -1) {
-            throw new Error(`Invalid scope: ${scope}`);
-        }
-        scopeOrder = scopeOrder.slice(scopeIndex + 1);
-        // Accumulate defaults from the current scope and higher scopes
-        const accumulatedDefaults = {};
-        for (let i = scopeIndex; i < scopeOrder.length; i++) {
-            const currentScope = scopeOrder[i];
-            const scopeCache = this.scopedSettingsCache.get(currentScope);
-            if (scopeCache) {
-                scopeCache.forEach((value, key) => {
-                    if (!(key in accumulatedDefaults)) {
-                        accumulatedDefaults[key] = value;
-                    }
-                });
-            }
-        }
-        // Merge with global default values from the definition service
-        const globalDefaults = await this.definitionService.defaultValues();
-        return { ...globalDefaults, ...accumulatedDefaults };
-    }
-    scope(scope) {
-        const provider = this.providers.find((p) => p.scope === scope);
-        if (!provider) {
-            throw new Error(`No provider found for scope: ${scope}`);
-        }
-        return new ScopedSettingService(this, provider, this.onChanged, this.scopedSettingsCache.get(scope));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-class ScopedSettingService {
-    constructor(parent, provider, onChanged, scopeCache) {
-        this.parent = parent;
-        this.provider = provider;
-        this.onChanged = onChanged;
-        this.scopeCache = scopeCache;
-    }
-    async get(key) {
-        const settings = await this.provider.load();
-        const setting = settings.find((s) => s.key === key);
-        return setting ? cloneDeep(setting.value) : undefined;
-    }
-    async all() {
-        const settings = await this.provider.load();
-        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
-    }
-    async defaultValues() {
-        return this.parent.defaultValues(this.provider.scope);
-    }
-    async set(keyOrValues, value) {
-        if (typeof keyOrValues === 'string') {
-            // Single key-value pair
-            await this.provider.set(keyOrValues, value);
-            this.scopeCache.set(keyOrValues, value); // Sync the cache
-            this.onChanged.next({
-                scope: this.provider.scope,
-                keys: [keyOrValues],
-                values: { [keyOrValues]: value },
-                entries: [{ key: keyOrValues, value }],
-            });
-        }
-        else {
-            // Multiple key-value pairs
-            await this.provider.set(keyOrValues);
-            Object.entries(keyOrValues).forEach(([key, val]) => this.scopeCache.set(key, val)); // Sync the cache
-            const entries = Object.entries(keyOrValues).map(([key, val]) => ({ key, value: val }));
-            this.onChanged.next({
-                scope: this.provider.scope,
-                keys: Object.keys(keyOrValues),
-                values: keyOrValues,
-                entries,
-            });
-        }
-    }
-}
-
-class AXPCommonEffects {
-    constructor(actions$, router, settingService) {
-        this.actions$ = actions$;
-        this.router = router;
-        this.settingService = settingService;
-        this.command$ = createEffect(() => this.actions$.pipe(ofType(AXPNavigateAction), switchMap((action) => {
-            if (Array.isArray(action.payload.commands))
-                this.router.navigate(action.payload.commands, action.payload.extras);
-            else {
-                if (action.payload.commands.toLowerCase().startsWith('http'))
-                    window.open(action.payload.commands, '_blank');
-                else
-                    this.router.navigate([action.payload.commands], action.payload.extras);
-            }
-            return of();
-        })), { dispatch: false });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1$1.Actions }, { token: i2$1.Router }, { token: AXPSettingValueProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.Actions }, { type: i2$1.Router }, { type: AXPSettingValueProviderService }] });
-
 const AXPMenuService = signalStore({ providedIn: 'root' }, 
 // Initial State
 withState((router = inject(Router)) => {
@@ -1754,7 +1287,7 @@ withState((router = inject(Router)) => {
     };
 }), 
 // Methods for State Management
-withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
+withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowService)) => {
     return {
         setMenuItems(items) {
             patchState(store, { items: items });
@@ -1812,11 +1345,11 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
             patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
         },
         executeCommand(item) {
-            if (item.command) {
-                globalStore.dispatch(item.command);
+            if (item.path) {
+                workflow.execute('navigate', { type: 'router', options: { path: item.path } });
             }
-            else if (item.path) {
-                globalStore.dispatch(AXPNavigateAction({ payload: { commands: item.path } }));
+            if (item.command) {
+                workflow.execute('navigate', item.command);
             }
             patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
         },
@@ -1847,39 +1380,49 @@ withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
 
 class AXPMenuSearchDefinitionProvider {
     async provide(context) {
-        context.addDefinition('menu', 'Menu', 'fa-thin fa-bars', [
-            {
-                name: 'open',
-                command: {
-                    name: 'view',
-                    options: {},
-                },
-                type: 'view',
-                priority: 'primary',
+        context.addDefinition('menu', 'Menu', 'fa-thin fa-bars', 2, {
+            format: {
+                id: '{{data.name}}',
             },
-        ]);
+            actions: [
+                {
+                    name: 'navigate',
+                    type: 'view',
+                    priority: 'primary',
+                },
+            ],
+        });
     }
 }
 
 class AXPMenuSearchProvider {
     constructor() {
         this.menuService = inject(AXPMenuProviderService);
-        this.trService = inject(AXTranslationService);
+        this.translateService = inject(AXTranslationService);
     }
     async search(text) {
         const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
         return sortBy(menuItems.map((item) => ({
-            name: 'menu', // Use `name` or empty string if undefined
+            group: 'menu', // Use `name` or empty string if undefined
             title: item.text, // Use `text` for the `title`
             icon: item.icon, // Include the `icon` if present
-            data: item,
+            data: omit(item, ['parent', 'children']), // Include all data except `parent` and `children`
+            commands: {
+                navigate: {
+                    ...(item.command ?? {
+                        type: 'router',
+                        options: {
+                            path: item.path,
+                        },
+                    }),
+                },
+            },
             parent: item.parent
                 ? {
                     title: item.parent.text,
-                    data: item.parent,
                 }
                 : undefined,
-        })), [(o) => this.trService.translateSync(o.title)]);
+        })), [(o) => this.translateService.translateSync(o.title)]);
     }
     /**
      * Recursively searches AXPMenuItem and its children for a matching text.
@@ -1894,7 +1437,7 @@ class AXPMenuSearchProvider {
             // Check if the current item's text matches the search text
             if (item.type != 'group' &&
                 (item.children?.length ?? 0) == 0 &&
-                (await this.trService.translateAsync(item.text)).toLowerCase().includes(searchText.toLowerCase())) {
+                (await this.translateService.translateAsync(item.text)).toLowerCase().includes(searchText.toLowerCase())) {
                 result.push(item);
             }
             // Recursively search in children if they exist
@@ -1960,12 +1503,19 @@ class AXPSearchDefinitionProviderContext {
         this.definitions = [];
         this.definitionMap = new Map();
     }
-    addDefinition(name, title, icon, actions) {
+    addDefinition(name, title, icon, order, options) {
         const definitionSearch = {
             name,
             title,
             icon,
-            actions: actions ?? [],
+            order,
+            format: {
+                title: options?.format?.title ?? '{{ title }}',
+                description: options?.format?.description ?? undefined,
+                icon: options?.format?.icon ?? undefined,
+                id: options?.format?.id ?? '{{ id }}',
+            },
+            actions: options?.actions ?? [],
         };
         this.definitions.push(definitionSearch);
         this.definitionMap.set(name, definitionSearch); // Index by name
@@ -1982,227 +1532,641 @@ class AXPSearchDefinitionProviderContext {
         return this.definitions;
     }
     // Expose groupMap for controlled access
-    hasEntity(name) {
-        return this.definitionMap.has(name);
+    hasEntity(name) {
+        return this.definitionMap.has(name);
+    }
+    getDefinition(name) {
+        return this.definitionMap.get(name);
+    }
+}
+class AXPSearchDefinitionBuilder {
+    constructor(context, definition) {
+        this.context = context;
+        this.definition = definition;
+    }
+    addAction(name) {
+        const newAction = {
+            name,
+            type: 'view',
+            priority: 'primary',
+        };
+        this.definition.actions.push(newAction);
+        return new AXPSearchDefinitionActionBuilder(this);
+    }
+    action(name) {
+        const foundAction = this.definition.actions.find((action) => action.name === name);
+        if (!foundAction) {
+            throw new Error(`action with name "${name}" not found in entity "${this.definition.name}".`);
+        }
+        return new AXPSearchDefinitionActionBuilder(this);
+    }
+    // addGroup(name: string, title: string, description?: string, icon?: string): AXPTextSearchEntityBuilder {
+    //   const newGroup: AXPTextSearchEntity = {
+    //     name,
+    //     title,
+    //     description: description,
+    //     icon,
+    //     groups: [],
+    //     sections: [],
+    //   };
+    //   this.entity.groups.push(newGroup);
+    //   if (this.context.hasGroup(name)) {
+    //     throw new Error(`Group with name "${name}" already exists.`);
+    //   }
+    //   this.context['groupMap'].set(name, newGroup);
+    //   return new AXPTextSearchEntityBuilder(this.context, newGroup);
+    // }
+    endEntity() {
+        return this.context;
+    }
+}
+class AXPSearchDefinitionActionBuilder {
+    constructor(entityBuilder) {
+        this.entityBuilder = entityBuilder;
+    }
+    endAction() {
+        return this.entityBuilder;
+    }
+}
+
+// Injection token for setting providers
+const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION_PROVIDER');
+class AXPSearchDefinitionProviderService {
+    constructor() {
+        this.providers = inject(AXP_SEARCH_DEFINITION_PROVIDER, { optional: true });
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSearchDefinitionProviderContext();
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        this.cache = context.getDefinitions();
+    }
+    async getListAsync() {
+        await this.load();
+        return this.getList();
+    }
+    getList() {
+        if (!this.cache) {
+            return [];
+        }
+        else {
+            return this.cache;
+        }
+    }
+    findDefinition(definitionName) {
+        const definition = this.getList().find((definition) => definition.name === definitionName);
+        if (!definition) {
+            throw new Error(`Definition with name ${definitionName} not found`);
+        }
+        return definition;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPSearchCommandProvider {
+    async search(text) {
+        return this.commands.filter((command) => command.title.toLowerCase().includes(text.toLowerCase()));
+    }
+}
+
+// Injection token for setting providers
+const AXP_SEARCH_PROVIDER = new InjectionToken('AXP_SEARCH_PROVIDER');
+class AXPSearchService {
+    constructor() {
+        this.providers = inject(AXP_SEARCH_PROVIDER, { optional: true });
+        this.definitionService = inject(AXPSearchDefinitionProviderService);
+        this.formatService = inject(AXFormatService);
+    }
+    async search(text) {
+        //TODO better handle this
+        if (this.definitionService.getList().length == 0) {
+            await this.definitionService.getListAsync();
+        }
+        if (!this.providers || (this.providers?.length || 0) === 0) {
+            throw new Error('No search providers available'); // No providers available
+        }
+        const mergeData = [];
+        const promises = this.providers.map((provider) => provider.search(text));
+        const results = await Promise.all(promises);
+        for (const resultArray of results) {
+            for (const result of resultArray) {
+                try {
+                    const definition = this.definitionService.findDefinition(result.group);
+                    mergeData.push({
+                        definitionName: definition.name,
+                        definitionTitle: definition.title,
+                        name: result.group,
+                        id: `${definition.name}:${this.formatService.format(definition.format.id, 'string', result)}`,
+                        title: result.title ??
+                            (definition.format.title
+                                ? this.formatService.format(definition.format.title, 'string', result.data)
+                                : 'Unknown'),
+                        description: result.description ??
+                            (definition.format.description
+                                ? this.formatService.format(definition.format.description, 'string', result.data)
+                                : undefined),
+                        icon: result.icon ??
+                            (result.icon
+                                ? this.formatService.format(definition.format.icon, 'string', result.data)
+                                : definition.icon),
+                        data: result.data,
+                        commands: result.commands,
+                        actions: definition.actions,
+                        parent: result.parent,
+                        order: definition.order,
+                    });
+                }
+                catch (e) {
+                    //console.error(e);
+                }
+            }
+        }
+        // Group data
+        const groupedData = [];
+        const groupMap = {};
+        // Create groups
+        for (const item of mergeData) {
+            const groupName = item.definitionName; // Change this to the property you want to group by
+            if (!groupMap[groupName]) {
+                groupMap[groupName] = {
+                    name: groupName,
+                    title: item.definitionTitle, // You can adjust the title logic if needed
+                    order: item.order, // Add order to the group
+                    children: [],
+                };
+                groupedData.push(groupMap[groupName]);
+            }
+            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle', 'order']));
+        }
+        // Sort groups by order
+        groupedData.sort((a, b) => a.order - b.order);
+        return groupedData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var AXPSettingScope;
+(function (AXPSettingScope) {
+    AXPSettingScope["Environment"] = "C";
+    AXPSettingScope["Global"] = "G";
+    AXPSettingScope["Tenant"] = "T";
+    AXPSettingScope["User"] = "U";
+})(AXPSettingScope || (AXPSettingScope = {}));
+;
+
+class AXPSettingDefinitionProviderContext {
+    constructor() {
+        this.rootGroups = [];
+        this.groupMap = new Map();
+    }
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.rootGroups.push(newGroup);
+        this.groupMap.set(name, newGroup); // Index by name
+        return new AXPSettingDefinitionGroupBuilder(this, newGroup);
+    }
+    group(name) {
+        const foundGroup = this.groupMap.get(name);
+        if (!foundGroup) {
+            throw new Error(`Group with name "${name}" not found.`);
+        }
+        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
+    }
+    getGroups() {
+        return this.rootGroups;
+    }
+    // Expose groupMap for controlled access
+    hasGroup(name) {
+        return this.groupMap.has(name);
     }
-    getDefinition(name) {
-        return this.definitionMap.get(name);
+    getGroup(name) {
+        return this.groupMap.get(name);
     }
 }
-class AXPSearchDefinitionBuilder {
-    constructor(context, definition) {
+class AXPSettingDefinitionGroupBuilder {
+    constructor(context, group) {
         this.context = context;
-        this.definition = definition;
+        this.group = group;
     }
-    addAction(name) {
-        const newAction = {
+    addSection(name, title, description) {
+        const newSection = {
             name,
-            type: 'view',
-            command: '',
-            priority: 'primary',
+            title,
+            description: description,
+            settings: [],
         };
-        this.definition.actions.push(newAction);
-        return new AXPSearchDefinitionActionBuilder(this);
+        this.group.sections.push(newSection);
+        return new AXPSettingDefinitionSectionBuilder(this, newSection);
     }
-    action(name) {
-        const foundAction = this.definition.actions.find((action) => action.name === name);
-        if (!foundAction) {
-            throw new Error(`action with name "${name}" not found in entity "${this.definition.name}".`);
+    section(name) {
+        const foundSection = this.group.sections.find((section) => section.name === name);
+        if (!foundSection) {
+            throw new Error(`Section with name "${name}" not found in group "${this.group.name}".`);
         }
-        return new AXPSearchDefinitionActionBuilder(this);
+        return new AXPSettingDefinitionSectionBuilder(this, foundSection);
     }
-    // addGroup(name: string, title: string, description?: string, icon?: string): AXPTextSearchEntityBuilder {
-    //   const newGroup: AXPTextSearchEntity = {
-    //     name,
-    //     title,
-    //     description: description,
-    //     icon,
-    //     groups: [],
-    //     sections: [],
-    //   };
-    //   this.entity.groups.push(newGroup);
-    //   if (this.context.hasGroup(name)) {
-    //     throw new Error(`Group with name "${name}" already exists.`);
-    //   }
-    //   this.context['groupMap'].set(name, newGroup);
-    //   return new AXPTextSearchEntityBuilder(this.context, newGroup);
-    // }
-    endEntity() {
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description: description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.group.groups.push(newGroup);
+        if (this.context.hasGroup(name)) {
+            throw new Error(`Group with name "${name}" already exists.`);
+        }
+        this.context['groupMap'].set(name, newGroup);
+        return new AXPSettingDefinitionGroupBuilder(this.context, newGroup);
+    }
+    endGroup() {
         return this.context;
     }
 }
-class AXPSearchDefinitionActionBuilder {
-    constructor(entityBuilder) {
-        this.entityBuilder = entityBuilder;
+class AXPSettingDefinitionSectionBuilder {
+    constructor(groupBuilder, section) {
+        this.groupBuilder = groupBuilder;
+        this.section = section;
     }
-    endAction() {
-        return this.entityBuilder;
+    addSetting(setting) {
+        const newSetting = {
+            name: setting.key,
+            title: setting.title,
+            description: setting.description,
+            isRequired: setting.isRequired ?? false,
+            isInherited: setting.isInherited ?? false,
+            isEncrypted: setting.isEncrypted ?? false,
+            defaultValue: setting.defaultValue,
+            scope: setting.scope ?? 'G',
+            widget: {
+                type: setting.widget.type,
+                name: setting.key,
+                path: setting.key,
+                defaultValue: setting.defaultValue,
+                options: merge(setting.widget.options ?? {}, {
+                    label: setting.widget.options?.['label'] ?? setting.title,
+                    validationRules: setting.validationRules ?? [],
+                }),
+                valueTransforms: setting.valueTransforms,
+                triggers: setting.widget.triggers,
+            },
+        };
+        this.section.settings.push(newSetting);
+        return this;
+    }
+    endSection() {
+        return this.groupBuilder;
     }
 }
 
 // Injection token for setting providers
-const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION_PROVIDER');
-class AXPSearchDefinitionProviderService {
+const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
+class AXPSettingDefinitionProviderService {
     constructor() {
-        this.providers = inject(AXP_SEARCH_DEFINITION_PROVIDER, { optional: true });
+        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
         this.cache = null;
     }
     async load() {
         if (this.cache) {
             return;
         }
-        const context = new AXPSearchDefinitionProviderContext();
+        const context = new AXPSettingDefinitionProviderContext();
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
-                await provider.provide(context);
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
+            }
+        }
+        this.cache = context.getGroups();
+    }
+    async getListAsync(scope) {
+        await this.load();
+        return this.getList(scope);
+    }
+    getList(scope) {
+        if (!this.cache) {
+            return [];
+        }
+        const scopeOrder = ['C', 'G', 'T', 'U']; // Scopes hierarchy in ascending order
+        const filterByScope = (groups, currentScope) => {
+            const currentScopeIndex = scopeOrder.indexOf(currentScope);
+            return groups
+                .map((group) => ({
+                ...group,
+                sections: group.sections.map((section) => ({
+                    ...section,
+                    settings: section.settings.filter((setting) => {
+                        const settingScopeIndex = scopeOrder.indexOf(setting.scope);
+                        // Include settings where:
+                        // 1. The scope matches the requested scope.
+                        if (setting.scope === currentScope)
+                            return true;
+                        // 2. The setting scope is higher (closer to 'U') and is inherited.
+                        if (setting.isInherited &&
+                            settingScopeIndex > currentScopeIndex // Higher scope
+                        ) {
+                            return true;
+                        }
+                        // 3. Exclude settings with a lower or irrelevant scope.
+                        return false;
+                    }),
+                })).filter((section) => section.settings.length > 0), // Keep only sections with settings
+                groups: filterByScope(group.groups, currentScope), // Recursively filter nested groups
+            }))
+                .filter((group) => group.sections.length > 0 || group.groups.length > 0); // Keep groups with valid sections or nested groups
+        };
+        return filterByScope(this.cache, scope);
+    }
+    async defaultValues() {
+        const defaults = {};
+        const collectDefaults = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        if (setting.defaultValue !== undefined) {
+                            defaults[setting.name] = setting.defaultValue;
+                        }
+                    });
+                });
+                collectDefaults(group.groups);
+            });
+        };
+        if (!this.cache) {
+            await this.load();
+        }
+        collectDefaults(this.cache);
+        return defaults;
+    }
+    findGroup(scope, groupName) {
+        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
+    }
+    searchRecursive(groups, groupName, breadcrumb) {
+        for (const group of groups) {
+            const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title, description: group.description }];
+            // If the group name matches, return its details
+            if (group.name === groupName) {
+                return {
+                    breadcrumb: currentBreadcrumb,
+                    sections: group.sections.length > 0 ? group.sections : null,
+                    groups: group.groups.length > 0 ? group.groups : null,
+                };
+            }
+            // Recursively search in nested groups
+            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
+            if (nestedResult.breadcrumb.length > 0) {
+                return nestedResult;
             }
         }
-        this.cache = context.getDefinitions();
-    }
-    async getListAsync() {
-        await this.load();
-        return this.getList();
+        // If no matching group is found
+        return {
+            breadcrumb: [],
+            groups: [],
+            sections: []
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class AXPSettingDefaultValueProvider {
+    constructor() {
+        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
+    }
+    get scope() {
+        return AXPSettingScope.Global;
+    }
+    async load() {
+        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
+    }
+    set(key, value) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return [
+            //new AXPSettingDefaultValueProvider(),
+            new AXPSettingValueProviderDefault(AXPSettingScope.Tenant),
+            new AXPSettingValueProviderDefault(AXPSettingScope.User)
+        ];
+    }
+});
+class AXPSettingValueProviderDefault {
+    get scope() {
+        return this._scope;
+    }
+    constructor(_scope) {
+        this._scope = _scope;
+        this.cache = new Map();
+        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
+    }
+    async load() {
+        // Load settings from localStorage as a single key
+        const storedSettings = localStorage.getItem(this.localStorageKey);
+        if (storedSettings) {
+            const parsedSettings = JSON.parse(storedSettings);
+            Object.entries(parsedSettings).forEach(([key, value]) => {
+                this.cache.set(key, value);
+            });
+            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
+        }
+        return Promise.resolve([]);
     }
-    getList() {
-        if (!this.cache) {
-            return [];
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single value update
+            this.cache.set(keyOrValues, value);
         }
         else {
-            return this.cache;
+            // Bulk update
+            for (const [key, val] of Object.entries(keyOrValues)) {
+                this.cache.set(key, val);
+            }
         }
+        await this.saveToLocalStorage();
     }
-    findDefinition(definitionName) {
-        const definition = this.getList().find((definition) => definition.name === definitionName);
-        if (!definition) {
-            throw new Error(`Definition with name ${definitionName} not found`);
-        }
-        return definition;
+    async saveToLocalStorage() {
+        const settingsObject = {};
+        this.cache.forEach((value, key) => {
+            settingsObject[key] = value;
+        });
+        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
 
-// Injection token for setting providers
-const AXP_SEARCH_PROVIDER = new InjectionToken('AXP_SEARCH_PROVIDER');
-class AXPSearchService {
+class AXPSettingService {
     constructor() {
-        this.providers = inject(AXP_SEARCH_PROVIDER, { optional: true });
-        this.definitionService = inject(AXPSearchDefinitionProviderService);
+        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
+        //private readonly definitionService = inject(AXPSettingDefinitionProviderService);
+        this.injector = inject(Injector);
+        this.scopedSettingsCache = new Map();
+        this.onChanged = new Subject();
+        // Initialize scoped caches for dynamic scopes
+        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
+        staticScopes.forEach((scope) => {
+            if (!this.scopedSettingsCache.has(scope)) {
+                this.scopedSettingsCache.set(scope, new Map());
+            }
+        });
     }
-    async search(text) {
-        //TODO better handle this
-        if (this.definitionService.getList().length == 0) {
-            await this.definitionService.getListAsync();
+    async load() {
+        try {
+            const settingsList = [];
+            for (const provider of this.providers) {
+                const scopeCache = this.scopedSettingsCache.get(provider.scope);
+                const providerSettings = await provider.load();
+                providerSettings.forEach((setting) => {
+                    scopeCache.set(setting.key, setting.value);
+                });
+                settingsList.push(...providerSettings);
+            }
+            return settingsList;
         }
-        if (!this.providers || (this.providers?.length || 0) === 0) {
-            throw new Error('No search providers available'); // No providers available
+        catch (error) {
+            console.error('Error loading settings', error);
+            throw error;
         }
-        const mergeData = [];
-        const promises = this.providers.map((provider) => provider.search(text));
-        const results = await Promise.all(promises);
-        for (const resultArray of results) {
-            for (const result of resultArray) {
-                try {
-                    const definition = this.definitionService.findDefinition(result.name);
-                    mergeData.push({
-                        definitionName: definition.name,
-                        definitionTitle: definition.title,
-                        name: result.name,
-                        title: result.title,
-                        icon: result.icon ?? definition.icon,
-                        data: result.data,
-                        actions: definition.actions,
-                        description: result.description,
-                        parent: result.parent,
-                    });
-                }
-                catch (e) {
-                    console.error(e);
+    }
+    async get(key) {
+        if (this.scopedSettingsCache.size === 0) {
+            await this.load();
+        }
+        const scopeOrder = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
+        for (const scope of scopeOrder) {
+            const scopeCache = this.scopedSettingsCache.get(scope);
+            if (scopeCache && scopeCache.has(key)) {
+                const value = scopeCache.get(key);
+                if (value !== undefined && value !== null) {
+                    return cloneDeep(value);
                 }
             }
         }
-        // Group data
-        const groupedData = [];
-        const groupMap = {};
-        // Create groups
-        for (const item of mergeData) {
-            const groupName = item.definitionName; // Change this to the property you want to group by
-            if (!groupMap[groupName]) {
-                groupMap[groupName] = {
-                    name: groupName,
-                    title: item.definitionTitle, // You can adjust the title logic if needed
-                    children: [],
-                };
-                groupedData.push(groupMap[groupName]);
+        const definitionService = this.injector.get(AXPSettingDefinitionProviderService);
+        const defaults = await definitionService.defaultValues();
+        return get(defaults, key); // Fallback if no value is found
+    }
+    async defaultValues(scope) {
+        let scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User].reverse();
+        const scopeIndex = scopeOrder.indexOf(scope);
+        if (scopeIndex === -1) {
+            throw new Error(`Invalid scope: ${scope}`);
+        }
+        scopeOrder = scopeOrder.slice(scopeIndex + 1);
+        // Accumulate defaults from the current scope and higher scopes
+        const accumulatedDefaults = {};
+        for (let i = scopeIndex; i < scopeOrder.length; i++) {
+            const currentScope = scopeOrder[i];
+            const scopeCache = this.scopedSettingsCache.get(currentScope);
+            if (scopeCache) {
+                scopeCache.forEach((value, key) => {
+                    if (!(key in accumulatedDefaults)) {
+                        accumulatedDefaults[key] = value;
+                    }
+                });
             }
-            groupMap[groupName].children.push(omit(item, ['definitionName', 'definitionTitle']));
         }
-        return groupedData;
+        // Merge with global default values from the definition service
+        const definitionService = this.injector.get(AXPSettingDefinitionProviderService);
+        const globalDefaults = await definitionService.defaultValues();
+        return { ...globalDefaults, ...accumulatedDefaults };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, providedIn: 'root' }); }
+    scope(scope) {
+        const provider = this.providers.find((p) => p.scope === scope);
+        if (!provider) {
+            throw new Error(`No provider found for scope: ${scope}`);
+        }
+        return new ScopedSettingService(this, provider, this.onChanged, this.scopedSettingsCache.get(scope));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class AXPSettingSearchDefinitionProvider {
-    async provide(context) {
-        context.addDefinition('setting', 'Setting', 'fa-solid fa-gear', [
-            {
-                name: 'open',
-                command: {
-                    name: 'view',
-                    options: {},
-                },
-                type: 'view',
-                priority: 'primary',
-            },
-        ]);
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, onChanged, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.onChanged = onChanged;
+        this.scopeCache = scopeCache;
     }
-}
-
-class AXPSettingSearchProvider {
-    constructor() {
-        this.settingService = inject(AXPSettingDefinitionProviderService);
+    async get(key) {
+        const settings = await this.provider.load();
+        const setting = settings.find((s) => s.key === key);
+        return setting ? cloneDeep(setting.value) : undefined;
     }
-    async search(text) {
-        const groupsSetting = this.settingService.getList(AXPSettingScope.User);
-        if (groupsSetting.length == 0) {
-            groupsSetting.push(...(await this.settingService.getListAsync(AXPSettingScope.User)));
-        }
-        // Step 2: Flatten settings from groups
-        const allSettings = [];
-        const extractSettings = (group) => {
-            for (const section of group.sections) {
-                allSettings.push(...section.settings.map((x) => ({ ...x, group })));
-            }
-            for (const subGroup of group.groups) {
-                extractSettings(subGroup); // Recursive extraction
-            }
-        };
-        for (const group of groupsSetting) {
-            extractSettings(group);
+    async all() {
+        const settings = await this.provider.load();
+        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
+    }
+    async defaultValues() {
+        return this.parent.defaultValues(this.provider.scope);
+    }
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single key-value pair
+            await this.provider.set(keyOrValues, value);
+            this.scopeCache.set(keyOrValues, value); // Sync the cache
+            this.onChanged.next({
+                scope: this.provider.scope,
+                keys: [keyOrValues],
+                values: { [keyOrValues]: value },
+                entries: [{ key: keyOrValues, value }],
+            });
+        }
+        else {
+            // Multiple key-value pairs
+            await this.provider.set(keyOrValues);
+            Object.entries(keyOrValues).forEach(([key, val]) => this.scopeCache.set(key, val)); // Sync the cache
+            const entries = Object.entries(keyOrValues).map(([key, val]) => ({ key, value: val }));
+            this.onChanged.next({
+                scope: this.provider.scope,
+                keys: Object.keys(keyOrValues),
+                values: keyOrValues,
+                entries,
+            });
         }
-        // Step 3: Search settings by title
-        const searchResults = allSettings.filter((setting) => setting.title.toLowerCase().includes(text.toLowerCase()));
-        return sortBy(searchResults.map((setting) => ({
-            title: setting.title,
-            description: setting.description,
-            name: 'setting',
-            data: setting,
-            parent: setting.group
-                ? {
-                    title: setting.group.title,
-                    data: setting.group,
-                }
-                : undefined,
-        })), ['title']);
     }
 }
 
@@ -2273,6 +2237,57 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: Injectable
         }] });
 
+class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
+    }
+    async execute(context) {
+        const command = context.getVariable();
+        const path = command.options.path;
+        if (path.toLowerCase().startsWith('http') || command.options?.extras?.target === 'blank') {
+            window.open(path, '_blank');
+        }
+        else {
+            const [basePathAndFragment, queryString] = path.split('?');
+            const [basePath, fragment] = basePathAndFragment.split('#'); // Extract fragment if present
+            const queryParams = this.parseQueryParams(queryString);
+            this.router.navigate([basePath], {
+                ...command.options.extras,
+                queryParams, // Pass query parameters separately
+                fragment, // Pass fragment explicitly
+            });
+        }
+    }
+    /**
+     * Parses query parameters from a query string into an object.
+     */
+    parseQueryParams(queryString) {
+        if (!queryString)
+            return undefined;
+        return queryString
+            .split('&')
+            .map(pair => pair.split('='))
+            .reduce((params, [key, value]) => {
+            params[decodeURIComponent(key)] = decodeURIComponent(value);
+            return params;
+        }, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPWorkflowRouterNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPNavigateWorkflow = {
+    startStepId: 'start',
+    steps: {
+        'start': {
+            action: 'navigate-router',
+        },
+    },
+};
+
 class AXMWorkflowErrorHandler {
     constructor() {
         this.dialog = inject(AXDialogService);
@@ -2333,17 +2348,6 @@ class AXPCommonModule {
         instances.forEach((f) => {
             f();
         });
-        // appInitService.registerTask({
-        //   name: 'Modules',
-        //   statusText: 'Initializing Modules ...',
-        //   run: () =>
-        //     new Promise<void>((resolve) => {
-        //       setTimeout(() => {
-        //         resolve();
-        //       }, 250);
-        //     }),
-        // });
-        //
         appInitService.registerTask({
             name: 'Settings',
             statusText: 'Loading Settings ...',
@@ -2361,8 +2365,8 @@ class AXPCommonModule {
             },
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingValueProviderService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, imports: [i1$1.EffectsFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, imports: [i4.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule], exports: [RouterModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, providers: [
@@ -2379,33 +2383,25 @@ class AXPCommonModule {
                 provide: AXPFilterOperatorMiddlewareService,
                 useClass: AXPFilterOperatorMiddlewareServiceImpl,
             },
-            {
-                provide: AXP_SEARCH_PROVIDER,
-                useClass: AXPSettingSearchProvider,
-                multi: true,
-            },
             {
                 provide: AXP_SEARCH_PROVIDER,
                 useClass: AXPMenuSearchProvider,
                 multi: true,
             },
-            {
-                provide: AXP_SEARCH_DEFINITION_PROVIDER,
-                useClass: AXPSettingSearchDefinitionProvider,
-                multi: true,
-            },
             {
                 provide: AXP_SEARCH_DEFINITION_PROVIDER,
                 useClass: AXPMenuSearchDefinitionProvider,
                 multi: true,
             },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects]),
-            AXPWorkflowModule.forChild({
+        ], imports: [AXPWorkflowModule.forChild({
                 actions: {
-                    navigate: AXPDialogConfirmAction,
+                    'navigate-router': AXPWorkflowRouterNavigateAction,
                     'show-prompt-dialog': AXPDialogConfirmAction,
                     'show-toast': AXPToastAction,
                 },
+                workflows: {
+                    'navigate': AXPNavigateWorkflow
+                }
             }),
             AXPopupModule,
             AXDateTimeModule,
@@ -2415,13 +2411,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             type: NgModule,
             args: [{
                     imports: [
-                        EffectsModule.forFeature([AXPCommonEffects]),
                         AXPWorkflowModule.forChild({
                             actions: {
-                                navigate: AXPDialogConfirmAction,
+                                'navigate-router': AXPWorkflowRouterNavigateAction,
                                 'show-prompt-dialog': AXPDialogConfirmAction,
                                 'show-toast': AXPToastAction,
                             },
+                            workflows: {
+                                'navigate': AXPNavigateWorkflow
+                            }
                         }),
                         AXPopupModule,
                         AXDateTimeModule,
@@ -2442,21 +2440,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                             provide: AXPFilterOperatorMiddlewareService,
                             useClass: AXPFilterOperatorMiddlewareServiceImpl,
                         },
-                        {
-                            provide: AXP_SEARCH_PROVIDER,
-                            useClass: AXPSettingSearchProvider,
-                            multi: true,
-                        },
                         {
                             provide: AXP_SEARCH_PROVIDER,
                             useClass: AXPMenuSearchProvider,
                             multi: true,
                         },
-                        {
-                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
-                            useClass: AXPSettingSearchDefinitionProvider,
-                            multi: true,
-                        },
                         {
                             provide: AXP_SEARCH_DEFINITION_PROVIDER,
                             useClass: AXPMenuSearchDefinitionProvider,
@@ -2467,7 +2455,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['AXPCommonModuleFactory']
-                }] }, { type: AXPAppStartUpService }, { type: AXPSettingValueProviderService }, { type: AXPDataSeederService }] });
+                }] }, { type: AXPAppStartUpService }, { type: AXPSettingService }, { type: AXPDataSeederService }] });
 
 const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
 const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
@@ -2528,9 +2516,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
                 }]
         }] });
 
+const AXPSignOutAction = createAction('[SignOut] Action');
+const AXPSignInAction = createAction('[SignIn] Action');
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityQueryType, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, getEntityInfo, resolveActionLook };
+export { ALL_DEFAULT_OPERATORS, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityQueryType, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFileStorageService, AXPFileStorageStatus, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingScope, AXPSettingService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, getEntityInfo, resolveActionLook };
 //# sourceMappingURL=acorex-platform-common.mjs.map