@acorex/platform 19.3.0-next.1 → 19.3.0-next.3

package/fesm2022/acorex-platform-common.mjs

@@ -1,12 +1,17 @@
 import * as i0 from '@angular/core';
-import { Injectable, provideAppInitializer, inject, InjectionToken, Injector, ErrorHandler, Input, Directive, EventEmitter, Output, runInInjectionContext, Optional, Inject, NgModule, Component, computed, ViewEncapsulation, signal, model, linkedSignal, afterNextRender } from '@angular/core';
-import { kebabCase, sortBy, omit, merge, cloneDeep, get } from 'lodash-es';
+import { Injectable, provideAppInitializer, inject, InjectionToken, Injector, makeEnvironmentProviders, NgModule, ErrorHandler, Input, Directive, EventEmitter, Output, runInInjectionContext, Optional, Inject, Component, computed, ViewEncapsulation, signal, model, linkedSignal, afterNextRender } from '@angular/core';
+import { kebabCase, merge, cloneDeep, get, sortBy, omit } from 'lodash-es';
+import { ROUTES, Router, RouterModule } from '@angular/router';
+import { AXPSessionService } from '@acorex/platform/auth';
+import { Subject, merge as merge$1 } from 'rxjs';
+import { AXPPlatformScope, AXPBroadcastEventService, objectKeyValueTransforms, AXPComponentLogoConfig, AXPFontIconLogoConfig, AXPImageUrlLogoConfig, AXPTextLogoConfig } from '@acorex/platform/core';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
 import { AXPopupModule, AXPopupService } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
 import * as i3 from '@acorex/platform/workflow';
 import { AXPWorkflowService, createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
-import { Router, RouterModule } from '@angular/router';
 import * as i4 from '@acorex/components/decorators';
 import { AXDecoratorModule } from '@acorex/components/decorators';
 import * as i2 from '@acorex/components/image';
@@ -14,10 +19,7 @@ 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 { AXTranslationService } from '@acorex/core/translation';
 import { AXFormatService } from '@acorex/core/format';
-import { AXPPlatformScope, AXPBroadcastEventService } from '@acorex/platform/core';
-import { Subject } from 'rxjs';
 import { AXDialogService } from '@acorex/components/dialog';
 import * as i5 from '@acorex/components/button';
 import { AXButtonModule } from '@acorex/components/button';
@@ -238,1591 +240,1752 @@ const ALL_DEFAULT_OPERATORS = [
     BETWEEN_OPER,
 ];
 
-class AXPDataProvider {
-}
-
-class AXPCustomOperatorService {
-}
-class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
-    getCustomOperators() {
-        return {};
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
-            type: Injectable
-        }] });
+const AXP_HOME_PAGES = new InjectionToken('AXP_HOME_PAGES');
+const AXP_HOME_PAGE_DEFAULT_KEY = new InjectionToken('AXP_HOME_PAGE_DEFAULT_KEY', {
+    factory: () => 'home'
+});
 
-class AXPFilterOperatorMiddlewareService {
-}
-class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
+class AXPSettingDefinitionProviderContext {
     constructor() {
-        super(...arguments);
-        this.customOperatorService = inject(AXPCustomOperatorService);
-        this.operators = {
-            ...this.getDefaultOperators(),
-            ...this.customOperatorService.getCustomOperators(),
-        };
-    }
-    transformFilters(filters) {
-        return filters.map((filter) => this.transformFilter(filter));
+        this.rootGroups = [];
+        this.groupMap = new Map();
     }
-    transformFilter(filter) {
-        const { operator, value, filters, field } = filter;
-        // Find the operator (either default or custom)
-        const filterOperator = this.operators[operator?.type ?? ''] || null;
-        // Start by transforming the filter itself
-        const transformedFilter = {
-            ...filter, // Keep the original filter structure
-            operator: filterOperator ? filterOperator : operator, // Add operator name
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description,
+            icon,
+            groups: [],
+            sections: [],
         };
-        // If the filter contains nested filters, recursively transform them
-        if (filters && filters.length > 0) {
-            transformedFilter.filters = this.transformFilters(filters); // Recursively transform nested filters
+        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) {
+            console.error(`Group with name "${name}" not found.`);
+            return null;
         }
-        return transformedFilter;
+        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
     }
-    getOperator(key) {
-        return this.operators[key];
+    getGroups() {
+        return this.rootGroups;
     }
-    // Helper function to return the default operators
-    getDefaultOperators() {
-        return ALL_DEFAULT_OPERATORS.reduce((acc, operator) => {
-            acc[operator.name] = {
-                type: operator.name,
-            };
-            return acc;
-        }, {});
+    // Expose groupMap for controlled access
+    hasGroup(name) {
+        return this.groupMap.has(name);
+    }
+    getGroup(name) {
+        return this.groupMap.get(name);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
-            type: Injectable
-        }] });
-
-class AXPErrorHandlerRegistryService {
-    constructor(injector) {
-        this.injector = injector;
-        this.errorHandlers = [];
+class AXPSettingDefinitionGroupBuilder {
+    constructor(context, group) {
+        this.context = context;
+        this.group = group;
     }
-    register(...plugins) {
-        plugins.forEach(t => {
-            const childInjector = Injector.create({ providers: [{ provide: t, useClass: t, deps: [] }], parent: this.injector });
-            const handler = childInjector.get(t);
-            if (handler) {
-                this.errorHandlers.push(handler);
-            }
-        });
+    addSection(name, title, description) {
+        const newSection = {
+            name,
+            title,
+            description: description,
+            settings: [],
+        };
+        this.group.sections.push(newSection);
+        return new AXPSettingDefinitionSectionBuilder(this, newSection);
     }
-    get handlers() {
-        return this.errorHandlers;
+    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;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i0.Injector }] });
-
-class AXPGlobalErrorHandler extends ErrorHandler {
-    constructor(injector, registry) {
-        super();
-        this.injector = injector;
-        this.registry = registry;
+class AXPSettingDefinitionSectionBuilder {
+    constructor(groupBuilder, section) {
+        this.groupBuilder = groupBuilder;
+        this.section = section;
     }
-    handleError(error) {
-        const handleErrorRecursively = (index, error) => {
-            const errorHandlers = this.registry.handlers;
-            if (index < errorHandlers.length) {
-                errorHandlers[index].handleError(error, (err) => {
-                    handleErrorRecursively(index + 1, err);
-                });
-            }
-            else {
-                super.handleError(error); // Fallback to default handler
-            }
+    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',
+            layout: setting.widget.layout,
+            widget: {
+                type: setting.widget.type,
+                name: setting.key,
+                path: setting.key,
+                defaultValue: setting.defaultValue,
+                options: merge(setting.widget.options ?? {}, {
+                    label: Object.keys(setting.widget.options ?? {}).includes('label') ? setting.widget.options?.['label'] : setting.title,
+                    validationRules: setting.validationRules ?? [],
+                }),
+                valueTransforms: setting.valueTransforms,
+                triggers: setting.widget.triggers,
+            },
         };
-        if (error.message?.startsWith('NG0100')) {
-            //ignore it
-            return;
-        }
-        handleErrorRecursively(0, error);
+        this.section.settings.push(newSetting);
+        return this;
+    }
+    endSection() {
+        return this.groupBuilder;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, deps: [{ token: i0.Injector }, { token: AXPErrorHandlerRegistryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
-// src/app/directives/grid-layout.directive.ts
-class AXPGridLayoutDirective {
-    constructor(el, renderer) {
-        this.el = el;
-        this.renderer = renderer;
+// 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;
     }
-    ngOnChanges(changes) {
-        if (changes['options']) {
-            this.applyTailwindClasses();
+    async load() {
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSettingDefinitionProviderContext();
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                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();
     }
-    applyTailwindClasses() {
-        if (this.options?.positions == null)
-            return;
-        // Clear existing grid classes
-        this.clearClasses();
-        // Apply new grid classes based on the input options
-        this.setClasses(this.options.positions?.default, '');
-        this.setClasses(this.options.positions?.md, 'md:');
-        this.setClasses(this.options.positions?.lg, 'lg:');
-        this.setClasses(this.options.positions?.xl, 'xl:');
-        this.setClasses(this.options.positions?.xxl, '2xl:');
+    async reload() {
+        this.cache = null;
+        await this.load();
     }
-    setClasses(positions, prefix) {
-        if (positions == null)
-            return;
-        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
-        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
-        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
-        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
-        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
-        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
-        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
-        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
-            if (cls) {
-                this.renderer.addClass(this.el.nativeElement, cls);
-            }
-        });
-    }
-    clearClasses() {
-        const currentClasses = this.el.nativeElement.className.split(' ');
-        currentClasses.forEach((className) => {
-            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
-                this.renderer.removeClass(this.el.nativeElement, className);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[gridLayout]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{
-                type: Input,
-                args: ['gridLayout']
-            }] } });
-
-class AXPStickyDirective {
-    get isSticky() {
-        return this._isSticky;
+    async getListAsync(scope) {
+        await this.load();
+        return this.getList(scope);
     }
-    set isSticky(value) {
-        if (this._isSticky !== value) {
-            this._isSticky = value;
-            this.isStickyChange.emit(value);
+    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);
     }
-    constructor(element, renderer, zone, cdr) {
-        this.element = element;
-        this.renderer = renderer;
-        this.zone = zone;
-        this.cdr = cdr;
-        this.stickyOffset = 100;
-        this.isStickyChange = new EventEmitter();
-        this._isSticky = false;
-        this.onParentScroll = () => {
-            this.zone.runOutsideAngular(() => {
-                const scrollTop = this.parentElement === window
-                    ? window.scrollY
-                    : this.parentElement.scrollTop;
-                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
-                if (shouldStick !== this.isSticky) {
-                    this.zone.run(() => {
-                        this.isSticky = shouldStick;
-                        this.toggleStickyClasses(shouldStick);
-                        this.cdr.markForCheck();
+    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);
             });
         };
-    }
-    ngAfterViewInit() {
-        this.initSticky();
-        // Add mutation observer for dynamic content
-        this.mutationObserver = new MutationObserver(() => {
-            this.updateTopOffset();
-        });
-        this.mutationObserver.observe(this.element.nativeElement, {
-            childList: true,
-            subtree: true,
-        });
-        // Add resize event listener
-        window.addEventListener('resize', this.updateTopOffset.bind(this));
-    }
-    initSticky() {
-        if (this.stickyParent instanceof HTMLElement) {
-            this.parentElement = this.stickyParent;
-        }
-        else {
-            this.parentElement =
-                document.querySelector(this.stickyParent) || window;
+        if (!this.cache) {
+            await this.load();
         }
-        this.targetElement =
-            document.querySelector(this.stickyTarget) ||
-                this.element.nativeElement;
-        this.updateTopOffset();
-        this.parentElement.addEventListener('scroll', this.onParentScroll);
+        collectDefaults(this.cache);
+        return defaults;
     }
-    updateTopOffset() {
-        this.zone.runOutsideAngular(() => {
-            const rect = this.targetElement.getBoundingClientRect();
-            this.topOffset = rect.top + (window.scrollY || 0);
-        });
+    findGroup(scope, groupName) {
+        return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
-    toggleStickyClasses(isSticky) {
-        const classes = this.stickyClass.split(' ').filter(Boolean);
-        classes.forEach((className) => {
-            if (isSticky) {
-                this.renderer.addClass(this.targetElement, className);
+    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,
+                };
             }
-            else {
-                this.renderer.removeClass(this.targetElement, className);
+            // Recursively search in nested groups
+            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
+            if (nestedResult.breadcrumb.length > 0) {
+                return nestedResult;
             }
-        });
-    }
-    ngOnDestroy() {
-        this.parentElement.removeEventListener('scroll', this.onParentScroll);
-        window.removeEventListener('resize', this.updateTopOffset.bind(this));
-        if (this.mutationObserver) {
-            this.mutationObserver.disconnect();
         }
+        // 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: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyOffset: "stickyOffset", stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
+    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: AXPStickyDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[axpSticky]',
-                    exportAs: 'axpSticky',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }], propDecorators: { stickyClass: [{
-                type: Input,
-                args: ['axpSticky']
-            }], stickyOffset: [{
-                type: Input,
-                args: ['stickyOffset']
-            }], isStickyChange: [{
-                type: Output
-            }], stickyParent: [{
-                type: Input
-            }], stickyTarget: [{
-                type: Input
-            }] } });
-
-class AXPComponentSlotRegistryService {
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+class AXPSettingDefaultValueProvider {
     constructor() {
-        this.registry = new Map();
+        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
     }
-    register(slotName, config) {
-        let configs = this.registry.get(slotName) || [];
-        // Check if the component is already registered in this slot
-        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
-        if (!isDuplicate) {
-            configs = [...configs, config]; // Add the new configuration
-            this.registry.set(slotName, configs);
-        }
+    get scope() {
+        return AXPPlatformScope.Global;
     }
-    get(slotName) {
-        return this.registry.get(slotName) || [];
+    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.');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
 
-class AXPComponentSlotLoaderService {
-    constructor(registryService, injector) {
-        this.registryService = registryService;
-        this.injector = injector;
+const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return [
+            new AXPSettingValueProviderDefault(AXPPlatformScope.Tenant),
+            new AXPSettingValueProviderDefault(AXPPlatformScope.User)
+        ];
     }
-    loadComponent(slotName, viewContainerRef) {
-        const configs = sortBy(this.registryService.get(slotName), (c) => c.priority ?? 0);
-        if (configs) {
-            viewContainerRef.clear();
-            configs.forEach(async (config) => {
-                let component;
-                let options = {};
-                if (typeof config.loadComponent === 'function') {
-                    // If component is a function
-                    runInInjectionContext(this.injector, () => {
-                        component = config.loadComponent?.();
-                    });
-                }
-                else if (config.component) {
-                    // If component is a Type
-                    component = config.component;
-                }
-                //
-                if (typeof config.options === 'function') {
-                    // If options is a function
-                    runInInjectionContext(this.injector, () => {
-                        const fun = config.options;
-                        options = fun();
-                    });
-                }
-                else if (config.options) {
-                    // If options is a object
-                    options = config.options;
-                }
-                //
-                if (component != null) {
-                    const componentRef = viewContainerRef.createComponent(component);
-                    Object.assign(componentRef.instance, options);
-                }
+});
+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([]);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
-
-class AXPComponentSlotDirective {
-    constructor(dynamicLoaderService, viewContainerRef) {
-        this.dynamicLoaderService = dynamicLoaderService;
-        this.viewContainerRef = viewContainerRef;
+    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();
     }
-    ngOnInit() {
-        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
+    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: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'axp-component-slot',
-                    standalone: false
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
-                type: Input
-            }] } });
 
-class AXPComponentSlotModule {
-    static forRoot(configs) {
-        return {
-            ngModule: AXPComponentSlotModule,
-            providers: [
-                {
-                    provide: 'AXPComponentSlotModuleFactory',
-                    useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
-                    },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
-                }
-            ]
-        };
+class AXPSettingService {
+    constructor() {
+        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
+        //private readonly definitionService = inject(AXPSettingDefinitionProviderService);
+        this.injector = inject(Injector);
+        this.eventService = inject(AXPBroadcastEventService);
+        this.scopedSettingsCache = new Map();
+        this.onChanged = new Subject();
+        // Initialize scoped caches for dynamic scopes
+        const staticScopes = [
+            AXPPlatformScope.Environment,
+            AXPPlatformScope.Global,
+            AXPPlatformScope.Tenant,
+            AXPPlatformScope.User,
+        ];
+        staticScopes.forEach((scope) => {
+            if (!this.scopedSettingsCache.has(scope)) {
+                this.scopedSettingsCache.set(scope, new Map());
+            }
+        });
+        // Listen for setting changes from other tabs
+        this.eventService.listen('AXPSettingChangedEvent').subscribe((event) => {
+            const data = event.data;
+            data.keys.forEach((key) => {
+                this.scopedSettingsCache.get(data.scope)?.set(key, data.values[key]);
+            });
+            this.onChanged.next(data); // Notify subscribers in the current tab
+        });
     }
-    static forChild(configs) {
-        return {
-            ngModule: AXPComponentSlotModule,
-            providers: [
-                {
-                    provide: 'AXPComponentSlotModuleFactory',
-                    useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
-                    },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
+    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 = [
+            AXPPlatformScope.User,
+            AXPPlatformScope.Tenant,
+            AXPPlatformScope.Global,
+            AXPPlatformScope.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 definitionService = this.injector.get(AXPSettingDefinitionProviderService);
+        const defaults = await definitionService.defaultValues();
+        return get(defaults, key); // Fallback if no value is found
     }
-    /**
-     * @ignore
-     */
-    constructor(instances) {
-        instances?.forEach(f => {
-            f();
-        });
+    async defaultValues(scope) {
+        let scopeOrder = [
+            AXPPlatformScope.Environment,
+            AXPPlatformScope.Global,
+            AXPPlatformScope.Tenant,
+            AXPPlatformScope.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 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: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule }); }
+    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.scopedSettingsCache.get(scope));
+    }
+    invokeChangeEvent(event) {
+        this.onChanged.next(event);
+        this.eventService.publish("AXPSettingChangedEvent", event);
+    }
+    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: AXPComponentSlotModule, decorators: [{
-            type: NgModule,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingService, decorators: [{
+            type: Injectable,
             args: [{
-                    declarations: [AXPComponentSlotDirective],
-                    exports: [AXPComponentSlotDirective]
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: ['AXPComponentSlotModuleFactory']
-                }] }] });
-
-class AXPTextLogoConfig {
-    constructor(text) {
-        this.text = text;
+        }], ctorParameters: () => [] });
+class ScopedSettingService {
+    constructor(parent, provider, scopeCache) {
+        this.parent = parent;
+        this.provider = provider;
+        this.scopeCache = scopeCache;
     }
-}
-class AXPImageUrlLogoConfig {
-    constructor(url) {
-        this.url = url;
+    async get(key) {
+        const settings = await this.provider.load();
+        const setting = settings.find((s) => s.key === key);
+        return setting ? cloneDeep(setting.value) : undefined;
     }
-}
-class AXPFontIconLogoConfig {
-    constructor(iconClass) {
-        this.iconClass = iconClass;
+    async all() {
+        const settings = await this.provider.load();
+        return Object.fromEntries(settings.map((s) => [s.key, cloneDeep(s.value)]));
     }
-}
-class AXPComponentLogoConfig {
-    constructor(component) {
-        this.component = component;
+    async defaultValues() {
+        return this.parent.defaultValues(this.provider.scope);
     }
-}
-
-class AXPLogoComponent {
-    ngOnInit() {
-        switch (true) {
-            case this.source instanceof AXPTextLogoConfig:
-                this.logoType = 'text';
-                break;
-            case this.source instanceof AXPImageUrlLogoConfig:
-                this.logoType = 'url';
-                break;
-            case this.source instanceof AXPFontIconLogoConfig:
-                this.logoType = 'iconClass';
-                break;
-            case this.source instanceof AXPComponentLogoConfig:
-                this.logoType = 'component';
-                break;
-            default:
-                break;
+    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.parent.invokeChangeEvent({
+                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.parent.invokeChangeEvent({
+                scope: this.provider.scope,
+                keys: Object.keys(keyOrValues),
+                values: keyOrValues,
+                entries,
+            });
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, ngImport: i0, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
+    async update(key, updateFn) {
+        const currentValue = await this.get(key);
+        const newValue = updateFn(currentValue);
+        await this.set(key, newValue);
+    }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axp-logo', imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { 'class': 'ax-flex ax-justify-center' }, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}" }]
-        }], propDecorators: { source: [{
-                type: Input
-            }] } });
 
-const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
-class AXPMenuProviderService {
+var AXPHomePageSettings;
+(function (AXPHomePageSettings) {
+    AXPHomePageSettings["UserHomePath"] = "general:startup:home-page";
+})(AXPHomePageSettings || (AXPHomePageSettings = {}));
+
+class AXPHomePageService {
+    get flatCandidates() {
+        return this.candidates.flatMap((c) => c);
+    }
     constructor() {
-        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
-        this.cache = null;
-        this.pendingInserts = [];
-        this.pendingRemovals = [];
-        this.pendingUpdates = [];
-        this.pendingAdditions = [];
+        this.defaultHomePageKey = inject(AXP_HOME_PAGE_DEFAULT_KEY, { optional: true }) ?? 'home';
+        this.userHomePageKey = null;
+        this.candidates = inject(AXP_HOME_PAGES, { optional: true }) ?? [];
+        this.settingsService = inject(AXPSettingService);
+        this.sessionService = inject(AXPSessionService);
+        // remove circular dependency
+        setTimeout(async () => {
+            await this.init();
+        });
     }
-    async items() {
-        // Return cached items if available
-        if (this.cache) {
-            return this.cache;
-        }
-        const items = [];
-        const context = this.createMenuProviderContext(items);
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                await provider.provide(context);
+    async init() {
+        await this.load();
+        //
+        const keys = [AXPHomePageSettings.UserHomePath];
+        this.settingsService.onChanged.subscribe(async (c) => {
+            if (keys.some((k) => c.keys.includes(k))) {
+                await this.load();
             }
-        }
-        // Apply pending operations
-        this.applyPendingOperations(items);
-        // Sort items by priority
-        items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-        // ADD level property to items
-        setMenuItemMeta(items);
-        // Cache the computed items
-        this.cache = items;
-        return items;
+        });
+        //
+        merge$1(this.sessionService.status$, this.sessionService.application$, this.sessionService.tenant$).subscribe(async () => {
+            await this.load();
+        });
     }
-    createMenuProviderContext(items) {
+    async load() {
+        this.userHomePageKey = await this.settingsService.get(AXPHomePageSettings.UserHomePath);
+    }
+    getRegisteredList() {
+        return this.flatCandidates.filter((c) => c.route);
+    }
+    getRegisteredRoutes() {
+        const defaultHomePage = this.flatCandidates.find((c) => c.key === this.defaultHomePageKey);
+        const home = this.flatCandidates.find((c) => this.userHomePageKey && c.key === this.userHomePageKey) ?? defaultHomePage;
+        if (home && home.route) {
+            const fullPath = this.findPath(home.route);
+            return [
+                { path: '', redirectTo: fullPath, pathMatch: 'full' },
+                { path: ':app', redirectTo: fullPath, pathMatch: 'full' },
+                { ...home?.route, ...{ data: { key: home?.key, title: home?.title, path: fullPath } } },
+            ];
+        }
+        return [];
+    }
+    getCurrent() {
+        const key = this.userHomePageKey ?? this.defaultHomePageKey;
+        const homePage = this.getRegisteredRoutes().find((c) => c.data?.['key'] === key);
         return {
-            addItems: (newItems) => {
-                items.push(...newItems);
-            },
-            find: (target) => {
-                return {
-                    insert: (newItems, position) => {
-                        this.pendingInserts.push({ target, newItems, position });
-                    },
-                    remove: () => {
-                        this.pendingRemovals.push(target);
-                    },
-                    update: (updatedItem) => {
-                        this.pendingUpdates.push({ target, updatedItem });
-                    },
-                    addItems: (newItems) => {
-                        this.pendingAdditions.push({ target, newItems });
-                    }
-                };
-            }
+            path: homePage.data?.['path'],
+            title: homePage.data?.['title'],
         };
     }
-    applyPendingOperations(items) {
-        for (const { target, newItems, position } of this.pendingInserts) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            const { foundItem, parentItems } = foundItemInfo;
-            if (!foundItem) {
-                console.warn(`Target "${target}" not found, appending items.`);
-                items.push(...newItems);
-            }
-            else {
-                if (position == 'inside') {
-                    foundItem.children?.push(...newItems);
-                }
-                else {
-                    const index = parentItems.indexOf(foundItem);
-                    const insertPosition = position === 'before' ? index : index + 1;
-                    parentItems.splice(insertPosition, 0, ...newItems);
-                }
-            }
-        }
-        for (const target of this.pendingRemovals) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            const { foundItem, parentItems } = foundItemInfo;
-            if (!foundItem) {
-                console.warn(`Target "${target}" not found, nothing to remove.`);
-            }
-            else {
-                const index = parentItems.indexOf(foundItem);
-                parentItems.splice(index, 1);
-            }
-        }
-        for (const { target, updatedItem } of this.pendingUpdates) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            const { foundItem } = foundItemInfo;
-            if (!foundItem) {
-                console.warn(`Target "${target}" not found, nothing to update.`);
-            }
-            else {
-                Object.assign(foundItem, updatedItem);
-            }
-        }
-        for (const { target, newItems } of this.pendingAdditions) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            const { foundItem } = foundItemInfo;
-            if (!foundItem) {
-                console.warn(`Target "${target}" not found, nothing to add items to.`);
-            }
-            else {
-                if (!foundItem.children) {
-                    foundItem.children = [];
-                }
-                foundItem.children.push(...newItems);
-            }
+    findPath(target) {
+        const rawPath = this.buildFullPaths(target).join('/');
+        const appName = this.sessionService.application?.name;
+        if (appName) {
+            return rawPath.replace(':app', appName);
         }
-        // Clear pending operations after applying them
-        this.pendingInserts = [];
-        this.pendingRemovals = [];
-        this.pendingUpdates = [];
-        this.pendingAdditions = [];
+        return rawPath;
     }
-    findItemWithParent(items, target, parentItems = items) {
-        for (const item of items) {
-            if (item.name === target) {
-                return { foundItem: item, parentItems };
-            }
-            if (item.children) {
-                const result = this.findItemWithParent(item.children, target, item.children);
-                if (result.foundItem) {
-                    return result;
-                }
-            }
+    buildFullPaths(route, parentPath = []) {
+        const segments = [...parentPath];
+        if (route.path) {
+            segments.push(route.path);
         }
-        return { foundItem: null, parentItems: items };
-    }
-    // Method to clear the cache, if needed (e.g., when providers change)
-    clearCache() {
-        this.cache = null;
-        this.pendingInserts = [];
-        this.pendingRemovals = [];
-        this.pendingUpdates = [];
-        this.pendingAdditions = [];
+        // Recursively search the first matched child (deepest first match)
+        if (route.children?.length) {
+            return this.buildFullPaths(route.children[0], segments);
+        }
+        return segments;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-function setMenuItemMeta(items, parentIndex = '', depth = 0) {
-    items.forEach((item, index) => {
-        const currentIndex = parentIndex ? `${parentIndex}-${index}` : `${index}`;
-        const hasChildren = !!(item.children && Array.isArray(item.children) && item.children.length > 0);
-        item.meta = {
-            index: currentIndex,
-            isRoot: depth === 0,
-            hasChildren,
-            depth
-        };
-        if (hasChildren) {
-            setMenuItemMeta(item.children, currentIndex, depth + 1);
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+function dynamicRoutesFactory() {
+    const service = inject(AXPHomePageService);
+    return service.getRegisteredRoutes();
+}
+function provideDynamicHomePage() {
+    return makeEnvironmentProviders([
+        {
+            provide: ROUTES,
+            useFactory: dynamicRoutesFactory,
+            multi: true
         }
-    });
+    ]);
 }
 
-const AXPMenuService = signalStore({ providedIn: 'root' }, 
-// Initial State
-withState((router = inject(Router)) => {
-    return {
-        items: [],
-        selectedMenuItem: {
-            item: null,
-            isFullMatch: false
-        },
-    };
-}), 
-// Methods for State Management
-withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowService)) => {
-    return {
-        setMenuItems(items) {
-            patchState(store, { items: items });
-        },
-        selectMenuItemByRoute(path) {
-            const findItem = (items) => {
-                for (const item of items) {
-                    // Recursively search children first
-                    if (item.children) {
-                        const foundChild = findItem(item.children);
-                        if (foundChild.item) {
-                            return foundChild;
-                        }
-                    }
-                    if (item.path) {
-                        // Check if the item path matches the current path
-                        const matchResult = pathsMatch(item.path, path, ["list", "view", "edit", "create"]);
-                        if (matchResult.isMatch) {
-                            return { item, isPartialMatch: matchResult.isPartial };
-                        }
-                    }
-                }
-                return { item: null, isPartialMatch: false };
-            };
-            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
-                const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
-                const pathSegments = currentPath.split('/').filter(segment => segment.length > 0);
-                const menuLength = itemSegments.length;
-                const pathLength = pathSegments.length;
-                // Identify the effective base length for the menuPath
-                let effectiveMenuLength = menuLength;
-                if (menuLength > 0 &&
-                    trailingSegmentsToIgnore.includes(itemSegments[menuLength - 1])) {
-                    effectiveMenuLength--; // Exclude trailing non-hierarchical segments
-                }
-                // Check if the menuPath (base segments) is a prefix of browserPath
-                let isPrefix = true;
-                for (let i = 0; i < effectiveMenuLength; i++) {
-                    if (itemSegments[i] !== pathSegments[i]) {
-                        isPrefix = false;
-                        break;
-                    }
-                }
-                // Partial match: menuPath base is a strict prefix of browserPath
-                const isPartialMatch = isPrefix && effectiveMenuLength < pathLength;
-                // Exact match: all segments match completely
-                const isExactMatch = isPrefix && effectiveMenuLength === pathLength;
-                return {
-                    isMatch: isExactMatch || isPartialMatch,
-                    isPartial: isPartialMatch && !isExactMatch,
-                };
-            };
-            const items = store.items();
-            const { item, isPartialMatch } = findItem(items);
-            patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
-        },
-        executeCommand(item) {
-            if (item.path) {
-                workflow.execute('navigate', { type: 'router', options: { path: item.path } });
-                patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
-            }
-            if (item.command) {
-                const command = item.command;
-                workflow.execute(command.name, command.options);
-            }
-        },
-        isItemOpen(item) {
-            const selectedItem = store.selectedMenuItem();
-            if (!selectedItem) {
-                return false;
-            }
-            const findParent = (currentItem, targetItem) => {
-                if (currentItem.children?.includes(targetItem)) {
-                    return true;
-                }
-                return currentItem.children?.some(child => findParent(child, targetItem)) ?? false;
-            };
-            return item === selectedItem?.item || findParent(item, selectedItem.item);
+class AXPHomePageSettingProvider {
+    constructor(injector) {
+        this.injector = injector;
+        this.translateService = this.injector.get(AXTranslationService);
+        this.homePageService = this.injector.get(AXPHomePageService);
+    }
+    async provide(context) {
+        const trans = async (key) => await this.translateService.translateAsync(`settings.${key}`, { scope: 'general' });
+        const list = await this.homePageService.getRegisteredList().map((c) => ({ id: c.key, title: c.title }));
+        if (list.length === 0) {
+            return;
         }
-    };
-}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => ({
-    onInit() {
-        (async () => {
-            const items = await menuProviderService.items();
-            patchState(store, { items: items });
-        })();
-    },
-    onDestroy() {
-    },
-})));
+        // Define the 'General Settings' group
+        context
+            .addGroup('general', await trans('general.title'), await trans('general.description'), 'fa-light fa-palette')
+            // Add the 'Startup' section
+            .addSection('startup', await trans('general.startup.title'), await trans('general.startup.description'))
+            // Add the 'Home Page' setting
+            .addSetting({
+            key: AXPHomePageSettings.UserHomePath,
+            title: await trans('general.startup.home-page.title'),
+            scope: AXPPlatformScope.User,
+            isInherited: true,
+            defaultValue: list[0].id,
+            valueTransforms: objectKeyValueTransforms('id'),
+            widget: {
+                type: AXPWidgetsCatalog.select,
+                options: {
+                    valueField: 'id',
+                    textField: 'title',
+                    dataSource: list,
+                },
+            },
+            description: await trans('general.startup.home-page.description'),
+        })
+            // End the 'Startup' section
+            .endSection()
+            // End the 'General Settings' group
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageSettingProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageSettingProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
 
-class AXPMenuSearchDefinitionProvider {
-    async provide(context) {
-        context.addDefinition('menu', 'Menu', 'menu', 'fa-thin fa-bars', 2, {
-            format: {
-                id: '{{data.name}}',
+class AXPHomePageModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageModule, providers: [
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXPHomePageSettingProvider,
+                multi: true,
             },
-            actions: [
-                {
-                    name: 'navigate',
-                    type: 'view',
-                    priority: 'primary',
-                },
-            ],
-        });
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPHomePageModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    providers: [
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXPHomePageSettingProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXPDataProvider {
+}
+
+class AXPCustomOperatorService {
+}
+class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
+    getCustomOperators() {
+        return {};
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
+            type: Injectable
+        }] });
 
-class AXPMenuSearchProvider {
+class AXPFilterOperatorMiddlewareService {
+}
+class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
     constructor() {
-        this.menuService = inject(AXPMenuProviderService);
-        this.translateService = inject(AXTranslationService);
+        super(...arguments);
+        this.customOperatorService = inject(AXPCustomOperatorService);
+        this.operators = {
+            ...this.getDefaultOperators(),
+            ...this.customOperatorService.getCustomOperators(),
+        };
     }
-    async search(text) {
-        const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
-        return sortBy(menuItems.map((item) => ({
-            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: omit(item, ['parent', 'children']), // Include all data except `parent` and `children`
-            command: item.path ? {
-                name: 'navigate',
-                options: {
-                    type: 'router',
-                    options: {
-                        path: item.path,
-                    },
-                }
-            } : item.command,
-            parent: item.parent
-                ? {
-                    title: item.parent.text,
-                }
-                : undefined,
-        })), [(o) => this.translateService.translateSync(o.title)]);
+    transformFilters(filters) {
+        return filters.map((filter) => this.transformFilter(filter));
     }
-    /**
-     * Recursively searches AXPMenuItem and its children for a matching text.
-     *
-     * @param menuItems - The array of AXPMenuItem to search in.
-     * @param searchText - The text to search for (case-insensitive).
-     * @returns An array of AXPMenuItem that match the search text.
-     */
-    async searchMenuItems(menuItems, searchText) {
-        const result = [];
-        for (const item of menuItems) {
-            // Check if the current item's text matches the search text
-            if (item.type != 'group' &&
-                (item.children?.length ?? 0) == 0 &&
-                (await this.translateService.translateAsync(item.text)).toLowerCase().includes(searchText.toLowerCase())) {
-                result.push(item);
+    transformFilter(filter) {
+        const { operator, value, filters, field } = filter;
+        // Find the operator (either default or custom)
+        const filterOperator = this.operators[operator?.type ?? ''] || null;
+        // Start by transforming the filter itself
+        const transformedFilter = {
+            ...filter, // Keep the original filter structure
+            operator: filterOperator ? filterOperator : operator, // Add operator name
+        };
+        // If the filter contains nested filters, recursively transform them
+        if (filters && filters.length > 0) {
+            transformedFilter.filters = this.transformFilters(filters); // Recursively transform nested filters
+        }
+        return transformedFilter;
+    }
+    getOperator(key) {
+        return this.operators[key];
+    }
+    // Helper function to return the default operators
+    getDefaultOperators() {
+        return ALL_DEFAULT_OPERATORS.reduce((acc, operator) => {
+            acc[operator.name] = {
+                type: operator.name,
+            };
+            return acc;
+        }, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPErrorHandlerRegistryService {
+    constructor(injector) {
+        this.injector = injector;
+        this.errorHandlers = [];
+    }
+    register(...plugins) {
+        plugins.forEach(t => {
+            const childInjector = Injector.create({ providers: [{ provide: t, useClass: t, deps: [] }], parent: this.injector });
+            const handler = childInjector.get(t);
+            if (handler) {
+                this.errorHandlers.push(handler);
+            }
+        });
+    }
+    get handlers() {
+        return this.errorHandlers;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPErrorHandlerRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXPGlobalErrorHandler extends ErrorHandler {
+    constructor(injector, registry) {
+        super();
+        this.injector = injector;
+        this.registry = registry;
+    }
+    handleError(error) {
+        const handleErrorRecursively = (index, error) => {
+            const errorHandlers = this.registry.handlers;
+            if (index < errorHandlers.length) {
+                errorHandlers[index].handleError(error, (err) => {
+                    handleErrorRecursively(index + 1, err);
+                });
             }
-            // Recursively search in children if they exist
-            if (item.children && item.children.length > 0) {
-                const childResults = await this.searchMenuItems(item.children, searchText);
-                result.push(...childResults.map((x) => ({ ...x, parent: item })));
+            else {
+                super.handleError(error); // Fallback to default handler
             }
+        };
+        if (error.message?.startsWith('NG0100')) {
+            //ignore it
+            return;
         }
-        return result;
+        handleErrorRecursively(0, error);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, deps: [{ token: i0.Injector }, { token: AXPErrorHandlerRegistryService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGlobalErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
-class AXPMenuBadgeHelper {
-    static { this.cache = new WeakMap(); }
-    static getTotalCount(item, badgeService) {
-        if (this.cache.has(item))
-            return this.cache.get(item);
-        const own = item.badgeKey ? badgeService.getCount(item.badgeKey) : () => 0;
-        const children = item.children?.map(child => this.getTotalCount(child, badgeService)) ?? [];
-        const total = computed(() => own() + children.reduce((sum, s) => sum + s(), 0));
-        this.cache.set(item, total);
-        return total;
+// src/app/directives/grid-layout.directive.ts
+class AXPGridLayoutDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
     }
-}
-
-class AXPFooterTextSlotComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
-      <small class="ax-text-sm" [innerHTML]="text"></small>
-    `, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-      <small class="ax-text-sm" [innerHTML]="text"></small>
-    `,
-                    standalone: true
-                }]
-        }], propDecorators: { text: [{
-                type: Input
-            }] } });
-
-class AXPNavBarSlotComponent {
-    handleCommand(action) {
-        // if (action)
-        //     this.store.dispatch(action)
+    ngOnChanges(changes) {
+        if (changes['options']) {
+            this.applyTailwindClasses();
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPNavBarSlotComponent, isStandalone: true, selector: "ng-component", inputs: { items: "items" }, ngImport: i0, template: `
-    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
-        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
-    </div>
-    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
+    applyTailwindClasses() {
+        if (this.options?.positions == null)
+            return;
+        // Clear existing grid classes
+        this.clearClasses();
+        // Apply new grid classes based on the input options
+        this.setClasses(this.options.positions?.default, '');
+        this.setClasses(this.options.positions?.md, 'md:');
+        this.setClasses(this.options.positions?.lg, 'lg:');
+        this.setClasses(this.options.positions?.xl, 'xl:');
+        this.setClasses(this.options.positions?.xxl, '2xl:');
+    }
+    setClasses(positions, prefix) {
+        if (positions == null)
+            return;
+        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
+        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
+        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
+        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
+        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
+        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
+        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
+        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
+            if (cls) {
+                this.renderer.addClass(this.el.nativeElement, cls);
+            }
+        });
+    }
+    clearClasses() {
+        const currentClasses = this.el.nativeElement.className.split(' ');
+        currentClasses.forEach((className) => {
+            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
+            type: Directive,
             args: [{
-                    template: `
-    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
-        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
-    </div>
-    `,
-                    imports: [CommonModule],
-                    encapsulation: ViewEncapsulation.None
+                    selector: '[gridLayout]',
+                    standalone: true,
                 }]
-        }], propDecorators: { items: [{
-                type: Input
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{
+                type: Input,
+                args: ['gridLayout']
             }] } });
 
-class AXPSearchDefinitionProviderContext {
-    constructor() {
-        this.definitions = [];
-        this.definitionMap = new Map();
+class AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
     }
-    addDefinition(name, title, group, icon, order, options) {
-        const definitionSearch = {
-            name,
-            title,
-            group,
-            icon,
-            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
-        return new AXPSearchDefinitionBuilder(this, definitionSearch);
+    set isSticky(value) {
+        if (this._isSticky !== value) {
+            this._isSticky = value;
+            this.isStickyChange.emit(value);
+        }
     }
-    getDefinitions() {
-        return this.definitions;
+    constructor(element, renderer, zone, cdr) {
+        this.element = element;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.cdr = cdr;
+        this.stickyOffset = 100;
+        this.isStickyChange = new EventEmitter();
+        this._isSticky = false;
+        this.onParentScroll = () => {
+            this.zone.runOutsideAngular(() => {
+                const scrollTop = this.parentElement === window
+                    ? window.scrollY
+                    : this.parentElement.scrollTop;
+                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
+                if (shouldStick !== this.isSticky) {
+                    this.zone.run(() => {
+                        this.isSticky = shouldStick;
+                        this.toggleStickyClasses(shouldStick);
+                        this.cdr.markForCheck();
+                    });
+                }
+            });
+        };
     }
-    // Expose groupMap for controlled access
-    hasEntity(name) {
-        return this.definitionMap.has(name);
+    ngAfterViewInit() {
+        this.initSticky();
+        // Add mutation observer for dynamic content
+        this.mutationObserver = new MutationObserver(() => {
+            this.updateTopOffset();
+        });
+        this.mutationObserver.observe(this.element.nativeElement, {
+            childList: true,
+            subtree: true,
+        });
+        // Add resize event listener
+        window.addEventListener('resize', this.updateTopOffset.bind(this));
     }
-    getDefinition(name) {
-        return this.definitionMap.get(name);
+    initSticky() {
+        if (this.stickyParent instanceof HTMLElement) {
+            this.parentElement = this.stickyParent;
+        }
+        else {
+            this.parentElement =
+                document.querySelector(this.stickyParent) || window;
+        }
+        this.targetElement =
+            document.querySelector(this.stickyTarget) ||
+                this.element.nativeElement;
+        this.updateTopOffset();
+        this.parentElement.addEventListener('scroll', this.onParentScroll);
     }
-}
-class AXPSearchDefinitionBuilder {
-    constructor(context, definition) {
-        this.context = context;
-        this.definition = definition;
+    updateTopOffset() {
+        this.zone.runOutsideAngular(() => {
+            const rect = this.targetElement.getBoundingClientRect();
+            this.topOffset = rect.top + (window.scrollY || 0);
+        });
     }
-    addAction(name) {
-        const newAction = {
-            name,
-            type: 'view',
-            priority: 'primary',
-        };
-        this.definition.actions.push(newAction);
-        return new AXPSearchDefinitionActionBuilder(this);
+    toggleStickyClasses(isSticky) {
+        const classes = this.stickyClass.split(' ').filter(Boolean);
+        classes.forEach((className) => {
+            if (isSticky) {
+                this.renderer.addClass(this.targetElement, className);
+            }
+            else {
+                this.renderer.removeClass(this.targetElement, className);
+            }
+        });
     }
-    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}".`);
+    ngOnDestroy() {
+        this.parentElement.removeEventListener('scroll', this.onParentScroll);
+        window.removeEventListener('resize', this.updateTopOffset.bind(this));
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
         }
-        return new AXPSearchDefinitionActionBuilder(this);
-    }
-    endEntity() {
-        return this.context;
-    }
-}
-class AXPSearchDefinitionActionBuilder {
-    constructor(entityBuilder) {
-        this.entityBuilder = entityBuilder;
-    }
-    endAction() {
-        return this.entityBuilder;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyOffset: "stickyOffset", stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPStickyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axpSticky]',
+                    exportAs: 'axpSticky',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }], propDecorators: { stickyClass: [{
+                type: Input,
+                args: ['axpSticky']
+            }], stickyOffset: [{
+                type: Input,
+                args: ['stickyOffset']
+            }], isStickyChange: [{
+                type: Output
+            }], stickyParent: [{
+                type: Input
+            }], stickyTarget: [{
+                type: Input
+            }] } });
 
-// Injection token for setting providers
-const AXP_SEARCH_DEFINITION_PROVIDER = new InjectionToken('AXP_SEARCH_DEFINITION_PROVIDER');
-class AXPSearchDefinitionProviderService {
+class AXPComponentSlotRegistryService {
     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;
-        }
+        this.registry = new Map();
     }
-    findDefinition(definitionName) {
-        const definition = this.getList().find((definition) => definition.name === definitionName);
-        if (!definition) {
-            throw new Error(`Definition with name ${definitionName} not found`);
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
         }
-        return definition;
     }
-    findDefinitionByGroup(definitionGroup) {
-        const definition = this.getList().find((definition) => definition.group === definitionGroup);
-        if (!definition) {
-            throw new Error(`Definition with group ${definitionGroup} not found`);
-        }
-        return definition;
+    get(slotName) {
+        return this.registry.get(slotName) || [];
     }
-    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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            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);
+class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
     }
-    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.group,
-                        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,
-                        command: result.command,
-                        actions: definition.actions,
-                        parent: result.parent,
-                        order: definition.order,
+    loadComponent(slotName, viewContainerRef) {
+        const configs = sortBy(this.registryService.get(slotName), (c) => c.priority ?? 0);
+        if (configs) {
+            viewContainerRef.clear();
+            configs.forEach(async (config) => {
+                let component;
+                let options = {};
+                if (typeof config.loadComponent === 'function') {
+                    // If component is a function
+                    runInInjectionContext(this.injector, () => {
+                        component = config.loadComponent?.();
                     });
                 }
-                catch (e) {
-                    console.error(e);
+                else if (config.component) {
+                    // If component is a Type
+                    component = config.component;
                 }
-            }
-        }
-        // 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']));
+                //
+                if (typeof config.options === 'function') {
+                    // If options is a function
+                    runInInjectionContext(this.injector, () => {
+                        const fun = config.options;
+                        options = fun();
+                    });
+                }
+                else if (config.options) {
+                    // If options is a object
+                    options = config.options;
+                }
+                //
+                if (component != null) {
+                    const componentRef = viewContainerRef.createComponent(component);
+                    Object.assign(componentRef.instance, options);
+                }
+            });
         }
-        // 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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotLoaderService, 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: AXPComponentSlotLoaderService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-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);
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+
+class AXPComponentSlotDirective {
+    constructor(dynamicLoaderService, viewContainerRef) {
+        this.dynamicLoaderService = dynamicLoaderService;
+        this.viewContainerRef = viewContainerRef;
     }
-    getGroup(name) {
-        return this.groupMap.get(name);
+    ngOnInit() {
+        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
 }
-class AXPSettingDefinitionGroupBuilder {
-    constructor(context, group) {
-        this.context = context;
-        this.group = group;
-    }
-    addSection(name, title, description) {
-        const newSection = {
-            name,
-            title,
-            description: description,
-            settings: [],
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
+                type: Input
+            }] } });
+
+class AXPComponentSlotModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
-        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: [],
+    static forChild(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
-        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;
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule }); }
 }
-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',
-            layout: setting.widget.layout,
-            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;
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPComponentSlotModuleFactory']
+                }] }] });
+
+class AXPLogoComponent {
+    ngOnInit() {
+        switch (true) {
+            case this.source instanceof AXPTextLogoConfig:
+                this.logoType = 'text';
+                break;
+            case this.source instanceof AXPImageUrlLogoConfig:
+                this.logoType = 'url';
+                break;
+            case this.source instanceof AXPFontIconLogoConfig:
+                this.logoType = 'iconClass';
+                break;
+            case this.source instanceof AXPComponentLogoConfig:
+                this.logoType = 'component';
+                break;
+            default:
+                break;
+        }
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.0.3", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, ngImport: i0, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPLogoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-logo', imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { class: 'ax-flex ax-justify-center' }, template: "@switch (logoType) {\n@case ('text') {\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\n}\n@case ('url') {\n<ax-image [src]=\"source.url\"></ax-image>\n} @case ('iconClass') {\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\n} @case ('component') {\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\n}\n}" }]
+        }], propDecorators: { source: [{
+                type: Input
+            }] } });
 
-// Injection token for setting providers
-const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
-class AXPSettingDefinitionProviderService {
+const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
+class AXPMenuProviderService {
     constructor() {
-        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
+        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
         this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
     }
-    async load() {
+    async items() {
+        // Return cached items if available
         if (this.cache) {
-            return;
+            return this.cache;
+        }
+        const items = [];
+        const context = this.createMenuProviderContext(items);
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        // Apply pending operations
+        this.applyPendingOperations(items);
+        // Sort items by priority
+        items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        // ADD level property to items
+        setMenuItemMeta(items);
+        // Cache the computed items
+        this.cache = items;
+        return items;
+    }
+    createMenuProviderContext(items) {
+        return {
+            addItems: (newItems) => {
+                items.push(...newItems);
+            },
+            find: (target) => {
+                return {
+                    insert: (newItems, position) => {
+                        this.pendingInserts.push({ target, newItems, position });
+                    },
+                    remove: () => {
+                        this.pendingRemovals.push(target);
+                    },
+                    update: (updatedItem) => {
+                        this.pendingUpdates.push({ target, updatedItem });
+                    },
+                    addItems: (newItems) => {
+                        this.pendingAdditions.push({ target, newItems });
+                    }
+                };
+            }
+        };
+    }
+    applyPendingOperations(items) {
+        for (const { target, newItems, position } of this.pendingInserts) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem, parentItems } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, appending items.`);
+                items.push(...newItems);
+            }
+            else {
+                if (position == 'inside') {
+                    foundItem.children?.push(...newItems);
+                }
+                else {
+                    const index = parentItems.indexOf(foundItem);
+                    const insertPosition = position === 'before' ? index : index + 1;
+                    parentItems.splice(insertPosition, 0, ...newItems);
+                }
+            }
+        }
+        for (const target of this.pendingRemovals) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem, parentItems } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to remove.`);
+            }
+            else {
+                const index = parentItems.indexOf(foundItem);
+                parentItems.splice(index, 1);
+            }
         }
-        const context = new AXPSettingDefinitionProviderContext();
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                if (provider instanceof Promise) {
-                    // If provider is a promise, resolve it
-                    const resolvedProvider = await provider;
-                    await resolvedProvider.provide(context);
+        for (const { target, updatedItem } of this.pendingUpdates) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to update.`);
+            }
+            else {
+                Object.assign(foundItem, updatedItem);
+            }
+        }
+        for (const { target, newItems } of this.pendingAdditions) {
+            const foundItemInfo = this.findItemWithParent(items, target);
+            const { foundItem } = foundItemInfo;
+            if (!foundItem) {
+                console.warn(`Target "${target}" not found, nothing to add items to.`);
+            }
+            else {
+                if (!foundItem.children) {
+                    foundItem.children = [];
                 }
-                else {
-                    // If provider is a direct instance, use it directly
-                    await provider.provide(context);
+                foundItem.children.push(...newItems);
+            }
+        }
+        // Clear pending operations after applying them
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
+    }
+    findItemWithParent(items, target, parentItems = items) {
+        for (const item of items) {
+            if (item.name === target) {
+                return { foundItem: item, parentItems };
+            }
+            if (item.children) {
+                const result = this.findItemWithParent(item.children, target, item.children);
+                if (result.foundItem) {
+                    return result;
                 }
             }
         }
-        this.cache = context.getGroups();
+        return { foundItem: null, parentItems: items };
     }
-    async reload() {
+    // Method to clear the cache, if needed (e.g., when providers change)
+    clearCache() {
         this.cache = null;
-        await this.load();
-    }
-    async getListAsync(scope) {
-        await this.load();
-        return this.getList(scope);
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
     }
-    getList(scope) {
-        if (!this.cache) {
-            return [];
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function setMenuItemMeta(items, parentIndex = '', depth = 0) {
+    items.forEach((item, index) => {
+        const currentIndex = parentIndex ? `${parentIndex}-${index}` : `${index}`;
+        const hasChildren = !!(item.children && Array.isArray(item.children) && item.children.length > 0);
+        item.meta = {
+            index: currentIndex,
+            isRoot: depth === 0,
+            hasChildren,
+            depth
+        };
+        if (hasChildren) {
+            setMenuItemMeta(item.children, currentIndex, depth + 1);
         }
-        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;
+    });
+}
+
+const AXPMenuService = signalStore({ providedIn: 'root' }, 
+// Initial State
+withState((router = inject(Router)) => {
+    return {
+        items: [],
+        selectedMenuItem: {
+            item: null,
+            isFullMatch: false
+        },
+    };
+}), 
+// Methods for State Management
+withMethods((store, router = inject(Router), workflow = inject(AXPWorkflowService)) => {
+    return {
+        setMenuItems(items) {
+            patchState(store, { items: items });
+        },
+        selectMenuItemByRoute(path) {
+            const findItem = (items) => {
+                for (const item of items) {
+                    // Recursively search children first
+                    if (item.children) {
+                        const foundChild = findItem(item.children);
+                        if (foundChild.item) {
+                            return foundChild;
                         }
-                        // 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;
+                    }
+                    if (item.path) {
+                        // Check if the item path matches the current path
+                        const matchResult = pathsMatch(item.path, path, ["list", "view", "edit", "create"]);
+                        if (matchResult.isMatch) {
+                            return { item, isPartialMatch: matchResult.isPartial };
                         }
-                    });
-                });
-                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 { item: null, isPartialMatch: false };
+            };
+            const pathsMatch = (itemPath, currentPath, trailingSegmentsToIgnore = []) => {
+                const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
+                const pathSegments = currentPath.split('/').filter(segment => segment.length > 0);
+                const menuLength = itemSegments.length;
+                const pathLength = pathSegments.length;
+                // Identify the effective base length for the menuPath
+                let effectiveMenuLength = menuLength;
+                if (menuLength > 0 &&
+                    trailingSegmentsToIgnore.includes(itemSegments[menuLength - 1])) {
+                    effectiveMenuLength--; // Exclude trailing non-hierarchical segments
+                }
+                // Check if the menuPath (base segments) is a prefix of browserPath
+                let isPrefix = true;
+                for (let i = 0; i < effectiveMenuLength; i++) {
+                    if (itemSegments[i] !== pathSegments[i]) {
+                        isPrefix = false;
+                        break;
+                    }
+                }
+                // Partial match: menuPath base is a strict prefix of browserPath
+                const isPartialMatch = isPrefix && effectiveMenuLength < pathLength;
+                // Exact match: all segments match completely
+                const isExactMatch = isPrefix && effectiveMenuLength === pathLength;
                 return {
-                    breadcrumb: currentBreadcrumb,
-                    sections: group.sections.length > 0 ? group.sections : null,
-                    groups: group.groups.length > 0 ? group.groups : null,
+                    isMatch: isExactMatch || isPartialMatch,
+                    isPartial: isPartialMatch && !isExactMatch,
                 };
+            };
+            const items = store.items();
+            const { item, isPartialMatch } = findItem(items);
+            patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
+        },
+        executeCommand(item) {
+            if (item.path) {
+                workflow.execute('navigate', { type: 'router', options: { path: item.path } });
+                patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
             }
-            // Recursively search in nested groups
-            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
-            if (nestedResult.breadcrumb.length > 0) {
-                return nestedResult;
+            if (item.command) {
+                const command = item.command;
+                workflow.execute(command.name, command.options);
+            }
+        },
+        isItemOpen(item) {
+            const selectedItem = store.selectedMenuItem();
+            if (!selectedItem) {
+                return false;
             }
+            const findParent = (currentItem, targetItem) => {
+                if (currentItem.children?.includes(targetItem)) {
+                    return true;
+                }
+                return currentItem.children?.some(child => findParent(child, targetItem)) ?? false;
+            };
+            return item === selectedItem?.item || findParent(item, selectedItem.item);
         }
-        // If no matching group is found
-        return {
-            breadcrumb: [],
-            groups: [],
-            sections: []
-        };
+    };
+}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => ({
+    onInit() {
+        (async () => {
+            const items = await menuProviderService.items();
+            patchState(store, { items: items });
+        })();
+    },
+    onDestroy() {
+    },
+})));
+
+class AXPMenuSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition('menu', 'Menu', 'menu', 'fa-thin fa-bars', 2, {
+            format: {
+                id: '{{data.name}}',
+            },
+            actions: [
+                {
+                    name: 'navigate',
+                    type: 'view',
+                    priority: 'primary',
+                },
+            ],
+        });
     }
-    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 {
+
+class AXPMenuSearchProvider {
     constructor() {
-        this.definitionProvider = inject(AXPSettingDefinitionProviderService);
+        this.menuService = inject(AXPMenuProviderService);
+        this.translateService = inject(AXTranslationService);
     }
-    get scope() {
-        return AXPPlatformScope.Global;
+    async search(text) {
+        const menuItems = await this.searchMenuItems(await this.menuService.items(), text);
+        return sortBy(menuItems.map((item) => ({
+            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: omit(item, ['parent', 'children']), // Include all data except `parent` and `children`
+            command: item.path ? {
+                name: 'navigate',
+                options: {
+                    type: 'router',
+                    options: {
+                        path: item.path,
+                    },
+                }
+            } : item.command,
+            parent: item.parent
+                ? {
+                    title: item.parent.text,
+                }
+                : undefined,
+        })), [(o) => this.translateService.translateSync(o.title)]);
     }
-    async load() {
-        return Object.entries(await this.definitionProvider.defaultValues()).map(c => ({ key: c[0], value: c[1] }));
+    /**
+     * Recursively searches AXPMenuItem and its children for a matching text.
+     *
+     * @param menuItems - The array of AXPMenuItem to search in.
+     * @param searchText - The text to search for (case-insensitive).
+     * @returns An array of AXPMenuItem that match the search text.
+     */
+    async searchMenuItems(menuItems, searchText) {
+        const result = [];
+        for (const item of menuItems) {
+            // Check if the current item's text matches the search text
+            if (item.type != 'group' &&
+                (item.children?.length ?? 0) == 0 &&
+                (await this.translateService.translateAsync(item.text)).toLowerCase().includes(searchText.toLowerCase())) {
+                result.push(item);
+            }
+            // Recursively search in children if they exist
+            if (item.children && item.children.length > 0) {
+                const childResults = await this.searchMenuItems(item.children, searchText);
+                result.push(...childResults.map((x) => ({ ...x, parent: item })));
+            }
+        }
+        return result;
     }
-    set(key, value) {
-        throw new Error('Method not implemented.');
+}
+
+class AXPMenuBadgeHelper {
+    static { this.cache = new WeakMap(); }
+    static getTotalCount(item, badgeService) {
+        if (this.cache.has(item))
+            return this.cache.get(item);
+        const own = item.badgeKey ? badgeService.getCount(item.badgeKey) : () => 0;
+        const children = item.children?.map(child => this.getTotalCount(child, badgeService)) ?? [];
+        const total = computed(() => own() + children.reduce((sum, s) => sum + s(), 0));
+        this.cache.set(item, total);
+        return total;
     }
 }
 
-const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
-    providedIn: 'root',
-    factory: () => {
-        return [
-            new AXPSettingValueProviderDefault(AXPPlatformScope.Tenant),
-            new AXPSettingValueProviderDefault(AXPPlatformScope.User)
-        ];
+class AXPFooterTextSlotComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
+      <small class="ax-text-sm" [innerHTML]="text"></small>
+    `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+      <small class="ax-text-sm" [innerHTML]="text"></small>
+    `,
+                    standalone: true
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+
+class AXPNavBarSlotComponent {
+    handleCommand(action) {
+        // if (action)
+        //     this.store.dispatch(action)
     }
-});
-class AXPSettingValueProviderDefault {
-    get scope() {
-        return this._scope;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: AXPNavBarSlotComponent, isStandalone: true, selector: "ng-component", inputs: { items: "items" }, ngImport: i0, template: `
+    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `,
+                    imports: [CommonModule],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
+
+class AXPSearchDefinitionProviderContext {
+    constructor() {
+        this.definitions = [];
+        this.definitionMap = new Map();
     }
-    constructor(_scope) {
-        this._scope = _scope;
-        this.cache = new Map();
-        this.localStorageKey = `AXP_SETTINGS_SCOPE(${this.scope})`;
+    addDefinition(name, title, group, icon, order, options) {
+        const definitionSearch = {
+            name,
+            title,
+            group,
+            icon,
+            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
+        return new AXPSearchDefinitionBuilder(this, definitionSearch);
     }
-    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([]);
+    getDefinitions() {
+        return this.definitions;
     }
-    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();
+    // Expose groupMap for controlled access
+    hasEntity(name) {
+        return this.definitionMap.has(name);
     }
-    async saveToLocalStorage() {
-        const settingsObject = {};
-        this.cache.forEach((value, key) => {
-            settingsObject[key] = value;
-        });
-        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
+    getDefinition(name) {
+        return this.definitionMap.get(name);
     }
 }
-
-class AXPSettingService {
-    constructor() {
-        this.providers = inject(AXP_SETTING_VALUE_PROVIDER);
-        //private readonly definitionService = inject(AXPSettingDefinitionProviderService);
-        this.injector = inject(Injector);
-        this.eventService = inject(AXPBroadcastEventService);
-        this.scopedSettingsCache = new Map();
-        this.onChanged = new Subject();
-        // Initialize scoped caches for dynamic scopes
-        const staticScopes = [
-            AXPPlatformScope.Environment,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ];
-        staticScopes.forEach((scope) => {
-            if (!this.scopedSettingsCache.has(scope)) {
-                this.scopedSettingsCache.set(scope, new Map());
-            }
-        });
-        // Listen for setting changes from other tabs
-        this.eventService.listen('AXPSettingChangedEvent').subscribe((event) => {
-            const data = event.data;
-            data.keys.forEach((key) => {
-                this.scopedSettingsCache.get(data.scope)?.set(key, data.values[key]);
-            });
-            this.onChanged.next(data); // Notify subscribers in the current tab
-        });
+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);
+    }
+    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() {
-        try {
-            const settingsList = [];
+        if (this.cache) {
+            return;
+        }
+        const context = new AXPSearchDefinitionProviderContext();
+        if (Array.isArray(this.providers)) {
             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);
+                await provider.provide(context);
             }
-            return settingsList;
-        }
-        catch (error) {
-            console.error('Error loading settings', error);
-            throw error;
         }
+        this.cache = context.getDefinitions();
     }
-    async get(key) {
-        if (this.scopedSettingsCache.size === 0) {
-            await this.load();
-        }
-        const scopeOrder = [
-            AXPPlatformScope.User,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.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 definitionService = this.injector.get(AXPSettingDefinitionProviderService);
-        const defaults = await definitionService.defaultValues();
-        return get(defaults, key); // Fallback if no value is found
+    async getListAsync() {
+        await this.load();
+        return this.getList();
     }
-    async defaultValues(scope) {
-        let scopeOrder = [
-            AXPPlatformScope.Environment,
-            AXPPlatformScope.Global,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ].reverse();
-        const scopeIndex = scopeOrder.indexOf(scope);
-        if (scopeIndex === -1) {
-            throw new Error(`Invalid scope: ${scope}`);
+    getList() {
+        if (!this.cache) {
+            return [];
         }
-        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;
-                    }
-                });
-            }
+        else {
+            return this.cache;
         }
-        // Merge with global default values from the definition service
-        const definitionService = this.injector.get(AXPSettingDefinitionProviderService);
-        const globalDefaults = await 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}`);
+    findDefinition(definitionName) {
+        const definition = this.getList().find((definition) => definition.name === definitionName);
+        if (!definition) {
+            throw new Error(`Definition with name ${definitionName} not found`);
         }
-        return new ScopedSettingService(this, provider, this.scopedSettingsCache.get(scope));
+        return definition;
     }
-    invokeChangeEvent(event) {
-        this.onChanged.next(event);
-        this.eventService.publish("AXPSettingChangedEvent", event);
+    findDefinitionByGroup(definitionGroup) {
+        const definition = this.getList().find((definition) => definition.group === definitionGroup);
+        if (!definition) {
+            throw new Error(`Definition with group ${definitionGroup} not found`);
+        }
+        return definition;
     }
-    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' }); }
+    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: AXPSettingService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSearchDefinitionProviderService, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-class ScopedSettingService {
-    constructor(parent, provider, scopeCache) {
-        this.parent = parent;
-        this.provider = provider;
-        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)]));
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPSearchCommandProvider {
+    async search(text) {
+        return this.commands.filter((command) => command.title.toLowerCase().includes(text.toLowerCase()));
     }
-    async defaultValues() {
-        return this.parent.defaultValues(this.provider.scope);
+}
+
+// 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 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.parent.invokeChangeEvent({
-                scope: this.provider.scope,
-                keys: [keyOrValues],
-                values: { [keyOrValues]: value },
-                entries: [{ key: keyOrValues, value }],
-            });
+    async search(text) {
+        //TODO better handle this
+        if (this.definitionService.getList().length == 0) {
+            await this.definitionService.getListAsync();
         }
-        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.parent.invokeChangeEvent({
-                scope: this.provider.scope,
-                keys: Object.keys(keyOrValues),
-                values: keyOrValues,
-                entries,
-            });
+        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.group,
+                        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,
+                        command: result.command,
+                        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;
     }
-    async update(key, updateFn) {
-        const currentValue = await this.get(key);
-        const newValue = updateFn(currentValue);
-        await this.set(key, newValue);
-    }
+    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' }]
+        }] });
 
 //TODO Loading, Redirect, Drawer, Show toast
 const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
@@ -1904,7 +2067,7 @@ class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
     async execute(context) {
         const command = context.getVariable();
         const path = command.options.path;
-        if (path.toLowerCase().startsWith('http') || command.options?.extras?.target === 'blank') {
+        if (path?.toLowerCase()?.startsWith('http') || command.options?.extras?.target === 'blank') {
             window.open(path, '_blank');
         }
         else {
@@ -1926,7 +2089,7 @@ class AXPWorkflowRouterNavigateAction extends AXPWorkflowAction {
             return undefined;
         return queryString
             .split('&')
-            .map(pair => pair.split('='))
+            .map((pair) => pair.split('='))
             .reduce((params, [key, value]) => {
             params[decodeURIComponent(key)] = decodeURIComponent(value);
             return params;
@@ -1941,7 +2104,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
 const AXPNavigateWorkflow = {
     startStepId: 'start',
     steps: {
-        'start': {
+        start: {
             action: 'navigate-router',
         },
     },
@@ -2133,7 +2296,7 @@ const AXPPlatformDefaultConfigs = {
     },
     network: {
         timeOut: 5000,
-    }
+    },
 };
 function configPlatform(config = AXPPlatformDefaultConfigs) {
     return merge(AXPPlatformDefaultConfigs, config);
@@ -2645,5 +2808,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuBadgeHelper, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalService, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPTextLogoConfig, AXPToastAction, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, 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, AXP_TASK_BADGE_PROVIDERS, 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, createAllQueryView, createQueryView, getEntityInfo, resolveActionLook };
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFiltersProviderService, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPHomePageModule, AXPHomePageService, AXPLogoComponent, AXPMenuBadgeHelper, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRegionalService, AXPRelationshipCardinality, AXPRelationshipKind, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValueProvider, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPToastAction, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, 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, AXP_TASK_BADGE_PROVIDERS, 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, createAllQueryView, createQueryView, getEntityInfo, provideDynamicHomePage, resolveActionLook };
 //# sourceMappingURL=acorex-platform-common.mjs.map