@acorex/platform 18.2.1 → 18.2.3

package/fesm2022/acorex-platform-common.mjs

@@ -1,34 +1,31 @@
 import * as i0 from '@angular/core';
-import { Injectable, APP_INITIALIZER, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Directive, Input, EventEmitter, Output, runInInjectionContext, NgModule, Optional, Inject, Component, ViewEncapsulation, ChangeDetectorRef, ChangeDetectionStrategy, ViewChild } from '@angular/core';
-import { kebabCase, sortBy, cloneDeep, merge, assign, isEqual, get, set } from 'lodash-es';
+import { Injectable, APP_INITIALIZER, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Inject, NgModule, Input, Directive, EventEmitter, Output, runInInjectionContext, Optional, Component, ViewEncapsulation, ChangeDetectorRef, ViewChild, ChangeDetectionStrategy } from '@angular/core';
+import { kebabCase, cloneDeep, merge, sortBy, assign, isEqual, get, set } from 'lodash-es';
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
-import * as i6 from '@acorex/platform/workflow';
+import * as i5 from '@acorex/platform/workflow';
 import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError, AXPWorkflowModule } from '@acorex/platform/workflow';
-import * as i1 from '@angular/router';
-import { NavigationEnd, Router, RouterModule } from '@angular/router';
-import * as i1$2 from '@ngrx/effects';
-import { createEffect, ofType, Actions, EffectsModule } from '@ngrx/effects';
-import * as i5$1 from '@ngrx/store';
-import { createAction, props, Store, createFeature, createReducer, on, createSelector, StoreModule } from '@ngrx/store';
+import * as i2 from '@angular/router';
+import { Router, RouterModule } from '@angular/router';
+import * as i1 from '@ngrx/effects';
+import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
 import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 import Dexie from 'dexie';
-import { filter } from 'rxjs/operators';
-import { BehaviorSubject, timer, of, Subject, switchMap, fromEvent, debounceTime, map } from 'rxjs';
-import * as i5 from '@acorex/components/decorators';
+import { Subject, switchMap, of } from 'rxjs';
+import { createAction, props, Store } from '@ngrx/store';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXTranslationService } from '@acorex/core/translation';
+import * as i5$1 from '@acorex/components/decorators';
 import { AXDecoratorModule } from '@acorex/components/decorators';
-import * as i2 from '@acorex/components/image';
+import * as i2$1 from '@acorex/components/image';
 import { AXImageModule } from '@acorex/components/image';
 import * as i1$1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
-import { AXPlatform } from '@acorex/core/platform';
-import { AXDialogService } from '@acorex/components/dialog';
-import { AXTranslationService } from '@acorex/core/translation';
-import * as i2$1 from '@acorex/components/skeleton';
+import * as i2$2 from '@acorex/components/skeleton';
 import { AXSkeletonModule } from '@acorex/components/skeleton';
-import * as i1$3 from '@angular/cdk/portal';
+import * as i1$2 from '@angular/cdk/portal';
 import { ComponentPortal, PortalModule } from '@angular/cdk/portal';
 import { AXDataTableColumnComponent } from '@acorex/components/data-table';
 import { AXUnsubscriber } from '@acorex/core/utils';
@@ -100,11 +97,11 @@ function getEntityInfo(entity) {
     return {
         source: `${entity.module}.${entity.name}`,
         module: {
-            route: kebabCase(entity.module)
+            route: kebabCase(entity.module),
         },
         entity: {
-            route: kebabCase(entity.name)
-        }
+            route: kebabCase(entity.name),
+        },
     };
 }
 function resolveActionLook(tr) {
@@ -175,6 +172,21 @@ const DATE_OPERATORS = [
     IS_EMPTY_OPER,
     IS_NOT_EMPTY_OPER,
 ];
+const ALL_DEFAULT_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    GT_OPER,
+    LT_OPER,
+    GTE_OPER,
+    LTE_OPER,
+    CONTAINS_OPER,
+    NOT_CONTAINS_OPER,
+    STARTS_WITH_OPER,
+    ENDS_WITH_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+    BETWEEN_OPER,
+];
 
 class AXPDataProvider {
 }
@@ -202,44 +214,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                 }]
         }] });
 
-class AXPRouteUtilityService {
-    constructor(router) {
-        this.router = router;
-        this.routeActiveCache = {};
-        // Subscribe to NavigationEnd events to update the cache
-        this.router.events
-            .pipe(filter((event) => event instanceof NavigationEnd))
-            .subscribe(() => {
-            this.clearRouteCache();
-        });
-    }
-    isRouteActive(item) {
-        const route = item.path;
-        if (!route)
-            return false;
-        // // Check if the result is already cached
-        // if (this.routeActiveCache.hasOwnProperty(route)) {
-        //     return this.routeActiveCache[route];
-        // }
-        // Calculate the route activity
-        const isActive = window.location.pathname.startsWith(route);
-        // Cache the result
-        this.routeActiveCache[route] = isActive;
-        return isActive;
-    }
-    clearRouteCache() {
-        this.routeActiveCache = {};
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPRouteUtilityService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPRouteUtilityService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPRouteUtilityService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.Router }] });
-
 class AXPDataGenerator {
     static uuid() {
         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
@@ -583,6 +557,29 @@ class AXPDexieEntityStorageService extends Dexie {
 //   }
 // }
 
+const AXP_DATA_SEEDER_TOKEN = new InjectionToken('AXP_DATA_SEEDER_TOKEN');
+class AXPDataSeederService {
+    constructor() {
+        this.loader = inject(AXP_DATA_SEEDER_TOKEN, { optional: true });
+    }
+    async seed() {
+        if (Array.isArray(this.loader)) {
+            for (const loader of this.loader) {
+                await loader.seed();
+            }
+        }
+        else {
+            await this.loader?.seed();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXPEntityStorageService {
 }
 class AXPEntityDataProvider {
@@ -637,35 +634,74 @@ class AXMEntityCrudServiceImpl {
     async query(request = { skip: 0, take: 100 }) {
         return this._entityDataProvider.query(request);
     }
-    get entityDataProvider() {
-        return this._entityDataProvider;
-    }
+    // get entityDataProvider() {
+    //   return this._entityDataProvider;
+    // }
     get storageService() {
         return this._storageService;
     }
 }
 
-const AXP_DATA_SEEDER_TOKEN = new InjectionToken('AXP_DATA_SEEDER_TOKEN');
-class AXPDataSeederService {
+class AXPCustomOperatorService {
+}
+class AXPCustomOperatorServiceImpl extends AXPCustomOperatorService {
+    getCustomOperators() {
+        return {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCustomOperatorServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCustomOperatorServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCustomOperatorServiceImpl, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPFilterOperatorMiddlewareService {
+}
+class AXPFilterOperatorMiddlewareServiceImpl extends AXPFilterOperatorMiddlewareService {
     constructor() {
-        this.loader = inject(AXP_DATA_SEEDER_TOKEN, { optional: true });
+        super(...arguments);
+        this.customOperatorService = inject(AXPCustomOperatorService);
+        this.operators = {
+            ...this.getDefaultOperators(),
+            ...this.customOperatorService.getCustomOperators(),
+        };
     }
-    async seed() {
-        if (Array.isArray(this.loader)) {
-            for (const loader of this.loader) {
-                await loader.seed();
-            }
-        }
-        else {
-            await this.loader?.seed();
+    transformFilters(filters) {
+        return filters.map((filter) => this.transformFilter(filter));
+    }
+    transformFilter(filter) {
+        console.log(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;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, providedIn: 'root' }); }
+    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: "18.2.0", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDataSeederService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPFilterOperatorMiddlewareServiceImpl, decorators: [{
+            type: Injectable
         }] });
 
 class AXPErrorHandlerRegistryService {
@@ -727,382 +763,518 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
             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_PROVIDER = new InjectionToken('AXP_SETTING_PROVIDER');
+class AXPSettingDefinitionProviderService {
+    constructor() {
+        this.providers = inject(AXP_SETTING_PROVIDER, { optional: true });
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingAdditions = [];
     }
-    ngOnChanges(changes) {
-        if (changes['options']) {
-            this.applyTailwindClasses();
+    // Retrieve all setting items, applying any pending operations
+    async items() {
+        if (this.cache) {
+            return this.cache;
+        }
+        const items = [];
+        const context = this.createProviderContext(items);
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                provider.provide(context);
+            }
         }
+        // this.applyPendingOperations(items);
+        this.cache = items;
+        return items;
     }
-    applyTailwindClasses() {
-        // 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:');
+    findGroupDetails(groupName) {
+        if (this.cache) {
+            return this.searchGroupDetails(this.cache, groupName, []); // Initialize with an empty breadcrumb
+        }
+        return null;
     }
-    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);
+    searchGroupDetails(groups, groupName, breadcrumb) {
+        for (const group of groups) {
+            const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title }];
+            // If the group name matches, return its details
+            if (group.name === groupName) {
+                return {
+                    breadcrumb: currentBreadcrumb,
+                    sections: group.sections.length > 0 ? group.sections : null,
+                    childGroups: group.groups.length > 0 ? group.groups : null,
+                };
             }
-        });
-    }
-    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);
+            // Recursively search in nested groups
+            const nestedResult = this.searchGroupDetails(group.groups, groupName, currentBreadcrumb);
+            if (nestedResult) {
+                return nestedResult;
             }
+        }
+        // If no matching group is found
+        return null;
+    }
+    // Create the provider context with methods to add items and find existing ones
+    createProviderContext(items) {
+        return {
+            addItems: (newItems) => {
+                items.push(...newItems);
+            },
+            addItem: (item) => {
+                items.push(item);
+            },
+            addGroup: (group) => {
+                items.push(group);
+            },
+            // find: (target: string): AXPSettingDefinitionFinderResult => {
+            //   return {
+            //     insertGroup: (item, position) => {
+            //       this.pendingInserts.push({ target, newItems: [item], position });
+            //     },
+            //     insertSingle: (item, position) => {
+            //       this.pendingInserts.push({ target, newItems: [item], position });
+            //     },
+            //     insertSingles: (items, position) => {
+            //       this.pendingInserts.push({ target, newItems: items, position });
+            //     },
+            //     addItems: (items) => {
+            //       this.pendingAdditions.push({ target, newItems: items });
+            //     },
+            //     addChildSingleAt: (item, index) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           if (index >= 0 && index <= group.singles.length) {
+            //             group.singles.splice(index, 0, item);
+            //           } else {
+            //             console.warn(`Index "${index}" is out of bounds for singles.`);
+            //           }
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child single.`);
+            //       }
+            //     },
+            //     addChildSingleFirst: (item) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           group.singles.unshift(item);
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child single.`);
+            //       }
+            //     },
+            //     addChildSingleLast: (item) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           group.singles.push(item);
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child single.`);
+            //       }
+            //     },
+            //     addChildGroupAt: (item, index) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           if (index >= 0 && index <= group.groups.length) {
+            //             group.groups.splice(index, 0, item);
+            //           } else {
+            //             console.warn(`Index "${index}" is out of bounds for groups.`);
+            //           }
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child group.`);
+            //       }
+            //     },
+            //     addChildGroupFirst: (item) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           group.groups.unshift(item);
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child group.`);
+            //       }
+            //     },
+            //     addChildGroupLast: (item) => {
+            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
+            //       if (foundItemInfo && foundItemInfo.foundItem) {
+            //         const { foundItem } = foundItemInfo;
+            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
+            //           const group = foundItem as AXPSettingDefinitionGroup;
+            //           group.groups.push(item);
+            //         } else {
+            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
+            //         }
+            //       } else {
+            //         console.warn(`Target "${target}" not found for adding a child group.`);
+            //       }
+            //     },
+            //   };
+            // },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const AXP_SETTINGS_PROVIDER = new InjectionToken('AXP_SETTINGS_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPSettingsProviderDefault();
+    }
+});
+class AXPSettingsProviderDefault {
+    constructor() {
+        this.cache = new Map();
+        this.localStorageKey = 'AXP_SETTINGS';
+    }
+    async load() {
+        // Load settings from localStorage as a single key
+        const storedSettings = localStorage.getItem(this.localStorageKey);
+        if (storedSettings) {
+            const parsedSettings = JSON.parse(storedSettings);
+            Object.entries(parsedSettings).forEach(([key, value]) => {
+                this.cache.set(key, value);
+            });
+            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
+        }
+        return Promise.resolve([]);
+    }
+    async set(key, value) {
+        this.cache.set(key, value);
+        // Save to localStorage as a single key
+        const settingsObject = {};
+        this.cache.forEach((val, k) => {
+            settingsObject[k] = val;
         });
+        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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 AXPLayoutService {
+class AXPSettingsService {
     constructor() {
-        this.minimumDisplayTime = 500; // milliseconds
-        // 
-        this.navigationLoadingSubject = new BehaviorSubject(false);
-        this.navigationLoadingTaskCount = 0;
-        this.navigationLoadingStateActive = false;
-        // 
-        this.overlayLoadingSubject = new BehaviorSubject(false);
-        this.overlayLoadingTaskCount = 0;
-        this.overlayLoadingStateActive = false;
-    }
-    get navigationLoading$() {
-        return this.navigationLoadingSubject.asObservable();
-    }
-    setNavigationLoading(value) {
-        if (value) {
-            this.navigationLoadingTaskCount++;
-            this.updateNavigationLoadingState(true);
+        this.settingsProvider = inject(AXP_SETTINGS_PROVIDER);
+        this.settingsCache = new Map();
+        this.changed = new Subject();
+    }
+    async load() {
+        try {
+            const settingsList = await this.settingsProvider.load();
+            this.settingsCache.clear();
+            settingsList.forEach((setting) => {
+                this.settingsCache.set(setting.key, setting.value);
+            });
+            return settingsList;
         }
-        else {
-            if (this.navigationLoadingTaskCount > 0) {
-                this.navigationLoadingTaskCount--;
-            }
-            if (this.navigationLoadingTaskCount === 0) {
-                // Start timer to keep loading state for minimum display time
-                timer(this.minimumDisplayTime).subscribe(() => {
-                    if (this.navigationLoadingTaskCount === 0) {
-                        this.updateNavigationLoadingState(false);
-                    }
-                });
-            }
+        catch (error) {
+            console.error('Error loading settings', error);
+            throw error; // Re-throw or handle it appropriately
         }
     }
-    updateNavigationLoadingState(state) {
-        if (state !== this.navigationLoadingStateActive) {
-            this.navigationLoadingStateActive = state;
-            this.navigationLoadingSubject.next(state);
+    async get(key) {
+        if (this.settingsCache.size == 0) {
+            await this.load();
         }
+        return cloneDeep(this.settingsCache.get(key));
     }
-    get overlayLoading$() {
-        return this.overlayLoadingSubject.asObservable();
-    }
-    setOverlayLoading(value) {
-        if (value) {
-            this.overlayLoadingTaskCount++;
-            this.updateOverlayLoadingState(true);
+    async set(key, value) {
+        if (this.settingsCache.has(key)) {
+            this.settingsCache.set(key, value);
+            await this.settingsProvider.set(key, value);
+            this.changed.next({ key, value });
         }
         else {
-            if (this.overlayLoadingTaskCount > 0) {
-                this.overlayLoadingTaskCount--;
-            }
-            if (this.overlayLoadingTaskCount === 0) {
-                // Start timer to keep loading state for minimum display time
-                timer(this.minimumDisplayTime).subscribe(() => {
-                    if (this.overlayLoadingTaskCount === 0) {
-                        this.updateOverlayLoadingState(false);
-                    }
-                });
-            }
-        }
-    }
-    updateOverlayLoadingState(state) {
-        if (state !== this.overlayLoadingStateActive) {
-            this.overlayLoadingStateActive = state;
-            this.overlayLoadingSubject.next(state);
+            console.warn(`Setting with key "${key}" not found.`);
+            this.settingsCache.set(key, value);
+            this.set(key, value);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, decorators: [{
             type: Injectable,
-            args: [{ providedIn: 'root' }]
+            args: [{
+                    providedIn: 'root',
+                }]
         }] });
 
-class AXPStickyDirective {
-    get isSticky() {
-        return this._isSticky;
+const AXPNavigateAction = createAction('[Navigate] Action', props());
+const AXPSignOutAction = createAction('[SignOut] Action');
+const AXPSignInAction = createAction('[SignIn] Action');
+
+class AXPCommonEffects {
+    constructor(actions$, router, settingService) {
+        this.actions$ = actions$;
+        this.router = router;
+        this.settingService = settingService;
+        this.command$ = createEffect(() => this.actions$.pipe(ofType(AXPNavigateAction), switchMap((action) => {
+            if (Array.isArray(action.payload.commands))
+                this.router.navigate(action.payload.commands, action.payload.extras);
+            else {
+                if (action.payload.commands.toLowerCase().startsWith('http'))
+                    window.open(action.payload.commands, '_blank');
+                else
+                    this.router.navigate([action.payload.commands], action.payload.extras);
+            }
+            return of();
+        })), { dispatch: false });
     }
-    set isSticky(v) {
-        this._isSticky = v;
-        this.isStickyChange.emit(v);
-    }
-    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 scrollPosition = this.parentElement === window ?
-                    window.scrollY :
-                    this.parentElement.scrollTop + this.targetElement.offsetTop;
-                if (scrollPosition - this.stickyOffset >= this.topOffset && !this.isSticky) {
-                    this.stickyClass.split(' ').forEach(c => {
-                        this.renderer.addClass(this.targetElement, c);
-                    });
-                    this.isSticky = true;
-                    this.cdr.markForCheck();
-                }
-                else if (scrollPosition <= this.topOffset && this.isSticky) {
-                    this.stickyClass.split(' ').forEach(c => {
-                        this.renderer.removeClass(this.targetElement, c);
-                    });
-                    this.isSticky = false;
-                    this.cdr.markForCheck();
-                }
-            });
-        };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1.Actions }, { token: i2.Router }, { token: AXPSettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }, { type: AXPSettingsService }] });
+
+//TODO Loading, Redirect, Drawer, Show toast
+const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
+class AXPWorkflowNavigateAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.router = inject(Router);
     }
-    ngAfterViewInit() {
-        if (this.stickyParent instanceof HTMLElement) {
-            this.parentElement = this.stickyParent;
+    async execute(context) {
+        const payload = context.getVariable('payload');
+        if (Array.isArray(payload.commands)) {
+            this.router.navigate(payload.commands, payload.extras);
         }
         else {
-            this.parentElement = document.querySelector(this.stickyParent) || window;
+            if (payload.commands.toLowerCase().startsWith('http') || payload.target == "blank") {
+                window.open(payload.commands, '_blank');
+            }
+            else
+                this.router.navigate([payload.commands], payload.extras);
         }
-        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
-        this.topOffset = this.targetElement.offsetTop;
-        this.parentElement.addEventListener('scroll', this.onParentScroll.bind(this));
-    }
-    ngOnDestroy() {
-        this.parentElement.removeEventListener('scroll', this.onParentScroll);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", 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: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPDialogConfirmAction extends AXPWorkflowAction {
     constructor() {
-        this.registry = new Map();
-    }
-    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);
-        }
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
     }
-    get(slotName) {
-        return this.registry.get(slotName) || [];
+    async execute(context) {
+        context.setOutput('result', false);
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync(this.title), await this.translationService.translateAsync(this.message), (await this.translationService.translateAsync(this.type)));
+        context.setOutput('result', dialogResult.result);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
         }] });
-
-class AXPComponentSlotLoaderService {
-    constructor(registryService, injector) {
-        this.registryService = registryService;
-        this.injector = injector;
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
     }
-    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);
-                }
-            });
-        }
+    async execute(context) {
+        this.toastService.show({
+            color: this.color,
+            title: await this.translationService.translateAsync(this.title),
+            content: await this.translationService.translateAsync(this.content),
+            closeButton: true,
+            timeOut: 3000,
+            timeOutProgress: true,
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction, decorators: [{
+            type: Injectable
+        }] });
 
-class AXPComponentSlotDirective {
-    constructor(dynamicLoaderService, viewContainerRef) {
-        this.dynamicLoaderService = dynamicLoaderService;
-        this.viewContainerRef = viewContainerRef;
+class AXMWorkflowErrorHandler {
+    constructor() {
+        this.dialog = inject(AXDialogService);
     }
-    ngOnInit() {
-        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
+    handleError(error, next) {
+        if (error instanceof AXPWorkflowError) {
+            this.dialog.alert("Somthing is wrong!", error.inner ? error.inner.message : error.message, 'danger');
+            next(error);
+        }
+        else {
+            next(error);
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.0", type: AXPComponentSlotDirective, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'axp-component-slot',
-                }]
-        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
-                type: Input
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler, decorators: [{
+            type: Injectable
+        }] });
 
-class AXPComponentSlotModule {
+class AXPCommonModule {
     static forRoot(configs) {
         return {
-            ngModule: AXPComponentSlotModule,
+            ngModule: AXPCommonModule,
             providers: [
+                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPComponentSlotModuleFactory',
+                    provide: 'AXPCommonModuleFactory',
                     useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
+                        registry.register(...(configs?.errorHandlers || []));
                     },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
-                }
-            ]
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
         };
     }
     static forChild(configs) {
         return {
-            ngModule: AXPComponentSlotModule,
+            ngModule: AXPCommonModule,
             providers: [
+                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPComponentSlotModuleFactory',
+                    provide: 'AXPCommonModuleFactory',
                     useFactory: (registry) => () => {
-                        if (configs) {
-                            for (const [key, value] of Object.entries(configs)) {
-                                value.forEach(v => {
-                                    registry.register(key, v);
-                                });
-                            }
-                        }
+                        registry.register(...(configs?.errorHandlers || []));
                     },
-                    deps: [AXPComponentSlotRegistryService],
-                    multi: true
-                }
-            ]
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
         };
     }
     /**
      * @ignore
      */
-    constructor(instances) {
-        instances?.forEach(f => {
+    constructor(instances, appInitService, settingsService, seederService) {
+        instances.forEach((f) => {
             f();
         });
+        // appInitService.registerTask({
+        //   name: 'Modules',
+        //   statusText: 'Initializing Modules ...',
+        //   run: () =>
+        //     new Promise<void>((resolve) => {
+        //       setTimeout(() => {
+        //         resolve();
+        //       }, 250);
+        //     }),
+        // });
+        //
+        appInitService.registerTask({
+            name: 'Settings',
+            statusText: 'Loading Settings ...',
+            run: async () => {
+                await settingsService.load();
+            },
+        });
+        //
+        //
+        appInitService.registerTask({
+            name: 'Seeder',
+            statusText: 'Seed Data ...',
+            run: async () => {
+                await seederService.seed();
+            },
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingsService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, imports: [i1.EffectsFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, providers: [
+            AXPAppStartUpProvider,
+            {
+                provide: ErrorHandler,
+                useClass: AXPGlobalErrorHandler,
+            },
+            {
+                provide: AXPCustomOperatorService,
+                useClass: AXPCustomOperatorServiceImpl,
+            },
+            {
+                provide: AXPFilterOperatorMiddlewareService,
+                useClass: AXPFilterOperatorMiddlewareServiceImpl,
+            },
+        ], imports: [EffectsModule.forFeature([AXPCommonEffects]),
+            AXPWorkflowModule.forChild({
+                actions: {
+                    navigate: AXPDialogConfirmAction,
+                    'show-prompt-dialog': AXPDialogConfirmAction,
+                    'show-toast': AXPToastAction,
+                },
+            }),
+            AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule, RouterModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [AXPComponentSlotDirective],
-                    exports: [AXPComponentSlotDirective]
+                    imports: [
+                        EffectsModule.forFeature([AXPCommonEffects]),
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                navigate: AXPDialogConfirmAction,
+                                'show-prompt-dialog': AXPDialogConfirmAction,
+                                'show-toast': AXPToastAction,
+                            },
+                        }),
+                        AXPopupModule,
+                        AXDateTimeModule,
+                        AXToastModule,
+                    ],
+                    exports: [RouterModule],
+                    providers: [
+                        AXPAppStartUpProvider,
+                        {
+                            provide: ErrorHandler,
+                            useClass: AXPGlobalErrorHandler,
+                        },
+                        {
+                            provide: AXPCustomOperatorService,
+                            useClass: AXPCustomOperatorServiceImpl,
+                        },
+                        {
+                            provide: AXPFilterOperatorMiddlewareService,
+                            useClass: AXPFilterOperatorMiddlewareServiceImpl,
+                        },
+                    ],
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
                     type: Inject,
-                    args: ['AXPComponentSlotModuleFactory']
-                }] }] });
+                    args: ['AXPCommonModuleFactory']
+                }] }, { type: AXPAppStartUpService }, { type: AXPSettingsService }, { type: AXPDataSeederService }] });
 
 class AXPTextLogoConfig {
     constructor(text) {
@@ -1125,682 +1297,644 @@ class AXPComponentLogoConfig {
     }
 }
 
-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: "18.2.0", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", 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$1.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: i5.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLogoComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axp-logo', standalone: true, 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_LOADER = new InjectionToken('AXP_MENU_LOADER', {
+const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
+const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
     providedIn: 'root',
     factory: () => {
-        return new AXMenuLoaderDefault();
+        return AXPPlatformDefaultConfigs;
     },
 });
-class AXMenuLoaderDefault {
-    /**
-     * @ignore
-     */
-    constructor(items = []) {
-        this._items = [
-            {
-                text: 'Menu Item 1',
-                icon: 'fa-solid fa-grid-2',
-                children: [
-                    {
-                        text: 'Sub Menu Item 1',
-                    },
-                    {
-                        text: 'Sub Menu Item 2',
-                    },
-                ],
-            },
-        ];
-        if (items && items.length) {
-            this._items = items;
-        }
-    }
-    currentMenuItem() {
-        throw new Error("Method not implemented.");
-    }
-    getItems(depth) {
-        return of(this._items);
+const AXPPlatformDefaultConfigs = {
+    copyright: 'ACoreX @ 2023',
+    title: 'ACoreX Platform',
+    logo: {
+        dark: new AXPTextLogoConfig('ACoreX'),
+        light: new AXPTextLogoConfig('ACoreX'),
+        colored: new AXPTextLogoConfig('ACoreX'),
+    },
+    useLocalData: false,
+    network: {
+        timeOut: 5000,
     }
+};
+function configPlatform(config = AXPPlatformDefaultConfigs) {
+    return merge(AXPPlatformDefaultConfigs, config);
 }
 
-const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
-class AXPMenuProviderService {
-    constructor() {
-        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
+const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
+
+// src/app/directives/grid-layout.directive.ts
+class AXPGridLayoutDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
     }
-    async items() {
-        const items = [];
-        if (Array.isArray(this.providers)) {
-            for (const provider of this.providers) {
-                const injections = await provider.items();
-                this.applyInjections(items, injections);
-            }
+    ngOnChanges(changes) {
+        if (changes['options']) {
+            this.applyTailwindClasses();
         }
-        return items;
     }
-    applyInjections(items, injections) {
-        for (const injection of injections) {
-            if (injection.insertAt) {
-                const inserted = this.findAndInsert(items, injection.items, injection.insertAt.target, injection.insertAt?.position ?? 'after');
-                if (!inserted) {
-                    // If target is not found, append items to the end
-                    items.push(...injection.items);
-                }
-            }
-            else {
-                // If insertAt is not defined, add items to the end
-                items.push(...injection.items);
-            }
-        }
+    applyTailwindClasses() {
+        // 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:');
     }
-    findAndInsert(items, newItems, target, position) {
-        for (let i = 0; i < items.length; i++) {
-            const item = items[i];
-            // Check if the current item matches the target
-            if (item.name === target) {
-                const insertPosition = position === 'before' ? i : i + 1;
-                items.splice(insertPosition, 0, ...newItems);
-                return true;
+    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);
             }
-            // If the item has children, perform a recursive search
-            if (item.children && this.findAndInsert(item.children, newItems, target, position)) {
-                return true;
+        });
+    }
+    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);
             }
-        }
-        return false; // Target not found in this branch
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-const AXPNavigateAction = createAction('[Navigate] Action', props());
-const AXPSignOutAction = createAction('[SignOut] Action');
-const AXPSignInAction = createAction('[SignIn] Action');
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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']
+            }] } });
 
-const AXP_SETTINGS_PROVIDER = new InjectionToken('AXP_SETTINGS_PROVIDER', {
-    providedIn: 'root',
-    factory: () => {
-        return new AXPSettingsProviderDefault();
+class AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
     }
-});
-class AXPSettingsProviderDefault {
-    constructor() {
-        this.cache = new Map();
-        this.localStorageKey = 'AXP_SETTINGS';
+    set isSticky(v) {
+        this._isSticky = v;
+        this.isStickyChange.emit(v);
     }
-    async load() {
-        // Load settings from localStorage as a single key
-        const storedSettings = localStorage.getItem(this.localStorageKey);
-        if (storedSettings) {
-            const parsedSettings = JSON.parse(storedSettings);
-            Object.entries(parsedSettings).forEach(([key, value]) => {
-                this.cache.set(key, value);
-            });
-            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
-        }
-        return Promise.resolve([]);
-    }
-    async set(key, value) {
-        this.cache.set(key, value);
-        // Save to localStorage as a single key
-        const settingsObject = {};
-        this.cache.forEach((val, k) => {
-            settingsObject[k] = val;
-        });
-        localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
-    }
-}
-
-class AXPSettingsService {
-    constructor() {
-        this.settingsProvider = inject(AXP_SETTINGS_PROVIDER);
-        this.settingsCache = new Map();
-        this.changed = new Subject();
-    }
-    async load() {
-        try {
-            const settingsList = await this.settingsProvider.load();
-            this.settingsCache.clear();
-            settingsList.forEach((setting) => {
-                this.settingsCache.set(setting.key, setting.value);
+    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 scrollPosition = this.parentElement === window ?
+                    window.scrollY :
+                    this.parentElement.scrollTop + this.targetElement.offsetTop;
+                if (scrollPosition - this.stickyOffset >= this.topOffset && !this.isSticky) {
+                    this.stickyClass.split(' ').forEach(c => {
+                        this.renderer.addClass(this.targetElement, c);
+                    });
+                    this.isSticky = true;
+                    this.cdr.markForCheck();
+                }
+                else if (scrollPosition <= this.topOffset && this.isSticky) {
+                    this.stickyClass.split(' ').forEach(c => {
+                        this.renderer.removeClass(this.targetElement, c);
+                    });
+                    this.isSticky = false;
+                    this.cdr.markForCheck();
+                }
             });
-            return settingsList;
-        }
-        catch (error) {
-            console.error('Error loading settings', error);
-            throw error; // Re-throw or handle it appropriately
-        }
-    }
-    async get(key) {
-        if (this.settingsCache.size == 0) {
-            await this.load();
-        }
-        return cloneDeep(this.settingsCache.get(key));
+        };
     }
-    async set(key, value) {
-        if (this.settingsCache.has(key)) {
-            this.settingsCache.set(key, value);
-            await this.settingsProvider.set(key, value);
-            this.changed.next({ key, value });
+    ngAfterViewInit() {
+        if (this.stickyParent instanceof HTMLElement) {
+            this.parentElement = this.stickyParent;
         }
         else {
-            console.warn(`Setting with key "${key}" not found.`);
-            this.settingsCache.set(key, value);
-            this.set(key, value);
+            this.parentElement = document.querySelector(this.stickyParent) || window;
         }
+        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
+        this.topOffset = this.targetElement.offsetTop;
+        this.parentElement.addEventListener('scroll', this.onParentScroll.bind(this));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingsService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXPCommonEffects {
-    constructor(actions$, router, settingService) {
-        this.actions$ = actions$;
-        this.router = router;
-        this.settingService = settingService;
-        this.command$ = createEffect(() => this.actions$.pipe(ofType(AXPNavigateAction), switchMap((action) => {
-            if (Array.isArray(action.payload.commands))
-                this.router.navigate(action.payload.commands, action.payload.extras);
-            else {
-                if (action.payload.commands.toLowerCase().startsWith('http'))
-                    window.open(action.payload.commands, '_blank');
-                else
-                    this.router.navigate([action.payload.commands], action.payload.extras);
-            }
-            return of();
-        })), { dispatch: false });
+    ngOnDestroy() {
+        this.parentElement.removeEventListener('scroll', this.onParentScroll);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1$2.Actions }, { token: i1.Router }, { token: AXPSettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$2.Actions }, { type: i1.Router }, { type: AXPSettingsService }] });
-
-const AXPMenuService = signalStore({ providedIn: 'root' }, 
-// Initial State
-withState((router = inject(Router)) => {
-    return {
-        items: [],
-        selectedMenuItem: null,
-    };
-}), 
-// Methods for State Management
-withMethods((store, router = inject(Router), globalStore = inject((Store))) => {
-    return {
-        setMenuItems(items) {
-            patchState(store, { items: items });
-        },
-        selectMenuItemByRoute(path) {
-            const findItem = (items) => {
-                for (const item of items) {
-                    if (item.children) {
-                        const foundChild = findItem(item.children);
-                        if (foundChild) {
-                            return foundChild;
-                        }
-                    }
-                    else if (item.path === path) {
-                        return item;
-                    }
-                }
-                return null;
-            };
-            const items = store.items();
-            const selectedItem = findItem(items);
-            patchState(store, { selectedMenuItem: selectedItem });
-        },
-        executeCommand(item) {
-            if (item.command) {
-                globalStore.dispatch(item.command);
-            }
-            else if (item.path) {
-                globalStore.dispatch(AXPNavigateAction({ payload: { commands: item.path } }));
-            }
-            patchState(store, { selectedMenuItem: item });
-        },
-        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 || findParent(item, selectedItem);
-        }
-    };
-}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => ({
-    onInit() {
-        (async () => {
-            const items = await menuProviderService.items();
-            patchState(store, { items: items });
-        })();
-    },
-    onDestroy() {
-    },
-})));
-
-class AXPFooterTextSlotComponent {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
-      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
-    `, isInline: true }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", 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: "18.2.0", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
-            type: Component,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPStickyDirective, decorators: [{
+            type: Directive,
             args: [{
-                    template: `
-      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
-    `,
+                    selector: '[axpSticky]',
+                    exportAs: 'axpSticky',
                     standalone: true
                 }]
-        }], propDecorators: { text: [{
-                type: Input
-            }] } });
-
-class AXPNavBarSlotComponent {
-    constructor() {
-        this.store = inject(Store);
-    }
-    handleCommand(action) {
-        if (action)
-            this.store.dispatch(action);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", 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$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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>
-    `,
-                    standalone: true,
-                    imports: [CommonModule],
-                    encapsulation: ViewEncapsulation.None
-                }]
-        }], propDecorators: { items: [{
-                type: Input
-            }] } });
-
-const AXPWindowResizeAction = createAction('[Layout] Resize');
-//
-const AXPLayoutRootDrawerClose = createAction('[Root Drawer] Close');
-const AXPLayoutRootDrawerToggle = createAction('[Root Drawer] Toggle');
-const AXPLayoutChildDrawerClose = createAction('[Child Drawer] Close');
-const AXPLayoutChildDrawerToggle = createAction('[Child Drawer] Toggle');
-//
-const AXPLoadingShowAction = createAction('[Theme] Loading Show');
-const AXPLoadingHideAction = createAction('[Theme] Loading Hide');
-
-class AXPLayoutEffects {
-    constructor() {
-        this.settingService = inject(AXPSettingsService);
-        this.actions$ = inject(Actions);
-        this.store$ = inject(Store);
-        this.resize$ = createEffect(() => fromEvent(window, 'resize').pipe(debounceTime(300), map(() => AXPWindowResizeAction())));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutEffects }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLayoutEffects, decorators: [{
-            type: Injectable
-        }] });
-
-const platform$1 = new AXPlatform();
-const initialState = {
-    screen: {
-        small: platform$1.is('SM') || platform$1.is('MD'),
-    },
-    drawer: {
-        root: !(platform$1.is('SM') || platform$1.is('MD')),
-        child: !(platform$1.is('SM') || platform$1.is('MD'))
-    },
-    loading: false
-};
-
-const platform = new AXPlatform();
-const AXPLayoutFeature = createFeature({
-    name: 'layout',
-    reducer: createReducer(initialState, 
-    // close drawers on navigatin
-    on(AXPNavigateAction, (state, action) => ({
-        ...state,
-        drawer: {
-            ...state.drawer,
-            root: platform.is('SM') ? false : state.drawer.root,
-            child: platform.is('SM') ? false : state.drawer.child,
-        },
-    })), 
-    // toggle root drawers
-    on(AXPLayoutRootDrawerToggle, (state, action) => ({
-        ...state,
-        drawer: {
-            ...state.drawer,
-            root: !state.drawer.root,
-            child: !state.drawer.root && platform.is('SM') ? false : state.drawer.child,
-        },
-    })), 
-    // close root drawers
-    on(AXPLayoutRootDrawerClose, (state) => ({
-        ...state,
-        drawer: { ...state.drawer, root: false },
-    })), 
-    // toggle second level child drawers
-    on(AXPLayoutChildDrawerToggle, (state) => ({
-        ...state,
-        drawer: { ...state.drawer, child: !state.drawer.child },
-    })), 
-    // close second level child drawers
-    on(AXPLayoutChildDrawerClose, (state) => ({
-        ...state,
-        drawer: { ...state.drawer, child: false },
-    })), 
-    // close drawers on window resize event
-    on(AXPWindowResizeAction, (state) => ({
-        ...state,
-        screen: { small: platform.is('SM') || platform.is('MD') },
-        drawer: {
-            ...state.drawer,
-            root: platform.is('SM') || platform.is('MD') ? false : state.drawer.root,
-            child: platform.is('SM') || platform.is('MD') ? false : state.drawer.child,
-        },
-    })), 
-    // Admin Root layout loading
-    on(AXPLoadingShowAction, (state) => ({
-        ...state,
-        loading: true,
-    })), on(AXPLoadingHideAction, (state) => ({
-        ...state,
-        loading: false,
-    }))),
-});
-const { name, reducer, selectLayoutState } = AXPLayoutFeature;
-
-const getRootDrawer = () => createSelector(selectLayoutState, (value) => value.drawer.root);
-const getChildDrawer = () => createSelector(selectLayoutState, (value) => value.drawer.child);
-const isSmallScreen = () => createSelector(selectLayoutState, (value) => value.screen.small);
-const isLoading = () => createSelector(selectLayoutState, (value) => value.loading);
-
-//TODO Loading, Redirect, Drawer, Show toast
-const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
-class AXPWorkflowNavigateAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.router = inject(Router);
-    }
-    async execute(context) {
-        const payload = context.getVariable('payload');
-        if (Array.isArray(payload.commands))
-            this.router.navigate(payload.commands, payload.extras);
-        else {
-            if (payload.commands.toLowerCase().startsWith('http'))
-                window.open(payload.commands, '_blank');
-            else
-                this.router.navigate([payload.commands], payload.extras);
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPDialogConfirmAction extends AXPWorkflowAction {
+        }], 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 {
     constructor() {
-        super(...arguments);
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
+        this.registry = new Map();
     }
-    async execute(context) {
-        context.setOutput('result', false);
-        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync(this.title), await this.translationService.translateAsync(this.message), (await this.translationService.translateAsync(this.type)));
-        context.setOutput('result', dialogResult.result);
+    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);
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction }); }
+    get(slotName) {
+        return this.registry.get(slotName) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
-            type: Injectable
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
         }] });
-class AXPToastAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
+
+class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
     }
-    async execute(context) {
-        this.toastService.show({
-            color: this.color,
-            title: await this.translationService.translateAsync(this.title),
-            content: await this.translationService.translateAsync(this.content),
-            closeButton: true,
-            timeOut: 3000,
-            timeOutProgress: true,
-        });
+    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);
+                }
+            });
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPToastAction, decorators: [{
-            type: Injectable
-        }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
 
-class AXMWorkflowErrorHandler {
-    constructor() {
-        this.dialog = inject(AXDialogService);
+class AXPComponentSlotDirective {
+    constructor(dynamicLoaderService, viewContainerRef) {
+        this.dynamicLoaderService = dynamicLoaderService;
+        this.viewContainerRef = viewContainerRef;
     }
-    handleError(error, next) {
-        if (error instanceof AXPWorkflowError) {
-            this.dialog.alert("Somthing is wrong!", error.inner ? error.inner.message : error.message, 'danger');
-            next(error);
-        }
-        else {
-            next(error);
-        }
+    ngOnInit() {
+        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.0", type: AXPComponentSlotDirective, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMWorkflowErrorHandler, decorators: [{
-            type: Injectable
-        }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
+                type: Input
+            }] } });
 
-class AXPCommonModule {
+class AXPComponentSlotModule {
     static forRoot(configs) {
         return {
-            ngModule: AXPCommonModule,
+            ngModule: AXPComponentSlotModule,
             providers: [
-                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPCommonModuleFactory',
+                    provide: 'AXPComponentSlotModuleFactory',
                     useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
                     },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
     }
     static forChild(configs) {
         return {
-            ngModule: AXPCommonModule,
+            ngModule: AXPComponentSlotModule,
             providers: [
-                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPCommonModuleFactory',
+                    provide: 'AXPComponentSlotModuleFactory',
                     useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
                     },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
     }
     /**
      * @ignore
      */
-    constructor(instances, appInitService, settingsService, seederService) {
-        instances.forEach((f) => {
+    constructor(instances) {
+        instances?.forEach(f => {
             f();
         });
-        // appInitService.registerTask({
-        //   name: 'Modules',
-        //   statusText: 'Initializing Modules ...',
-        //   run: () =>
-        //     new Promise<void>((resolve) => {
-        //       setTimeout(() => {
-        //         resolve();
-        //       }, 250);
-        //     }),
-        // });
-        //
-        appInitService.registerTask({
-            name: 'Settings',
-            statusText: 'Loading Settings ...',
-            run: async () => {
-                await settingsService.load();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPComponentSlotModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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: "18.2.0", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", 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$1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2$1.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i5$1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLogoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-logo', standalone: true, 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 {
+    constructor() {
+        this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
+    }
+    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);
             }
-        });
-        //
-        //
-        appInitService.registerTask({
-            name: 'Seeder',
-            statusText: 'Seed Data ...',
-            run: async () => {
-                await seederService.seed();
-            },
-        });
+        }
+        // Apply pending operations
+        this.applyPendingOperations(items);
+        // Cache the computed items
+        this.cache = items;
+        return items;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingsService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, imports: [i1$2.EffectsFeatureModule, i5$1.StoreFeatureModule, i6.AXPWorkflowModule, AXPopupModule,
-            AXDateTimeModule,
-            AXToastModule], exports: [RouterModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, providers: [
-            AXPAppStartUpProvider,
-            {
-                provide: ErrorHandler,
-                useClass: AXPGlobalErrorHandler,
+    createMenuProviderContext(items) {
+        return {
+            addItems: (newItems) => {
+                items.push(...newItems);
             },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),
-            StoreModule.forFeature(AXPLayoutFeature),
-            AXPWorkflowModule.forChild({
-                actions: {
-                    navigate: AXPDialogConfirmAction,
-                    'show-prompt-dialog': AXPDialogConfirmAction,
-                    'show-toast': AXPToastAction,
-                },
-            }),
-            AXPopupModule,
-            AXDateTimeModule,
-            AXToastModule, RouterModule] }); }
+            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 {
+                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);
+            }
+        }
+        // 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;
+                }
+            }
+        }
+        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 = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),
-                        StoreModule.forFeature(AXPLayoutFeature),
-                        AXPWorkflowModule.forChild({
-                            actions: {
-                                navigate: AXPDialogConfirmAction,
-                                'show-prompt-dialog': AXPDialogConfirmAction,
-                                'show-toast': AXPToastAction,
-                            },
-                        }),
-                        AXPopupModule,
-                        AXDateTimeModule,
-                        AXToastModule,
-                    ],
-                    exports: [RouterModule],
-                    providers: [
-                        AXPAppStartUpProvider,
-                        {
-                            provide: ErrorHandler,
-                            useClass: AXPGlobalErrorHandler,
-                        },
-                    ],
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['AXPCommonModuleFactory']
-                }] }, { type: AXPAppStartUpService }, { type: AXPSettingsService }, { type: AXPDataSeederService }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
-const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
-    providedIn: 'root',
-    factory: () => {
-        return AXPPlatformDefaultConfigs;
+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), globalStore = inject(Store)) => {
+    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);
+                        if (matchResult.isMatch) {
+                            return { item, isPartialMatch: matchResult.isPartial };
+                        }
+                    }
+                }
+                return { item: null, isPartialMatch: false };
+            };
+            const pathsMatch = (itemPath, currentPath) => {
+                // Split both paths into segments
+                const itemSegments = itemPath.split('/').filter(segment => segment.length > 0);
+                const pathSegments = currentPath.split('/').filter(segment => segment.length > 0);
+                // Determine the minimum number of segments to compare
+                const minLength = Math.min(itemSegments.length, pathSegments.length);
+                // Compare segments until we find a mismatch
+                let commonBaseLength = 0;
+                for (let i = 0; i < minLength; i++) {
+                    if (itemSegments[i] === pathSegments[i]) {
+                        commonBaseLength++;
+                    }
+                    else {
+                        break; // Stop at the first mismatch
+                    }
+                }
+                // Determine if we have a common base of at least 5 segments
+                const isPartialMatch = commonBaseLength >= 5 && commonBaseLength < itemSegments.length;
+                const isExactMatch = commonBaseLength === itemSegments.length && itemSegments.length === pathSegments.length;
+                return {
+                    isMatch: isPartialMatch || isExactMatch,
+                    isPartial: isPartialMatch && !isExactMatch,
+                };
+            };
+            const items = store.items();
+            const { item, isPartialMatch } = findItem(items);
+            patchState(store, { selectedMenuItem: { item, isFullMatch: !isPartialMatch } });
+        },
+        executeCommand(item) {
+            if (item.command) {
+                globalStore.dispatch(item.command);
+            }
+            else if (item.path) {
+                globalStore.dispatch(AXPNavigateAction({ payload: { commands: item.path } }));
+            }
+            patchState(store, { selectedMenuItem: { item, isFullMatch: true } });
+        },
+        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);
+        }
+    };
+}), withHooks((store, menuProviderService = inject(AXPMenuProviderService)) => ({
+    onInit() {
+        (async () => {
+            const items = await menuProviderService.items();
+            patchState(store, { items: items });
+        })();
     },
-});
-const AXPPlatformDefaultConfigs = {
-    copyright: 'ACoreX @ 2023',
-    title: 'ACoreX Platform',
-    logo: {
-        dark: new AXPTextLogoConfig('ACoreX'),
-        light: new AXPTextLogoConfig('ACoreX'),
-        colored: new AXPTextLogoConfig('ACoreX'),
+    onDestroy() {
     },
-    useLocalData: false,
-    network: {
-        timeOut: 5000,
-    }
-};
-function configPlatform(config = AXPPlatformDefaultConfigs) {
-    return merge(AXPPlatformDefaultConfigs, config);
+})));
+
+class AXPFooterTextSlotComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
+      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+    `, isInline: true }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+    `,
+                    standalone: true
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
 
-const AXP_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
+class AXPNavBarSlotComponent {
+    constructor() {
+        this.store = inject(Store);
+    }
+    handleCommand(action) {
+        if (action)
+            this.store.dispatch(action);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", 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$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", 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>
+    `,
+                    standalone: true,
+                    imports: [CommonModule],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
 
 class AXPSchemaRegistryService {
     constructor() {
@@ -2039,7 +2173,7 @@ class AXPWidgetFilterRendererComponent {
     } @else {
     <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1$3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$1.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWidgetFilterRendererComponent, decorators: [{
             type: Component,
@@ -2284,7 +2418,7 @@ class AXPWidgetRendererComponent {
     } @else {
     <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
     }
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1$3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$1.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWidgetRendererComponent, decorators: [{
             type: Component,
@@ -2471,22 +2605,22 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-text-widget-view.component-BDxpsxE6.mjs').then((c) => c.AXPTextWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-text-widget-view.component-BK3HZGgb.mjs').then((c) => c.AXPTextWidgetViewComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-B9h7CnEz.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-text-widget-edit.component-BiyTKmvV.mjs').then((c) => c.AXPTextWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-text-widget-edit.component-DC_GnFhe.mjs').then((c) => c.AXPTextWidgetEditComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-text-widget-column.component-LFKeHZbS.mjs').then((c) => c.AXPTextWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-text-widget-column.component-DVczwvKA.mjs').then((c) => c.AXPTextWidgetColumnComponent),
                     options: { allowResizing: true },
                 },
             },
             filterOptions: {
                 operators: [...STRING_OPERATORS],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             name: widgetSchemas.text,
             dataType: 'string',
@@ -2495,7 +2629,7 @@ class AXPCommonWidgetModule {
             name: widgetSchemas.largetext,
             component: {
                 edit: {
-                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-BeiJZnEv.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-DGMxpnsr.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
                 },
                 column: {
                     options: {
@@ -2508,16 +2642,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-number-widget-view.component-Du1oQYBH.mjs').then((c) => c.AXPNumberWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-number-widget-view.component-DGfLSGw1.mjs').then((c) => c.AXPNumberWidgetViewComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-number-widget-filter.component-BgTJbR2u.mjs').then((c) => c.AXPNumberWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-number-widget-filter.component-DxfJ90n4.mjs').then((c) => c.AXPNumberWidgetFilterComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-number-widget-edit.component-B0if4vR4.mjs').then((c) => c.AXPNumberWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-number-widget-edit.component-Bc5-ZUw4.mjs').then((c) => c.AXPNumberWidgetEditComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-number-widget-view.component-Du1oQYBH.mjs').then((c) => c.AXPNumberWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-number-widget-view.component-DGfLSGw1.mjs').then((c) => c.AXPNumberWidgetViewComponent),
                     options: { allowResizing: true },
                 },
             },
@@ -2545,23 +2679,23 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-phone-widget-view.component-xGygt5Y9.mjs').then((c) => c.AXPPhoneWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-phone-widget-view.component-BlFVuoNN.mjs').then((c) => c.AXPPhoneWidgetViewComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-phone-widget-column.component-DGaGGltV.mjs').then((c) => c.AXPPhoneWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-phone-widget-column.component-D99ncxxJ.mjs').then((c) => c.AXPPhoneWidgetColumnComponent),
                     options: { allowResizing: true },
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-phone-widget-edit.component-BNfAQ_4j.mjs').then((c) => c.AXPPhoneWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-phone-widget-edit.component-a5EAI9FK.mjs').then((c) => c.AXPPhoneWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-B9h7CnEz.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
             },
             name: widgetSchemas.phone,
             filterOptions: {
                 operators: [...STRING_OPERATORS],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             dataType: 'object',
         });
@@ -2569,23 +2703,23 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-email-widget-view.component-CvEHLvcT.mjs').then((c) => c.AXPEmailWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-email-widget-view.component-C3AUr1HO.mjs').then((c) => c.AXPEmailWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-email-widget-edit.component-DTxCX3ok.mjs').then((c) => c.AXPEmailWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-email-widget-edit.component--0gaRm4s.mjs').then((c) => c.AXPEmailWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-B9h7CnEz.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-email-widget-column.component-Cy_Kj9po.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-email-widget-column.component-CLNqSuB7.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
                     options: { allowResizing: true },
                 },
             },
             name: widgetSchemas.email,
             filterOptions: {
                 operators: [...STRING_OPERATORS],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             dataType: 'object',
         });
@@ -2593,16 +2727,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-view.component-lzf0fwxr.mjs').then((c) => c.AXPDateTimeWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-dateTime-widget-view.component-KGgJkiKB.mjs').then((c) => c.AXPDateTimeWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-edit.component-Dm4QofDq.mjs').then((c) => c.AXPDateTimeWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-dateTime-widget-edit.component-D8W-XEcx.mjs').then((c) => c.AXPDateTimeWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-filter.component-DDny36SE.mjs').then((c) => c.AXPDateTimeWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-dateTime-widget-filter.component-DngCKwFY.mjs').then((c) => c.AXPDateTimeWidgetFilterComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-column.component-CtS98tbi.mjs').then((c) => c.AXPDateTimeWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-dateTime-widget-column.component-DG0leXAo.mjs').then((c) => c.AXPDateTimeWidgetColumnComponent),
                     options: {
                         width: '200px',
                         allowResizing: true,
@@ -2649,19 +2783,19 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-toggle-widget-view.component-Cq2-5QUg.mjs').then((c) => c.AXPToggleWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-toggle-widget-view.component-BTaXXZ88.mjs').then((c) => c.AXPToggleWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-toggle-widget-edit.component-Cz7LayX-.mjs').then((c) => c.AXPToggleWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-toggle-widget-edit.component-D64m4agx.mjs').then((c) => c.AXPToggleWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-DRDiIxsn.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-S4-3SmKA.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-toggle-widget-column.component-BnmR9hFM.mjs').then((c) => c.AXPToggleWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-toggle-widget-column.component-Bp1d7SAE.mjs').then((c) => c.AXPToggleWidgetColumnComponent),
                     options: {
                         width: '100px',
-                        allowResizing: true
+                        allowResizing: true,
                     },
                 },
             },
@@ -2676,19 +2810,19 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-view.component-D7kmxXjj.mjs').then((c) => c.AXPCheckboxWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-checkbox-widget-view.component-CKz8XnjT.mjs').then((c) => c.AXPCheckboxWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-edit.component-BuS0Pg-j.mjs').then((c) => c.AXPCheckboxWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-checkbox-widget-edit.component-PFRq-XS-.mjs').then((c) => c.AXPCheckboxWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-DRDiIxsn.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-S4-3SmKA.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-column.component-Bn0tnHyT.mjs').then((c) => c.AXPCheckboxWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-checkbox-widget-column.component-DOoneR7g.mjs').then((c) => c.AXPCheckboxWidgetColumnComponent),
                     options: {
                         width: '100px',
-                        allowResizing: true
+                        allowResizing: true,
                     },
                 },
             },
@@ -2703,16 +2837,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-password-widget-view.component-BVW-Zak-.mjs').then((c) => c.AXPPasswordWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-password-widget-view.component-B_HU-3J1.mjs').then((c) => c.AXPPasswordWidgetViewComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-password-widget-column.component-CEWtRX1S.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-password-widget-column.component-DEHaVLGK.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-password-widget-edit.component-B-_m6f_C.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-password-widget-edit.component-DrYyu5v-.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -2726,19 +2860,19 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-file-widget-view.component-RsQQjlL7.mjs').then((c) => c.AXPFileWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-file-widget-view.component-BvMzrs5C.mjs').then((c) => c.AXPFileWidgetViewComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-file-widget-column.component-GtbElxmS.mjs').then((c) => c.AXPFileWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-file-widget-column.component-C9AHk2UP.mjs').then((c) => c.AXPFileWidgetColumnComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-file-widget-edit.component-3fR5jRFv.mjs').then((c) => c.AXPFileWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-file-widget-edit.component-L7bln9k0.mjs').then((c) => c.AXPFileWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-file-widget-filter.component-B7etTIuq.mjs').then((c) => c.AXPFileWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-file-widget-filter.component-Ce35mqny.mjs').then((c) => c.AXPFileWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -2752,24 +2886,24 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-lookup-widget-view.component-DTNcGNir.mjs').then((c) => c.AXPLookupWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-lookup-widget-view.component-DYAg76YH.mjs').then((c) => c.AXPLookupWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-lookup-widget-edit.component-uopyJIC1.mjs').then((c) => c.AXPLookupWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-lookup-widget-edit.component-DqB_g9Zz.mjs').then((c) => c.AXPLookupWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-lookup-widget-filter.component-D1lrIkz4.mjs').then((c) => c.AXPLookupWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-lookup-widget-filter.component-0TPWNWSd.mjs').then((c) => c.AXPLookupWidgetFilterComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-lookup-widget-column.component-C5DZ-cez.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-lookup-widget-column.component-B-cEaNjv.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
             },
             filterOptions: {
                 operators: [],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             name: widgetSchemas.lookup,
             dataType: 'object',
@@ -2778,24 +2912,24 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-view.component-DLc1MHex.mjs').then((c) => c.AXPSelectionListWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-view.component-3hinF85C.mjs').then((c) => c.AXPSelectionListWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-edit.component-Tdkf-0cn.mjs').then((c) => c.AXPSelectionListWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-edit.component-BmbDQ1LH.mjs').then((c) => c.AXPSelectionListWidgetEditComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-column.component-1zPVFgFG.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-column.component-CkOuYy0Z.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-y2aFk-A6.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-Dm_1-7eT.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
                 },
             },
             filterOptions: {
                 operators: [],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             name: widgetSchemas.selectionList,
             dataType: 'object',
@@ -2804,27 +2938,27 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-view.component-B77Y5luo.mjs').then((c) => c.AXPRichTextWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-rich-text-widget-view.component-B9WB-mx9.mjs').then((c) => c.AXPRichTextWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-edit.component-Dvv8JnXl.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-rich-text-widget-edit.component-DL5UyAqe.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-column.component-BJYxnZm2.mjs').then((c) => c.AXPRichTextWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-rich-text-widget-column.component-DOdv5I2s.mjs').then((c) => c.AXPRichTextWidgetColumnComponent),
                     options: {
                         width: '400px',
                     },
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-string-widget-filter.component-B9h7CnEz.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
             },
             filterOptions: {
                 operators: [...STRING_OPERATORS],
-                default: CONTAINS_OPER,
+                default: EQ_OPER,
             },
             name: widgetSchemas.richText,
             dataType: 'object',
@@ -2833,10 +2967,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-map-widget-view.component-Deos8gVy.mjs').then((c) => c.AXPMapWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-map-widget-view.component-C-DCNaJi.mjs').then((c) => c.AXPMapWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-map-widget-edit.component-h4SRiV6_.mjs').then((c) => c.AXPMapWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-map-widget-edit.component-C3cpsXD5.mjs').then((c) => c.AXPMapWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -2850,10 +2984,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-avatar-widget-view.component-CfHELBLm.mjs').then((c) => c.AXPAvatarWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-avatar-widget-view.component-BOIV0Be1.mjs').then((c) => c.AXPAvatarWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-avatar-widget-edit.component-BYEjzXpW.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-avatar-widget-edit.component-DtC2IaE8.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -2867,16 +3001,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-messenger-widget-view.component-DA9MiNb9.mjs').then((c) => c.AXPMessengerWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-messenger-widget-view.component-B6FavkmG.mjs').then((c) => c.AXPMessengerWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-messenger-widget-edit.component-m_zxHCw5.mjs').then((c) => c.AXPMessengerWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-messenger-widget-edit.component-DC8vQDo0.mjs').then((c) => c.AXPMessengerWidgetEditComponent),
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-messenger-widget-column.component-DN8dFLZD.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-messenger-widget-column.component-B2A7ZBEP.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
                     options: {
-                        allowResizing: true
-                    }
+                        allowResizing: true,
+                    },
                 },
             },
             filterOptions: {
@@ -2891,13 +3025,13 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-gallery-widget-view.component-YaLJU3Cv.mjs').then((c) => c.AXPGalleryWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-gallery-widget-view.component-D8YmSi9C.mjs').then((c) => c.AXPGalleryWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-gallery-widget-edit.component-CixJEDUT.mjs').then((c) => c.AXPGalleryWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-gallery-widget-edit.component-BVuV2Ib8.mjs').then((c) => c.AXPGalleryWidgetEditComponent),
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-gallery-widget-filter.component-1wzY6U5s.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-gallery-widget-filter.component-C8tdM6PX.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -2911,10 +3045,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-signature-pad-widget-view.component-D5XVZ88b.mjs').then((c) => c.AXPSignaturePadWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-signature-pad-widget-view.component-DkFaMNk8.mjs').then((c) => c.AXPSignaturePadWidgetViewComponent),
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-signature-pad-widget-edit.component-qUuwwYlj.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-signature-pad-widget-edit.component-DmmPbw-A.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -2944,5 +3078,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXMenuLoaderDefault, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLayoutChildDrawerClose, AXPLayoutChildDrawerToggle, AXPLayoutEffects, AXPLayoutFeature, AXPLayoutRootDrawerClose, AXPLayoutRootDrawerToggle, AXPLayoutService, AXPLoadingHideAction, AXPLoadingShowAction, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPRouteUtilityService, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWindowResizeAction, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTINGS_PROVIDER, AXP_WIDGET_TOKEN, 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, convertPropertiesToColumns, convertPropertyToColumn, getChildDrawer, getEntityInfo, getRootDrawer, initialState, isLoading, isSmallScreen, name, reducer, resolveActionLook, selectLayoutState, widgetSchemas };
+export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefinitionProviderService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTINGS_PROVIDER, AXP_SETTING_PROVIDER, AXP_WIDGET_TOKEN, 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, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
 //# sourceMappingURL=acorex-platform-common.mjs.map