@acorex/platform 18.2.2 → 18.2.3

package/fesm2022/acorex-platform-common.mjs

@@ -1,30 +1,28 @@
 import * as i0 from '@angular/core';
-import { Injectable, APP_INITIALIZER, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, Input, Directive, EventEmitter, Output, runInInjectionContext, Optional, Inject, NgModule, Component, ViewEncapsulation, ChangeDetectorRef, ViewChild, ChangeDetectionStrategy } 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 i2$1 from '@angular/router';
+import * as i2 from '@angular/router';
 import { Router, RouterModule } from '@angular/router';
-import * as i1$1 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 i1 from '@ngrx/effects';
+import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
 import { applySortArray, applyFilterArray } from '@acorex/platform/core';
 import Dexie from 'dexie';
-import { BehaviorSubject, timer, Subject, switchMap, of, 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 from '@angular/common';
+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$2 from '@acorex/components/skeleton';
 import { AXSkeletonModule } from '@acorex/components/skeleton';
 import * as i1$2 from '@angular/cdk/portal';
@@ -174,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 {
 }
@@ -544,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 {
@@ -606,27 +642,66 @@ class AXMEntityCrudServiceImpl {
     }
 }
 
-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 {
@@ -688,203 +763,687 @@ 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;
-    }
-    ngOnChanges(changes) {
-        if (changes['options']) {
-            this.applyTailwindClasses();
-        }
-    }
-    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:');
-    }
-    setClasses(positions, prefix) {
-        if (positions == null)
-            return;
-        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
-        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
-        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
-        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
-        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
-        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
-        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
-        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
-            if (cls) {
-                this.renderer.addClass(this.el.nativeElement, cls);
-            }
-        });
-    }
-    clearClasses() {
-        const currentClasses = this.el.nativeElement.className.split(' ');
-        currentClasses.forEach((className) => {
-            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
-                this.renderer.removeClass(this.el.nativeElement, className);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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 {
+// Injection token for setting providers
+const AXP_SETTING_PROVIDER = new InjectionToken('AXP_SETTING_PROVIDER');
+class AXPSettingDefinitionProviderService {
     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.providers = inject(AXP_SETTING_PROVIDER, { optional: true });
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingAdditions = [];
+    }
+    // Retrieve all setting items, applying any pending operations
+    async items() {
+        if (this.cache) {
+            return this.cache;
         }
-        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);
-                    }
-                });
+        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;
     }
-    updateNavigationLoadingState(state) {
-        if (state !== this.navigationLoadingStateActive) {
-            this.navigationLoadingStateActive = state;
-            this.navigationLoadingSubject.next(state);
+    findGroupDetails(groupName) {
+        if (this.cache) {
+            return this.searchGroupDetails(this.cache, groupName, []); // Initialize with an empty breadcrumb
         }
+        return null;
     }
-    get overlayLoading$() {
-        return this.overlayLoadingSubject.asObservable();
-    }
-    setOverlayLoading(value) {
-        if (value) {
-            this.overlayLoadingTaskCount++;
-            this.updateOverlayLoadingState(true);
-        }
-        else {
-            if (this.overlayLoadingTaskCount > 0) {
-                this.overlayLoadingTaskCount--;
+    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,
+                };
             }
-            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);
-                    }
-                });
+            // 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;
     }
-    updateOverlayLoadingState(state) {
-        if (state !== this.overlayLoadingStateActive) {
-            this.overlayLoadingStateActive = state;
-            this.overlayLoadingSubject.next(state);
-        }
+    // 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: 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: 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: AXPLayoutService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingDefinitionProviderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
 
-class AXPStickyDirective {
-    get isSticky() {
-        return this._isSticky;
+const AXP_SETTINGS_PROVIDER = new InjectionToken('AXP_SETTINGS_PROVIDER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPSettingsProviderDefault();
     }
-    set isSticky(v) {
-        this._isSticky = v;
-        this.isStickyChange.emit(v);
+});
+class AXPSettingsProviderDefault {
+    constructor() {
+        this.cache = new Map();
+        this.localStorageKey = 'AXP_SETTINGS';
     }
-    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();
-                }
+    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);
             });
-        };
-    }
-    ngAfterViewInit() {
-        if (this.stickyParent instanceof HTMLElement) {
-            this.parentElement = this.stickyParent;
-        }
-        else {
-            this.parentElement = document.querySelector(this.stickyParent) || window;
+            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
         }
-        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
-        this.topOffset = this.targetElement.offsetTop;
-        this.parentElement.addEventListener('scroll', this.onParentScroll.bind(this));
+        return Promise.resolve([]);
     }
-    ngOnDestroy() {
-        this.parentElement.removeEventListener('scroll', this.onParentScroll);
+    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: 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: AXPStickyDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[axpSticky]',
-                    exportAs: 'axpSticky',
-                    standalone: true
-                }]
+
+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);
+            });
+            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 });
+        }
+        else {
+            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: 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',
+                }]
+        }] });
+
+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 });
+    }
+    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);
+    }
+    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') || payload.target == "blank") {
+                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 {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    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: 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: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
+    }
+    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: 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: AXPToastAction, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMWorkflowErrorHandler {
+    constructor() {
+        this.dialog = inject(AXDialogService);
+    }
+    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: 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: AXMWorkflowErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPCommonModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPCommonModule,
+            providers: [
+                ...(configs?.errorHandlers || []),
+                {
+                    provide: 'AXPCommonModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.register(...(configs?.errorHandlers || []));
+                    },
+                    deps: [AXPErrorHandlerRegistryService],
+                    multi: true,
+                },
+            ],
+        };
+    }
+    /**
+     * @ignore
+     */
+    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: 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: AXPCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    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: Inject,
+                    args: ['AXPCommonModuleFactory']
+                }] }, { type: AXPAppStartUpService }, { type: AXPSettingsService }, { type: AXPDataSeederService }] });
+
+class AXPTextLogoConfig {
+    constructor(text) {
+        this.text = text;
+    }
+}
+class AXPImageUrlLogoConfig {
+    constructor(url) {
+        this.url = url;
+    }
+}
+class AXPFontIconLogoConfig {
+    constructor(iconClass) {
+        this.iconClass = iconClass;
+    }
+}
+class AXPComponentLogoConfig {
+    constructor(component) {
+        this.component = component;
+    }
+}
+
+const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
+const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
+    providedIn: 'root',
+    factory: () => {
+        return AXPPlatformDefaultConfigs;
+    },
+});
+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_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;
+    }
+    ngOnChanges(changes) {
+        if (changes['options']) {
+            this.applyTailwindClasses();
+        }
+    }
+    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:');
+    }
+    setClasses(positions, prefix) {
+        if (positions == null)
+            return;
+        const colStart = positions.colStart ? `${prefix}ax-col-start-${positions.colStart}` : '';
+        const colEnd = positions.colEnd ? `${prefix}ax-col-end-${positions.colEnd}` : '';
+        const colSpan = positions.colSpan ? `${prefix}ax-col-span-${positions.colSpan}` : '';
+        const rowStart = positions.rowStart ? `${prefix}ax-row-start-${positions.rowStart}` : '';
+        const rowEnd = positions.rowEnd ? `${prefix}ax-row-end-${positions.rowEnd}` : '';
+        const rowSpan = positions.rowSpan ? `${prefix}ax-row-span-${positions.rowSpan}` : '';
+        const order = positions.order ? `${prefix}ax-order-${positions.order}` : ''; // Handling order
+        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
+            if (cls) {
+                this.renderer.addClass(this.el.nativeElement, cls);
+            }
+        });
+    }
+    clearClasses() {
+        const currentClasses = this.el.nativeElement.className.split(' ');
+        currentClasses.forEach((className) => {
+            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "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 AXPStickyDirective {
+    get isSticky() {
+        return this._isSticky;
+    }
+    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();
+                }
+            });
+        };
+    }
+    ngAfterViewInit() {
+        if (this.stickyParent instanceof HTMLElement) {
+            this.parentElement = this.stickyParent;
+        }
+        else {
+            this.parentElement = document.querySelector(this.stickyParent) || window;
+        }
+        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
+        this.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 }); }
+}
+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']
@@ -1065,27 +1624,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                     args: ['AXPComponentSlotModuleFactory']
                 }] }] });
 
-class AXPTextLogoConfig {
-    constructor(text) {
-        this.text = text;
-    }
-}
-class AXPImageUrlLogoConfig {
-    constructor(url) {
-        this.url = url;
-    }
-}
-class AXPFontIconLogoConfig {
-    constructor(iconClass) {
-        this.iconClass = iconClass;
-    }
-}
-class AXPComponentLogoConfig {
-    constructor(component) {
-        this.component = component;
-    }
-}
-
 class AXPLogoComponent {
     ngOnInit() {
         switch (true) {
@@ -1106,7 +1644,7 @@ class AXPLogoComponent {
         }
     }
     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.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"] }] }); }
+    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,
@@ -1240,358 +1778,15 @@ class AXPMenuProviderService {
         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: AXPMenuProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-const AXPNavigateAction = createAction('[Navigate] Action', props());
-const AXPSignOutAction = createAction('[SignOut] Action');
-const AXPSignInAction = createAction('[SignIn] Action');
-
-// Enum to distinguish between single settings and groups
-var AXPSettingDefinitionItemType;
-(function (AXPSettingDefinitionItemType) {
-    AXPSettingDefinitionItemType["Single"] = "single";
-    AXPSettingDefinitionItemType["Group"] = "group";
-})(AXPSettingDefinitionItemType || (AXPSettingDefinitionItemType = {}));
-
-// Injection token for setting providers
-const AXP_SETTING_PROVIDER = new InjectionToken('AXP_SETTING_PROVIDER');
-class AXPSettingProviderService {
-    constructor() {
-        this.providers = inject(AXP_SETTING_PROVIDER, { optional: true });
-        this.cache = null;
-        this.pendingInserts = [];
-        this.pendingAdditions = [];
-    }
-    // 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) {
-                await provider.provide(context);
-            }
-        }
-        this.applyPendingOperations(items);
-        this.cache = items;
-        return items;
-    }
-    // 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) => {
-                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;
-                                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;
-                                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;
-                                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;
-                                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;
-                                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;
-                                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.`);
-                        }
-                    },
-                };
-            },
-        };
-    }
-    applyPendingOperations(items) {
-        // Process pending insertions
-        for (const { target, newItems, position } of this.pendingInserts) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            if (foundItemInfo && foundItemInfo.foundItem) {
-                const { foundItem, parentItems } = foundItemInfo;
-                const index = parentItems.indexOf(foundItem);
-                const insertIndex = position === 'before' ? index : index + 1;
-                parentItems.splice(insertIndex, 0, ...newItems);
-            }
-            else {
-                console.warn(`Target "${target}" not found for insertion.`);
-            }
-        }
-        // Process pending additions
-        for (const { target, newItems } of this.pendingAdditions) {
-            const foundItemInfo = this.findItemWithParent(items, target);
-            if (foundItemInfo && foundItemInfo.foundItem) {
-                const { foundItem } = foundItemInfo;
-                if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-                    const group = foundItem;
-                    group.groups.push(...newItems.filter((item) => item.type === AXPSettingDefinitionItemType.Group));
-                    group.singles.push(...newItems.filter((item) => item.type === AXPSettingDefinitionItemType.Single));
-                }
-                else {
-                    console.warn(`Target "${target}" is not a group; cannot add items.`);
-                }
-            }
-            else {
-                console.warn(`Target "${target}" not found for adding items.`);
-            }
-        }
-        // Clear pending operations after applying them
-        this.pendingInserts = [];
-        this.pendingAdditions = [];
-    }
-    findItemWithParent(items, target, parentItems = items) {
-        for (const item of items) {
-            if (item.name === target) {
-                return { foundItem: item, parentItems };
-            }
-            if (item.type === AXPSettingDefinitionItemType.Group) {
-                const group = item;
-                // Search within child groups
-                const groupResult = this.findItemWithParent(group.groups, target, group.groups);
-                if (groupResult) {
-                    return groupResult;
-                }
-                // Search within child singles
-                const singleResult = this.findItemWithParent(group.singles, target, group.singles);
-                if (singleResult) {
-                    return singleResult;
-                }
-            }
-        }
-        return null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPSettingProviderService, 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));
-    }
-}
-
-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);
-            });
-            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 });
-        }
-        else {
-            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: 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 });
+        this.pendingAdditions = [];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1$1.Actions }, { token: i2$1.Router }, { token: AXPSettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonEffects }); }
+    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: AXPCommonEffects, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.Actions }, { type: i2$1.Router }, { type: AXPSettingsService }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPMenuProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 const AXPMenuService = signalStore({ providedIn: 'root' }, 
 // Initial State
@@ -1605,7 +1800,7 @@ withState((router = inject(Router)) => {
     };
 }), 
 // Methods for State Management
-withMethods((store, router = inject(Router), globalStore = inject((Store))) => {
+withMethods((store, router = inject(Router), globalStore = inject(Store)) => {
     return {
         setMenuItems(items) {
             patchState(store, { items: items });
@@ -1723,7 +1918,7 @@ class AXPNavBarSlotComponent {
     <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
         <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
     </div>
-    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
+    `, 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,
@@ -1741,340 +1936,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                 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 platform = inject(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') || payload.target == "blank") {
-                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 {
-    constructor() {
-        super(...arguments);
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    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: 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: AXPDialogConfirmAction, decorators: [{
-            type: Injectable
-        }] });
-class AXPToastAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
-    }
-    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: 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: AXPToastAction, decorators: [{
-            type: Injectable
-        }] });
-
-class AXMWorkflowErrorHandler {
-    constructor() {
-        this.dialog = inject(AXDialogService);
-    }
-    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: 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: AXMWorkflowErrorHandler, decorators: [{
-            type: Injectable
-        }] });
-
-class AXPCommonModule {
-    static forRoot(configs) {
-        return {
-            ngModule: AXPCommonModule,
-            providers: [
-                ...(configs?.errorHandlers || []),
-                {
-                    provide: 'AXPCommonModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
-                    },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
-        };
-    }
-    static forChild(configs) {
-        return {
-            ngModule: AXPCommonModule,
-            providers: [
-                ...(configs?.errorHandlers || []),
-                {
-                    provide: 'AXPCommonModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
-                    },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
-        };
-    }
-    /**
-     * @ignore
-     */
-    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: 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$1.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,
-            },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),
-            StoreModule.forFeature(AXPLayoutFeature),
-            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: 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 }] });
-
-const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
-const AXP_PLATFORM_CONFIG_TOKEN = new InjectionToken('AXP_PLATFORM_CONFIG_TOKEN', {
-    providedIn: 'root',
-    factory: () => {
-        return AXPPlatformDefaultConfigs;
-    },
-});
-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_ROOT_CONFIG_TOKEN = new InjectionToken('AXP_ROOT_CONFIG_TOKEN');
-
 class AXPSchemaRegistryService {
     constructor() {
         this.types = new Map();
@@ -2173,7 +2034,7 @@ class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
       }
     </ng-template>
     <ng-template #footer></ng-template>
-  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
             type: Component,
@@ -2744,16 +2605,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-text-widget-view.component-DsUAJ-md.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-wI9D-Ju5.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-feJTTnye.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-Be7Nr0lJ.mjs').then((c) => c.AXPTextWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-text-widget-column.component-DVczwvKA.mjs').then((c) => c.AXPTextWidgetColumnComponent),
                     options: { allowResizing: true },
                 },
             },
@@ -2768,7 +2629,7 @@ class AXPCommonWidgetModule {
             name: widgetSchemas.largetext,
             component: {
                 edit: {
-                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-D89AlBSm.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-DGMxpnsr.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
                 },
                 column: {
                     options: {
@@ -2781,16 +2642,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-number-widget-view.component-ROrdklif.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-CvEw3awN.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-gQCEBhPv.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-ROrdklif.mjs').then((c) => c.AXPNumberWidgetViewComponent),
+                    component: () => import('./acorex-platform-common-number-widget-view.component-DGfLSGw1.mjs').then((c) => c.AXPNumberWidgetViewComponent),
                     options: { allowResizing: true },
                 },
             },
@@ -2818,17 +2679,17 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-phone-widget-view.component-DDBCR_QY.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-BbuUbPCu.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-Bo_aOxfZ.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-wI9D-Ju5.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
             },
             name: widgetSchemas.phone,
@@ -2842,16 +2703,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-email-widget-view.component-ClRjKVy6.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-BfXFBLF6.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-wI9D-Ju5.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-Cm-fhlNZ.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-email-widget-column.component-CLNqSuB7.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
                     options: { allowResizing: true },
                 },
             },
@@ -2866,16 +2727,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-dateTime-widget-view.component-DxNwm_5m.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-CzLb3xnR.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-DZRQ6yVk.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-QUYyDVw8.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,
@@ -2922,16 +2783,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-toggle-widget-view.component-DYz6VTey.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-Cuf9_RrU.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-BdE7WOK5.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-BFwzsY4-.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,
@@ -2949,16 +2810,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-checkbox-widget-view.component-CbQwjE_u.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-ChXbJsuG.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-BdE7WOK5.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-Bj5rjEk1.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,
@@ -2976,16 +2837,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-password-widget-view.component-rpjAeimk.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-vXdE4UjM.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-password-widget-column.component-DEHaVLGK.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
                     options: {
                         allowResizing: true,
                     },
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-password-widget-edit.component-BCOoHtGl.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-password-widget-edit.component-DrYyu5v-.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -2999,19 +2860,19 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-file-widget-view.component-DTl_Rehd.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-B0v2rSWI.mjs').then((c) => c.AXPFileWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-file-widget-column.component-C9AHk2UP.mjs').then((c) => c.AXPFileWidgetColumnComponent),
                     options: {
                         allowResizing: true,
                     },
                 },
                 edit: {
-                    component: () => import('./acorex-platform-common-file-widget-edit.component-DsIqehpt.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-C3uBjqF-.mjs').then((c) => c.AXPFileWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-file-widget-filter.component-Ce35mqny.mjs').then((c) => c.AXPFileWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -3025,16 +2886,16 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-lookup-widget-view.component-BtO3feA9.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-B0HQnsb8.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-Dxj_XEYV.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-CB0ehp_y.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-lookup-widget-column.component-B-cEaNjv.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
                     options: {
                         allowResizing: true,
                     },
@@ -3051,19 +2912,19 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-view.component-D-VQ4JNC.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-C1QPfHCm.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-C2JikSdw.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-column.component-CkOuYy0Z.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
                     options: {
                         allowResizing: true,
                     },
                 },
                 filter: {
-                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-DIgxHmqa.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-Dm_1-7eT.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -3077,22 +2938,22 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-view.component-Xr0ohz5L.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-12odUyzb.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-rich-text-widget-edit.component-DL5UyAqe.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
                     options: {
                         allowResizing: true,
                     },
                 },
                 column: {
-                    component: () => import('./acorex-platform-common-rich-text-widget-column.component-BHiq7hdp.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-wI9D-Ju5.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-DAqR2PUN.mjs').then((c) => c.AXPStringWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -3106,10 +2967,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-map-widget-view.component-RgV-r8q6.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-hXIZrhzg.mjs').then((c) => c.AXPMapWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-map-widget-edit.component-C3cpsXD5.mjs').then((c) => c.AXPMapWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -3123,10 +2984,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-avatar-widget-view.component-Dew3CVLm.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-vDhYokEG.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-avatar-widget-edit.component-DtC2IaE8.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -3140,13 +3001,13 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-messenger-widget-view.component-DEbnPggG.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-Blv1qL4e.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-DGWQWuzM.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
+                    component: () => import('./acorex-platform-common-messenger-widget-column.component-B2A7ZBEP.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
                     options: {
                         allowResizing: true,
                     },
@@ -3164,13 +3025,13 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-gallery-widget-view.component-CkcRvfv-.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-DHeFVg5x.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-Di446i2c.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
+                    component: () => import('./acorex-platform-common-gallery-widget-filter.component-C8tdM6PX.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
                 },
             },
             filterOptions: {
@@ -3184,10 +3045,10 @@ class AXPCommonWidgetModule {
         service.register({
             component: {
                 view: {
-                    component: () => import('./acorex-platform-common-signature-pad-widget-view.component-USd0U707.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-BimaJ4_d.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
+                    component: () => import('./acorex-platform-common-signature-pad-widget-edit.component-DmmPbw-A.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
                 },
             },
             filterOptions: {
@@ -3217,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, 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, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefinitionItemType, AXPSettingProviderService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWindowResizeAction, 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, 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