@acorex/platform 1.0.6 → 18.0.1

package/fesm2022/acorex-platform-common.mjs

@@ -1,16 +1,35 @@
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXDateTimeModule } from '@acorex/core/date-time';
 import * as i0 from '@angular/core';
-import { Injector, Injectable, ErrorHandler, NgModule, Inject, InjectionToken, inject, APP_INITIALIZER, EventEmitter, Directive, Input, Output } from '@angular/core';
+import { Injector, Injectable, ErrorHandler, Directive, Input, EventEmitter, Output, runInInjectionContext, NgModule, Optional, Inject, Component, InjectionToken, inject, ViewEncapsulation, ChangeDetectorRef, ChangeDetectionStrategy, ViewChild } from '@angular/core';
 import * as i2 from '@angular/router';
-import { RouterModule, NavigationEnd } from '@angular/router';
+import { RouterModule, NavigationEnd, Router } from '@angular/router';
 import * as i1 from '@ngrx/effects';
-import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
-import { createAction, props, Store } from '@ngrx/store';
-import { switchMap, of, BehaviorSubject, shareReplay } from 'rxjs';
-import { merge } from 'lodash-es';
-import { AXToastService } from '@acorex/components/toast';
+import { createEffect, ofType, Actions, EffectsModule } from '@ngrx/effects';
+import * as i2$3 from '@ngrx/store';
+import { createAction, props, Store, createFeature, createReducer, on, createSelector, StoreModule } from '@ngrx/store';
+import { switchMap, of, BehaviorSubject, timer, fromEvent, debounceTime, map, withLatestFrom, mergeMap, shareReplay } from 'rxjs';
+import * as i3 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i2$1 from '@acorex/components/image';
+import { AXImageModule } from '@acorex/components/image';
+import * as i1$1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i2$2 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import { AXPlatform } from '@acorex/core/platform';
+import { AXToastModule, AXToastService } from '@acorex/components/toast';
+import { merge, cloneDeep, assign, isEqual, get, set } from 'lodash-es';
+import * as i2$4 from '@acorex/components/skeleton';
+import { AXSkeletonModule } from '@acorex/components/skeleton';
+import * as i1$2 from '@angular/cdk/portal';
+import { ComponentPortal, PortalModule } from '@angular/cdk/portal';
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { AXFormatService } from '@acorex/core/format';
 import { filter } from 'rxjs/operators';
+import { AXDialogService } from '@acorex/components/dialog';
+import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowError } from '@acorex/platform/workflow';
 
 class AXPErrorHandlerRegistryService {
     constructor(injector) {
@@ -74,6 +93,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
 const AXPNavigateAction = createAction('[Navigate] Action', props());
 const AXPSignOutAction = createAction('[SignOut] Action');
 const AXPSignInAction = createAction('[SignIn] Action');
+const AXPLoadInitState = createAction('[App] Load State from Storage');
 
 class AXPCommonEffects {
     constructor(actions$, router) {
@@ -98,111 +118,381 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }] });
 
-class AXPCommonModule {
+// 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?.sm, 'sm:');
+        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)
+            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}` : '';
+        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan].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-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", 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.0.2", type: AXPGridLayoutDirective, isStandalone: true, selector: "[gridLayout]", inputs: { options: ["gridLayout", "options"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", 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 {
+    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);
+        }
+        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);
+                    }
+                });
+            }
+        }
+    }
+    updateNavigationLoadingState(state) {
+        if (state !== this.navigationLoadingStateActive) {
+            this.navigationLoadingStateActive = state;
+            this.navigationLoadingSubject.next(state);
+        }
+    }
+    get overlayLoading$() {
+        return this.overlayLoadingSubject.asObservable();
+    }
+    setOverlayLoading(value) {
+        if (value) {
+            this.overlayLoadingTaskCount++;
+            this.updateOverlayLoadingState(true);
+        }
+        else {
+            if (this.overlayLoadingTaskCount > 0) {
+                this.overlayLoadingTaskCount--;
+            }
+            if (this.overlayLoadingTaskCount === 0) {
+                // Start timer to keep loading state for minimum display time
+                timer(this.minimumDisplayTime).subscribe(() => {
+                    if (this.overlayLoadingTaskCount === 0) {
+                        this.updateOverlayLoadingState(false);
+                    }
+                });
+            }
+        }
+    }
+    updateOverlayLoadingState(state) {
+        if (state !== this.overlayLoadingStateActive) {
+            this.overlayLoadingStateActive = state;
+            this.overlayLoadingSubject.next(state);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+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();
+                }
+            });
+        };
+    }
+    ngOnInit() {
+        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.0.2", 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.0.2", 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.0.2", ngImport: i0, type: AXPStickyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axpSticky]',
+                    exportAs: 'axpSticky',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }], propDecorators: { stickyClass: [{
+                type: Input,
+                args: ['axpSticky']
+            }], stickyOffset: [{
+                type: Input,
+                args: ['stickyOffset']
+            }], isStickyChange: [{
+                type: Output
+            }], stickyParent: [{
+                type: Input
+            }], stickyTarget: [{
+                type: Input
+            }] } });
+
+class AXPComponentSlotRegistryService {
+    constructor() {
+        this.registry = new Map();
+    }
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
+        }
+    }
+    get(slotName) {
+        return this.registry.get(slotName) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AXPComponentSlotLoaderService {
+    constructor(registryService, injector) {
+        this.registryService = registryService;
+        this.injector = injector;
+    }
+    loadComponent(slotName, viewContainerRef) {
+        const configs = this.registryService.get(slotName);
+        if (configs) {
+            viewContainerRef.clear();
+            configs.forEach(async (config) => {
+                let component;
+                let options = {};
+                if (typeof config.loadComponent === 'function') {
+                    // If component is a function
+                    runInInjectionContext(this.injector, () => {
+                        component = config.loadComponent?.();
+                    });
+                }
+                else if (config.component) {
+                    // If component is a Type
+                    component = config.component;
+                }
+                //
+                if (typeof config.options === 'function') {
+                    // If options is a function
+                    runInInjectionContext(this.injector, () => {
+                        const fun = config.options;
+                        options = fun();
+                    });
+                }
+                else if (config.options) {
+                    // If options is a object
+                    options = config.options;
+                }
+                //
+                if (component != null) {
+                    const componentRef = viewContainerRef.createComponent(component);
+                    Object.assign(componentRef.instance, options);
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, deps: [{ token: AXPComponentSlotRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotRegistryService }, { type: i0.Injector }] });
+
+class AXPComponentSlotDirective {
+    constructor(dynamicLoaderService, viewContainerRef) {
+        this.dynamicLoaderService = dynamicLoaderService;
+        this.viewContainerRef = viewContainerRef;
+    }
+    ngOnInit() {
+        this.dynamicLoaderService.loadComponent(this.name, this.viewContainerRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotDirective, deps: [{ token: AXPComponentSlotLoaderService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: AXPComponentSlotDirective, selector: "axp-component-slot", inputs: { name: "name" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                }]
+        }], ctorParameters: () => [{ type: AXPComponentSlotLoaderService }, { type: i0.ViewContainerRef }], propDecorators: { name: [{
+                type: Input
+            }] } });
+
+class AXPComponentSlotModule {
     static forRoot(configs) {
         return {
-            ngModule: AXPCommonModule,
+            ngModule: AXPComponentSlotModule,
             providers: [
-                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPCommonModuleFactory',
+                    provide: 'AXPComponentSlotModuleFactory',
                     useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
                     },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
     }
     static forChild(configs) {
         return {
-            ngModule: AXPCommonModule,
+            ngModule: AXPComponentSlotModule,
             providers: [
-                ...(configs?.errorHandlers || []),
                 {
-                    provide: 'AXPCommonModuleFactory',
+                    provide: 'AXPComponentSlotModuleFactory',
                     useFactory: (registry) => () => {
-                        registry.register(...(configs?.errorHandlers || []));
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
                     },
-                    deps: [AXPErrorHandlerRegistryService],
-                    multi: true,
-                },
-            ],
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
         };
     }
     /**
      * @ignore
      */
     constructor(instances) {
-        instances.forEach((f) => {
+        instances?.forEach(f => {
             f();
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, imports: [i1.EffectsFeatureModule, AXPopupModule, AXDateTimeModule], exports: [RouterModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, providers: [
-            {
-                provide: ErrorHandler,
-                useClass: AXPGlobalErrorHandler,
-            },
-            // {
-            //   provide: AX_VALIDATION_CONFIG,
-            //   useValue: validationConfig({
-            //     rules: {
-            //       password: {
-            //         rule: 'callback',
-            //         options: {
-            //           validate: (e: any) => {
-            //             const { value } = e;
-            //             const patterns = [/[A-Z]/, /[a-z]/, /\d/, /[!@#$%^&*(),.?":{}|<>]/];
-            //             let conditionsMet = patterns.filter((pattern) => pattern.test(value)).length;
-            //             return /.{8,}/.test(value) && conditionsMet >= 3;
-            //           },
-            //           message: 'Password must be 8+ characters with upper, lower, digit, or symbol.',
-            //           // message: AXTranslator.get('validation.messages.password'),
-            //         }
-            //       },
-            //     },
-            //   }),
-            // },
-        ], imports: [EffectsModule.forFeature([AXPCommonEffects]), AXPopupModule, AXDateTimeModule, RouterModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [EffectsModule.forFeature([AXPCommonEffects]), AXPopupModule, AXDateTimeModule],
-                    exports: [RouterModule],
-                    providers: [
-                        {
-                            provide: ErrorHandler,
-                            useClass: AXPGlobalErrorHandler,
-                        },
-                        // {
-                        //   provide: AX_VALIDATION_CONFIG,
-                        //   useValue: validationConfig({
-                        //     rules: {
-                        //       password: {
-                        //         rule: 'callback',
-                        //         options: {
-                        //           validate: (e: any) => {
-                        //             const { value } = e;
-                        //             const patterns = [/[A-Z]/, /[a-z]/, /\d/, /[!@#$%^&*(),.?":{}|<>]/];
-                        //             let conditionsMet = patterns.filter((pattern) => pattern.test(value)).length;
-                        //             return /.{8,}/.test(value) && conditionsMet >= 3;
-                        //           },
-                        //           message: 'Password must be 8+ characters with upper, lower, digit, or symbol.',
-                        //           // message: AXTranslator.get('validation.messages.password'),
-                        //         }
-                        //       },
-                        //     },
-                        //   }),
-                        // },
-                    ],
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
                     type: Inject,
-                    args: ['AXPCommonModuleFactory']
+                    args: ['AXPComponentSlotModuleFactory']
                 }] }] });
 
 class AXPTextLogoConfig {
@@ -226,31 +516,34 @@ class AXPComponentLogoConfig {
     }
 }
 
-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,
+class AXPLogoComponent {
+    ngOnInit() {
+        switch (true) {
+            case this.source instanceof AXPTextLogoConfig:
+                this.logoType = 'text';
+                break;
+            case this.source instanceof AXPImageUrlLogoConfig:
+                this.logoType = 'url';
+                break;
+            case this.source instanceof AXPFontIconLogoConfig:
+                this.logoType = 'iconClass';
+                break;
+            case this.source instanceof AXPComponentLogoConfig:
+                this.logoType = 'component';
+                break;
+            default:
+                break;
+        }
     }
-};
-function configPlatform(config = AXPPlatformDefaultConfigs) {
-    return merge(AXPPlatformDefaultConfigs, config);
-}
-
-class AXPDataProvider {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLogoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPLogoComponent, isStandalone: true, selector: "axp-logo", inputs: { source: "source" }, host: { classAttribute: "ax-flex ax-justify-center" }, ngImport: i0, template: "@switch (logoType) {\r\n@case ('text') {\r\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\r\n}\r\n@case ('url') {\r\n<ax-image [src]=\"source.url\"></ax-image>\r\n} @case ('iconClass') {\r\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\r\n} @case ('component') {\r\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\r\n}\r\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: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLogoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-logo', standalone: true, imports: [CommonModule, AXImageModule, AXDecoratorModule], host: { 'class': 'ax-flex ax-justify-center' }, template: "@switch (logoType) {\r\n@case ('text') {\r\n<span class=\"ax-font-bold ax-select-none\">{{ source.text }}</span>\r\n}\r\n@case ('url') {\r\n<ax-image [src]=\"source.url\"></ax-image>\r\n} @case ('iconClass') {\r\n<ax-icon class=\"{{ source.classIcon }}\"></ax-icon>\r\n} @case ('component') {\r\n<ng-container *ngComponentOutlet=\"source.component\"></ng-container>\r\n}\r\n}" }]
+        }], propDecorators: { source: [{
+                type: Input
+            }] } });
 
 const AXP_MENU_LOADER = new InjectionToken('AXP_MENU_LOADER', {
     providedIn: 'root',
@@ -289,98 +582,1558 @@ class AXMenuLoaderDefault {
     }
 }
 
-const AXP_SETTINGS_LOADER = new InjectionToken('AXP_SETTINGS_LOADER', {
-    providedIn: 'root',
-    factory: () => {
-        return new AXPSettingsDefaultLoader();
-    }
-});
-class AXPSettingsDefaultLoader {
-    global$() {
-        return of([]);
-    }
-    user$() {
-        return of([]);
-    }
+class AXPFooterTextSlotComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPFooterTextSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPFooterTextSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: `
+      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+    `, isInline: true }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPFooterTextSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+      <small class="ax-text-sm  ax-text-neutral-400" [innerHTML]="text"></small>
+    `,
+                    standalone: true
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
 
-class AXPSettingsService {
+class AXPNavBarSlotComponent {
     constructor() {
-        this.settingsLoader = inject(AXP_SETTINGS_LOADER);
-        this.settingsSubject = new BehaviorSubject([]);
-        this.settings$ = this.settingsSubject.asObservable().pipe(shareReplay(1));
+        this.store = inject(Store);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
+    handleCommand(action) {
+        if (action)
+            this.store.dispatch(action);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPNavBarSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPNavBarSlotComponent, isStandalone: true, selector: "ng-component", inputs: { items: "items" }, ngImport: i0, template: `
+    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, decorators: [{
-            type: Injectable,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPNavBarSlotComponent, decorators: [{
+            type: Component,
             args: [{
-                    providedIn: 'root',
+                    template: `
+    <div class="ax-flex ax-items-center ax-justify-between ax-gap-5">
+        <a *ngFor="let link of items" (click)="handleCommand(link.command)" >{{ link.text }}</a>
+    </div>
+    `,
+                    standalone: true,
+                    imports: [CommonModule],
+                    encapsulation: ViewEncapsulation.None
                 }]
-        }] });
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
 
-const INIT_ACTION = '@ngrx/store/init';
-const UPDATE_ACTION = '@ngrx/store/update-reducers';
-const RECUMPUTE_ACTION = '@ngrx/store-devtools/recompute';
-const INIT_EFFECTS_ACTION = '@ngrx/effects/init';
-function syncStateReducer(reducer) {
-    return (state, action) => {
-        let nextState;
-        if (action.type == INIT_EFFECTS_ACTION) {
-            //TODO: replace with storage library
-            const savedState = localStorage.getItem('appState');
-            if (savedState) {
-                const initialState = JSON.parse(savedState);
-                nextState = reducer(initialState, action);
-            }
-            else {
-                nextState = reducer(nextState, action);
-            }
-        }
-        else {
-            nextState = reducer(state, action);
+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 AXPLayoutThemeDarkToggleAction = createAction('[Theme] Toggle Dark');
+const AXPLoadingShowAction = createAction('[Theme] Loading Show');
+const AXPLoadingHideAction = createAction('[Theme] Loading Hide');
+
+const platform$1 = new AXPlatform();
+const initialState = {
+    theme: {
+        dark: false,
+    },
+    screen: {
+        small: platform$1.is('SM') || platform$1.is('MD'),
+    },
+    drawer: {
+        root: !(platform$1.is('SM') || platform$1.is('MD')),
+        child: !(platform$1.is('SM') || platform$1.is('MD'))
+    },
+    loading: false
+};
+
+const platform = new AXPlatform();
+const AXPLayoutFeature = createFeature({
+    name: 'layout',
+    reducer: createReducer(initialState, 
+    // close drawers on navigatin
+    on(AXPNavigateAction, (state, action) => ({
+        ...state,
+        drawer: { ...state.drawer, root: platform.is('SM') ? false : state.drawer.root, child: platform.is('SM') ? false : state.drawer.child },
+    })), 
+    // toggle root drawers 
+    on(AXPLayoutRootDrawerToggle, (state, action) => ({
+        ...state,
+        drawer: { ...state.drawer, root: !state.drawer.root, child: (!state.drawer.root && platform.is('SM')) ? false : state.drawer.child },
+    })), 
+    // close root drawers 
+    on(AXPLayoutRootDrawerClose, (state) => ({
+        ...state,
+        drawer: { ...state.drawer, root: false },
+    })), 
+    // toggle second level child drawers 
+    on(AXPLayoutChildDrawerToggle, (state) => ({
+        ...state,
+        drawer: { ...state.drawer, child: !state.drawer.child },
+    })), 
+    // close second level child drawers 
+    on(AXPLayoutChildDrawerClose, (state) => ({
+        ...state,
+        drawer: { ...state.drawer, child: false },
+    })), 
+    // close drawers on window resize event 
+    on(AXPWindowResizeAction, (state) => ({
+        ...state,
+        screen: { small: platform.is('SM') || platform.is('MD') },
+        drawer: {
+            ...state.drawer,
+            root: platform.is('SM') || platform.is('MD') ? false : state.drawer.root,
+            child: platform.is('SM') || platform.is('MD') ? false : state.drawer.child
+        },
+    })), 
+    // toggle dark mode of theme 
+    on(AXPLayoutThemeDarkToggleAction, (state) => ({
+        ...state,
+        theme: { dark: !state.theme?.dark },
+    })), 
+    // 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 isDarkTheme = () => createSelector(selectLayoutState, (value) => value.theme.dark);
+const isLoading = () => createSelector(selectLayoutState, (value) => value.loading);
+
+class AXPLayoutEffects {
+    constructor() {
+        this.platform = inject(AXPlatform);
+        this.actions$ = inject(Actions);
+        this.store$ = inject(Store);
+        this.resize$ = createEffect(() => fromEvent(window, 'resize').pipe(debounceTime(300), map(() => AXPWindowResizeAction())));
+        this.switchDark$ = createEffect(() => this.actions$.pipe(ofType(AXPLayoutThemeDarkToggleAction, AXPLoadInitState), withLatestFrom(this.store$.select(isDarkTheme())), mergeMap(([action, dark]) => {
+            //TODO: replace with platform function;
+            const html = document.getElementsByTagName('html')[0];
+            dark ? html.classList.add('ax-dark') : html.classList.remove('ax-dark');
+            return of();
+        })), { dispatch: false });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutEffects, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutEffects }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPLayoutEffects, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPThemeSlotComponent {
+    constructor() {
+        this.store = inject((Store));
+        this.isDark = this.store.select(isDarkTheme());
+    }
+    switchMode() {
+        this.store.dispatch(AXPLayoutThemeDarkToggleAction());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPThemeSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: AXPThemeSlotComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: `
+        <ax-button color="default" look="blank" (onClick)="switchMode()">
+        <ax-icon>
+            <i class="fa-solid fa-brightness ax-text-slate-400 dark:ax-text-slate-200" *ngIf="isDark | async"></i>
+            <i class="fa-solid fa-moon ax-text-slate-400 dark:ax-text-slate-200" *ngIf="!(isDark | async)"></i>
+        </ax-icon>
+        </ax-button>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2$2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "type"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPThemeSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <ax-button color="default" look="blank" (onClick)="switchMode()">
+        <ax-icon>
+            <i class="fa-solid fa-brightness ax-text-slate-400 dark:ax-text-slate-200" *ngIf="isDark | async"></i>
+            <i class="fa-solid fa-moon ax-text-slate-400 dark:ax-text-slate-200" *ngIf="!(isDark | async)"></i>
+        </ax-icon>
+        </ax-button>
+    `,
+                    standalone: true,
+                    imports: [
+                        CommonModule,
+                        AXButtonModule,
+                        AXDecoratorModule
+                    ]
+                }]
+        }] });
+
+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) {
+        instances.forEach((f) => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, imports: [i1.EffectsFeatureModule, i2$3.StoreFeatureModule, AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, providers: [
+            {
+                provide: ErrorHandler,
+                useClass: AXPGlobalErrorHandler,
+            },
+        ], imports: [EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),
+            StoreModule.forFeature(AXPLayoutFeature),
+            AXPopupModule,
+            AXDateTimeModule,
+            AXToastModule, RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),
+                        StoreModule.forFeature(AXPLayoutFeature),
+                        AXPopupModule,
+                        AXDateTimeModule,
+                        AXToastModule
+                    ],
+                    exports: [RouterModule],
+                    providers: [
+                        {
+                            provide: ErrorHandler,
+                            useClass: AXPGlobalErrorHandler,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['AXPCommonModuleFactory']
+                }] }] });
+
+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 AXPDataProvider {
+}
+
+class AXPSchemaRegistryService {
+    constructor() {
+        this.types = new Map();
+    }
+    register(schema) {
+        this.types.set(schema.name, schema);
+    }
+    extend(parentName, schema) {
+        const parentSchema = this.resolve(parentName);
+        const newSchema = merge({}, parentSchema, schema);
+        newSchema.name = schema.name;
+        this.register(newSchema);
+    }
+    resolve(name) {
+        const schema = this.types.get(name);
+        if (!schema) {
+            throw new Error(`Parent schema with name ${schema} does not exist.`);
+        }
+        return schema;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const AXP_WIDGET_TOKEN = new InjectionToken('AXP_WIDGET_TOKEN');
+
+class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.mergedOptions = {};
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    get renderFooterTemplate() {
+        return this.footerTemplate ?? this._contentFooterTemplate;
+    }
+    get renderCellTemplate() {
+        return this.cellTemplate ?? this._contentCellTemplate;
+    }
+    get renderHeaderTemplate() {
+        return this.headerTemplate ?? this._contentHeaderTemplate;
+    }
+    get loadingEnabled() {
+        return true;
+    }
+    get name() {
+        return `col-${this.dataField}`;
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+    }
+    async ngOnInit() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        if (schema?.component?.column)
+            this.component = await schema?.component?.column.component();
+        this.mergedOptions = merge(cloneDeep(schema?.component.column?.options), this.options) || {};
+        const tokenValue = {
+            prop: {
+                name: this.dataField,
+                formats: { default: this.displayFormat },
+            },
+            schema: schema,
+        };
+        this.widgetInjector = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        this.width = this.mergedOptions.width ?? '200px';
+        this.allowResizing = this.mergedOptions.allowResizing || false;
+        this.cdr.markForCheck();
+    }
+    getInputs(data) {
+        return assign(this.mergedOptions, { context: data });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: { width: "width", caption: "caption", headerTemplate: "headerTemplate", allowSorting: "allowSorting", fixed: "fixed", footerTemplate: "footerTemplate", cellTemplate: "cellTemplate", options: "options", dataField: "dataField", displayFormat: "displayFormat", schemaName: ["schema", "schemaName"] }, providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }], viewQueries: [{ propertyName: "_contentFooterTemplate", first: true, predicate: ["footer"], descendants: true }, { propertyName: "_contentCellTemplate", first: true, predicate: ["cell"], descendants: true }, { propertyName: "_contentHeaderTemplate", first: true, predicate: ["header"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template #header>{{ caption }}</ng-template>
+    <ng-template #cell let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
+      }
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `, 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.0.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-column-renderer',
+                    template: `
+    <ng-template #header>{{ caption }}</ng-template>
+    <ng-template #cell let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"></ng-container>
+      }
+    </ng-template>
+    <ng-template #footer></ng-template>
+  `,
+                    providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['width', 'caption', 'headerTemplate', 'allowSorting', 'fixed'],
+                }]
+        }], propDecorators: { footerTemplate: [{
+                type: Input
+            }], _contentFooterTemplate: [{
+                type: ViewChild,
+                args: ['footer']
+            }], cellTemplate: [{
+                type: Input
+            }], _contentCellTemplate: [{
+                type: ViewChild,
+                args: ['cell']
+            }], headerTemplate: [{
+                type: Input
+            }], _contentHeaderTemplate: [{
+                type: ViewChild,
+                args: ['header']
+            }], options: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], displayFormat: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+
+class AXPWidgetFilterRendererComponent {
+    constructor() {
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.isLoading = true;
+        this.valueChange = new EventEmitter();
+        this.operatorChange = new EventEmitter();
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+        this.options = {};
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.updateValue();
+        this.valueChange.emit(v);
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(op) {
+        this._operator = op;
+        this.updateOperator();
+        this.operatorChange.emit(op);
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+        setTimeout(async () => {
+            await this.render();
+        });
+    }
+    async render() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        this.options =
+            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.filter?.options), schema?.component?.filter?.options) || {};
+        const tokenValue = {
+            prop: this.prop,
+            schema: schema,
+        };
+        const token = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        if (schema?.component && schema.component.filter?.component) {
+            var com = await schema.component.filter?.component();
+            this.portal = new ComponentPortal(com, null, token);
+            this.isLoading = false;
+            this.cdr.markForCheck();
+        }
+    }
+    updateValue() {
+        if (this.instance) {
+            this.instance.value = this.value;
+        }
+    }
+    updateOperator() {
+        if (this.instance) {
+            this.instance.operator = this.operator;
+        }
+    }
+    handleAttached(portalOutletRef) {
+        portalOutletRef = portalOutletRef;
+        this.instance = portalOutletRef.instance;
+        // console.log(this.schemaName, this.instance);
+        assign(this.instance, this.options);
+        this.updateValue();
+        this.updateOperator();
+        this.instance.valueChange.subscribe((v) => {
+            if (!isEqual(v, this.value)) {
+                this.value = v;
+            }
+        });
+        this.instance.operatorChange.subscribe((op) => {
+            if (!isEqual(op, this.operator)) {
+                this.operator = op;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetFilterRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPWidgetFilterRendererComponent, selector: "axp-widget-filter-renderer", inputs: { value: "value", operator: "operator", prop: "prop", schemaName: ["schema", "schemaName"] }, outputs: { valueChange: "valueChange", operatorChange: "operatorChange" }, host: { styleAttribute: "display: contents;" }, ngImport: i0, template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$4.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetFilterRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-filter-renderer',
+                    template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents;' },
+                }]
+        }], propDecorators: { valueChange: [{
+                type: Output
+            }], operatorChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], operator: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+
+class AXPWidgetBase {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.token = inject(AXP_WIDGET_TOKEN);
+        this.formatService = inject(AXFormatService);
+        this.markForCheck = inject(ChangeDetectorRef).markForCheck;
+    }
+    get schema() {
+        return this.token.schema;
+    }
+    get prop() {
+        return this.token.prop;
+    }
+    get rawValue() {
+        return get(this.context, this.token.prop.name);
+    }
+    //   protected get multiple(): boolean {
+    //     return this.token.prop.multiple ?? false;
+    //   }
+    get formats() {
+        return merge(cloneDeep(this.schema.formats), this.token.prop.formats);
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        this.render();
+        this.cdr.markForCheck();
+    }
+    render() { }
+    setOption(name, value) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { context: [{
+                type: Input
+            }] } });
+class AXPWidgetEditBase extends AXPWidgetBase {
+    constructor() {
+        super(...arguments);
+        this.valueChange = new EventEmitter();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.valueChange.emit(v);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    get validations() {
+        const merged = [...(this.schema.validationRules ?? []), ...(this.token.prop.validationRules ?? [])];
+        return merged;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetEditBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetEditBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetEditBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+class AXPWidgetFilterBase extends AXPWidgetBase {
+    constructor() {
+        super(...arguments);
+        this.operatorChange = new EventEmitter();
+        this.valueChange = new EventEmitter();
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(op) {
+        this._operator = op;
+        this.operatorChange.emit(op);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.valueChange.emit(v);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetFilterBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetFilterBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetFilterBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { operatorChange: [{
+                type: Output
+            }], operator: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+
+class AXPWidgetRendererComponent {
+    constructor() {
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.subscriber = inject(AXUnsubscriber);
+        this.mode = 'view';
+        this.isLoading = true;
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+        this.options = {};
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        if (this.instance) {
+            this.instance.context = v;
         }
-        if (![INIT_ACTION, UPDATE_ACTION, RECUMPUTE_ACTION, INIT_EFFECTS_ACTION].includes(action.type) &&
-            Object.keys(state).length > 0) {
-            localStorage.setItem('appState', JSON.stringify(nextState));
+        this.updateValue();
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+        setTimeout(async () => {
+            //TODO: move to better place
+            await this.render();
+        });
+    }
+    async render() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        this.options =
+            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.[this.mode]?.options), schema?.component?.[this.mode]?.options) || {};
+        const tokenValue = {
+            prop: this.prop,
+            schema: schema,
+        };
+        const token = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        if (schema?.component && schema.component[this.mode]?.component) {
+            var com = await schema.component[this.mode]?.component();
+            this.portal = new ComponentPortal(com, null, token);
+            this.isLoading = false;
+            this.cdr.markForCheck();
+        }
+    }
+    updateValue() {
+        if (this.instance && this.context && this.instance instanceof AXPWidgetEditBase) {
+            this.instance.value = get(this.context, this.prop.name);
         }
-        return nextState;
+    }
+    updateProps() {
+        if (this.instance) {
+            assign(this.instance, this.options);
+        }
+    }
+    handleAttached(portalOutletRef) {
+        portalOutletRef = portalOutletRef;
+        this.instance = portalOutletRef.instance;
+        this.instance.context = this.context;
+        this.updateProps();
+        this.updateValue();
+        if (this.instance instanceof AXPWidgetEditBase) {
+            this.instance.valueChange.pipe(this.subscriber.takeUntilDestroy).subscribe((v) => {
+                set(this.context, this.prop.name, v);
+                if (this.options['reference']) {
+                    const valueField = this.prop.component?.common?.options?.valueField || 'id';
+                    const referenceField = this.options['referenceField'];
+                    if (referenceField) {
+                        if (Array.isArray(v)) {
+                            this.context[referenceField] = v.map((item) => item[valueField]);
+                        }
+                        else {
+                            this.context[referenceField] = v?.[valueField];
+                        }
+                    }
+                    else {
+                        this.context[`${this.prop.name}Id`] = v[valueField];
+                    }
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPWidgetRendererComponent, selector: "axp-widget-renderer", inputs: { context: "context", prop: "prop", mode: "mode", schemaName: ["schema", "schemaName"] }, host: { styleAttribute: "display: contents;" }, providers: [
+            {
+                provide: AXUnsubscriber,
+            },
+        ], ngImport: i0, template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$2.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2$4.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWidgetRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-renderer',
+                    template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents;' },
+                    providers: [
+                        {
+                            provide: AXUnsubscriber,
+                        },
+                    ],
+                }]
+        }], propDecorators: { context: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+
+class AXPSchemaModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaModule, declarations: [AXPWidgetRendererComponent, AXPWidgetColumnRendererComponent, AXPWidgetFilterRendererComponent], imports: [PortalModule, AXSkeletonModule, CommonModule], exports: [AXPWidgetRendererComponent, AXPWidgetFilterRendererComponent, AXPWidgetColumnRendererComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaModule, imports: [PortalModule, AXSkeletonModule, CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSchemaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [PortalModule, AXSkeletonModule, CommonModule],
+                    exports: [AXPWidgetRendererComponent, AXPWidgetFilterRendererComponent, AXPWidgetColumnRendererComponent],
+                    declarations: [AXPWidgetRendererComponent, AXPWidgetColumnRendererComponent, AXPWidgetFilterRendererComponent],
+                    providers: [],
+                }]
+        }] });
+
+const AXPEntityListViewConfigEmpty = {
+    fixed: false,
+    columns: [],
+    conditions: [],
+    sorts: [],
+    name: 'empty',
+    title: 'Empty',
+};
+function convertPropertyToColumn(property) {
+    return {
+        //TODO: merge format function
+        schema: property.schema,
+        name: property.name,
+        title: property.title,
+        visible: true,
+        displayFormat: property.formats?.list ?? property.formats?.default,
+        sortOptions: {
+            enabled: property.canSort,
+            property: property.name,
+        },
+        filterOptions: {
+            enabled: property.canFilter,
+            property: property.name,
+        },
+        options: merge(cloneDeep(property.component?.common?.options), property.component?.column?.options),
     };
 }
-const metaReducers = [syncStateReducer];
-
-const AXPLoadInitState = createAction('[App] Load State from Storage');
+function convertPropertiesToColumns(...propertis) {
+    return propertis.map((p) => convertPropertyToColumn(p));
+}
+
+class AXEntityLoaderDefault {
+    async get(moduleName, entityName) {
+        return null;
+    }
+}
+const AXP_ENTITY_LOADER = new InjectionToken('AXP_ENTITY_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXEntityLoaderDefault();
+    },
+});
+
+class AXPEntityRegistryService {
+    constructor() {
+        // Stores AXPEntityConfig objects, keyed by a combination of module and entity name.
+        this.entities = new Map();
+        // Entity loader service for dynamically loading entity configurations.
+        this.loader = inject(AXP_ENTITY_LOADER); // Assuming AXPEntityLoader is the correct type
+    }
+    /**
+     * Registers a new entity configuration. Entities are identified uniquely by a combination
+     * of their module and name.
+     *
+     * @param config The configuration object of the entity to be registered.
+     */
+    register(config) {
+        const key = this.createEntityKey(config.module, config.name);
+        this.entities.set(key, config);
+    }
+    /**
+     * Resolves an entity configuration based on module and entity name. If the configuration
+     * is not already registered, attempts to load it dynamically. Throws an error if the
+     * entity cannot be found or loaded.
+     *
+     * @param moduleName The module name of the entity.
+     * @param entityName The name of the entity.
+     * @returns A promise resolving to the entity configuration.
+     * @throws Error if the entity configuration cannot be resolved.
+     */
+    async resolve(moduleName, entityName) {
+        const key = this.createEntityKey(moduleName, entityName);
+        let config = this.entities.get(key) ?? null;
+        if (!config) {
+            try {
+                config = await this.loader.get(moduleName, entityName);
+                if (config) {
+                    this.register(config);
+                }
+            }
+            catch (error) {
+                console.error(`Error loading entity '${key}':`, error);
+                throw error; // Rethrow to allow error handling by caller
+            }
+            if (!config) {
+                throw new Error(`Invalid Entity name: ${key}`);
+            }
+        }
+        return config;
+    }
+    /**
+     * Creates a unique key for an entity based on its module and name.
+     *
+     * @param moduleName The module name of the entity.
+     * @param entityName The name of the entity.
+     * @returns The unique key for the entity.
+     */
+    createEntityKey(moduleName, entityName) {
+        return `${moduleName}.${entityName}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPEntityRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var AXPRelationshipKind;
+(function (AXPRelationshipKind) {
+    AXPRelationshipKind[AXPRelationshipKind["Association"] = 0] = "Association";
+    AXPRelationshipKind[AXPRelationshipKind["Composition"] = 1] = "Composition";
+    AXPRelationshipKind[AXPRelationshipKind["Aggregation"] = 2] = "Aggregation";
+})(AXPRelationshipKind || (AXPRelationshipKind = {}));
+var AXPRelationshipCardinality;
+(function (AXPRelationshipCardinality) {
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToOne"] = 0] = "OneToOne";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["OneToMany"] = 1] = "OneToMany";
+    AXPRelationshipCardinality[AXPRelationshipCardinality["ManyToMany"] = 2] = "ManyToMany";
+})(AXPRelationshipCardinality || (AXPRelationshipCardinality = {}));
+var AXPEntityCommandScope;
+(function (AXPEntityCommandScope) {
+    AXPEntityCommandScope["TypeLevel"] = "typeLevel";
+    AXPEntityCommandScope["Selected"] = "selected";
+    AXPEntityCommandScope["Individual"] = "individual";
+    AXPEntityCommandScope["Section"] = "section";
+})(AXPEntityCommandScope || (AXPEntityCommandScope = {}));
+var AXPEntityQueryType;
+(function (AXPEntityQueryType) {
+    AXPEntityQueryType["Single"] = "single";
+    AXPEntityQueryType["List"] = "list";
+})(AXPEntityQueryType || (AXPEntityQueryType = {}));
+function resolveActionLook(tr) {
+    switch (tr.type) {
+        case 'create':
+            return { color: 'primary', icon: 'fa-solid fa-add' };
+        case 'delete':
+            return { color: 'danger', icon: 'fa-solid fa-trash' };
+        case 'print':
+            return { color: 'secondary', icon: 'fa-solid fa-print' };
+        case 'confirm':
+            return { color: 'success', icon: 'fa-solid fa-check' };
+        default:
+            return { color: 'primary', icon: '' };
+    }
+}
+
+const EQ_OPER = { name: 'equal', title: 'Equal', hasValue: true };
+const NOT_EQ_OPER = { name: 'notEqual', title: 'Not Equal', hasValue: true };
+const GT_OPER = { name: 'greaterThan', title: 'Greater Than', hasValue: true };
+const LT_OPER = { name: 'lessThan', title: 'Less Than', hasValue: true };
+const GTE_OPER = {
+    name: 'greaterThanOrEqual',
+    title: 'Greater Than or Equal',
+    hasValue: true,
+};
+const LTE_OPER = { name: 'lessThanOrEqual', title: 'Less Than or Equal', hasValue: true };
+const CONTAINS_OPER = { name: 'contains', title: 'Contains', hasValue: true };
+const NOT_CONTAINS_OPER = { name: 'notContains', title: 'Does Not Contain', hasValue: true };
+const STARTS_WITH_OPER = { name: 'startsWith', title: 'Starts With', hasValue: true };
+const ENDS_WITH_OPER = { name: 'endsWith', title: 'Ends With', hasValue: true };
+const IS_EMPTY_OPER = { name: 'isEmpty', title: 'Is Empty', hasValue: false };
+const IS_NOT_EMPTY_OPER = { name: 'isNotEmpty', title: 'Is Not Empty', hasValue: false };
+const BETWEEN_OPER = { name: 'between', title: 'Between', hasValue: true };
+const STRING_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    CONTAINS_OPER,
+    NOT_CONTAINS_OPER,
+    STARTS_WITH_OPER,
+    ENDS_WITH_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+];
+const NUMBER_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    BETWEEN_OPER,
+    GT_OPER,
+    GTE_OPER,
+    LT_OPER,
+    LTE_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+];
+const BOOLEAN_OPERATORS = [EQ_OPER];
+const DATE_OPERATORS = [
+    EQ_OPER,
+    NOT_EQ_OPER,
+    GT_OPER,
+    GTE_OPER,
+    LT_OPER,
+    LTE_OPER,
+    IS_EMPTY_OPER,
+    IS_NOT_EMPTY_OPER,
+];
+
+const widgetSchemas = {
+    //*Sharing schema list with other modules
+    text: 'text',
+    largetext: 'largetext',
+    number: 'number',
+    currency: 'currency',
+    phone: 'phone',
+    email: 'email',
+    dateTime: 'dateTime',
+    date: 'date',
+    time: 'time',
+    toggle: 'toggle',
+    checkbox: 'checkbox',
+    password: 'password',
+    file: 'file',
+    lookup: 'lookup',
+    selectionList: 'selection-list',
+    richText: 'rich-text',
+    map: 'map',
+    avatar: 'avatar',
+    messenger: 'messenger',
+    gallery: 'gallery',
+    signaturePad: 'signature-pad',
+};
+class AXPCommonWidgetModule {
+    constructor(service) {
+        //text
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-text-widget-view.component-WbZtm_bf.mjs').then((c) => c.AXPTextWidgetViewComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-Di_GFHme.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-text-widget-edit.component-K9z9N1qw.mjs').then((c) => c.AXPTextWidgetEditComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-text-widget-column.component-BSYd1CbC.mjs').then((c) => c.AXPTextWidgetColumnComponent),
+                    options: { allowResizing: true },
+                },
+            },
+            filterOptions: {
+                operators: [...STRING_OPERATORS],
+                default: CONTAINS_OPER,
+            },
+            name: widgetSchemas.text,
+            dataType: 'string',
+        });
+        service.extend('text', {
+            name: widgetSchemas.largetext,
+            component: {
+                edit: {
+                    component: () => import('./acorex-platform-common-largetext-widget-edit.component-DFKG-kum.mjs').then((c) => c.AXPLargeTextWidgetEditComponent),
+                },
+                column: {
+                    options: {
+                        width: '400px',
+                    },
+                },
+            },
+        });
+        //
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-number-widget-view.component-BzUWjT8m.mjs').then((c) => c.AXPNumberWidgetViewComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-number-widget-filter.component-jQ4DaFQH.mjs').then((c) => c.AXPNumberWidgetFilterComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-number-widget-edit.component-BRuIP96Y.mjs').then((c) => c.AXPNumberWidgetEditComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-number-widget-view.component-BzUWjT8m.mjs').then((c) => c.AXPNumberWidgetViewComponent),
+                    options: { allowResizing: true },
+                },
+            },
+            name: widgetSchemas.number,
+            filterOptions: {
+                operators: [...NUMBER_OPERATORS],
+                default: BETWEEN_OPER,
+            },
+            dataType: 'number',
+        });
+        service.extend('number', {
+            name: widgetSchemas.currency,
+            formats: {
+                default: 'EN-GB',
+            },
+            component: {
+                edit: {
+                    options: {
+                        clearButton: false,
+                    },
+                },
+            },
+        });
+        //phone
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-phone-widget-view.component-CFiMsGOB.mjs').then((c) => c.AXPPhoneWidgetViewComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-phone-widget-column.component-BD7BScjW.mjs').then((c) => c.AXPPhoneWidgetColumnComponent),
+                    options: { allowResizing: true },
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-phone-widget-edit.component-D8tGKfNj.mjs').then((c) => c.AXPPhoneWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-Di_GFHme.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                },
+            },
+            name: widgetSchemas.phone,
+            filterOptions: {
+                operators: [...STRING_OPERATORS],
+                default: CONTAINS_OPER,
+            },
+            dataType: 'object',
+        });
+        //email
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-email-widget-view.component-B6puyycL.mjs').then((c) => c.AXPEmailWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-email-widget-edit.component-DWT24mCM.mjs').then((c) => c.AXPEmailWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-Di_GFHme.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-email-widget-column.component-D_UNn2dW.mjs').then((c) => c.AXPEmailWidgetColumnComponent),
+                    options: { allowResizing: true },
+                },
+            },
+            name: widgetSchemas.email,
+            filterOptions: {
+                operators: [...STRING_OPERATORS],
+                default: CONTAINS_OPER,
+            },
+            dataType: 'object',
+        });
+        // dateTime
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-dateTime-widget-view.component-Dy7pAkGG.mjs').then((c) => c.AXPDateTimeWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-dateTime-widget-edit.component-B0s6FN-g.mjs').then((c) => c.AXPDateTimeWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-dateTime-widget-filter.component-B7KBCsUt.mjs').then((c) => c.AXPDateTimeWidgetFilterComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-dateTime-widget-column.component-BlXTU887.mjs').then((c) => c.AXPDateTimeWidgetColumnComponent),
+                    options: {
+                        width: '200px',
+                        allowResizing: true,
+                    },
+                },
+            },
+            formats: {
+                default: 'date',
+            },
+            filterOptions: {
+                operators: [...DATE_OPERATORS],
+                default: BETWEEN_OPER,
+            },
+            name: widgetSchemas.dateTime,
+            dataType: 'date',
+        });
+        service.extend(widgetSchemas.dateTime, {
+            name: widgetSchemas.date,
+            formats: {
+                default: 'date',
+            },
+            component: {
+                column: {
+                    options: {
+                        width: '120px',
+                    },
+                },
+            },
+        });
+        service.extend(widgetSchemas.dateTime, {
+            name: widgetSchemas.time,
+            formats: {
+                default: 'time',
+            },
+            component: {
+                column: {
+                    options: {
+                        width: '80px',
+                    },
+                },
+            },
+        });
+        //toggle
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-toggle-widget-view.component-DLDIrci1.mjs').then((c) => c.AXPToggleWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-toggle-widget-edit.component-rkDfLA-J.mjs').then((c) => c.AXPToggleWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-CEqibiML.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-toggle-widget-column.component-ZCBSYMuz.mjs').then((c) => c.AXPToggleWidgetColumnComponent),
+                    options: {
+                        width: '100px',
+                        allowResizing: true
+                    },
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.toggle,
+            dataType: 'boolean',
+        });
+        //checkbox
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-checkbox-widget-view.component-CfGkMcDi.mjs').then((c) => c.AXPCheckboxWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-checkbox-widget-edit.component-BVG9_XXh.mjs').then((c) => c.AXPCheckboxWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-boolean-widget-filter.component-CEqibiML.mjs').then((c) => c.AXPBooleanWidgetFilterComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-checkbox-widget-column.component-BiUHPDqV.mjs').then((c) => c.AXPCheckboxWidgetColumnComponent),
+                    options: {
+                        width: '100px',
+                        allowResizing: true
+                    },
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.checkbox,
+            dataType: 'boolean',
+        });
+        //password
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-password-widget-view.component-CKaQItON.mjs').then((c) => c.AXPPasswordWidgetViewComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-password-widget-column.component-BRzyuK5c.mjs').then((c) => c.AXPPasswordWidgetColumnComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-password-widget-edit.component-q6R2dw5k.mjs').then((c) => c.AXPPasswordWidgetEditComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.password,
+            dataType: 'string',
+        });
+        //file
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-file-widget-view.component-CHI4VCvt.mjs').then((c) => c.AXPFileWidgetViewComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-file-widget-column.component-C1faGR4K.mjs').then((c) => c.AXPFileWidgetColumnComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-file-widget-edit.component-CTvS9ls8.mjs').then((c) => c.AXPFileWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-file-widget-filter.component-D4AMg5M0.mjs').then((c) => c.AXPFileWidgetFilterComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.file,
+            dataType: 'object',
+        });
+        // look up
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-lookup-widget-view.component-5YeixMp7.mjs').then((c) => c.AXPLookupWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-lookup-widget-edit.component-CYTSeEOq.mjs').then((c) => c.AXPLookupWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-lookup-widget-filter.component-BkxT9_Hh.mjs').then((c) => c.AXPLookupWidgetFilterComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-lookup-widget-column.component-CFzCGcqA.mjs').then((c) => c.AXPLookupWidgetColumnComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: CONTAINS_OPER,
+            },
+            name: widgetSchemas.lookup,
+            dataType: 'object',
+        });
+        // selection list
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-selection-list-widget-view.component-CjDiuUdj.mjs').then((c) => c.AXPSelectionListWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-selection-list-widget-edit.component-QKw_tyOd.mjs').then((c) => c.AXPSelectionListWidgetEditComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-selection-list-widget-column.component-_MglaOmo.mjs').then((c) => c.AXPSelectionListWidgetColumnComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-selection-list-widget-filter.component-DRToTnHQ.mjs').then((c) => c.AXPSelectionListWidgetFilterComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: CONTAINS_OPER,
+            },
+            name: widgetSchemas.selectionList,
+            dataType: 'object',
+        });
+        // rich text
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-rich-text-widget-view.component-DYfTZ64H.mjs').then((c) => c.AXPRichTextWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-rich-text-widget-edit.component-CA2xRfVg.mjs').then((c) => c.AXPRichTextWidgetEditComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-rich-text-widget-column.component-BPzwY_8L.mjs').then((c) => c.AXPRichTextWidgetColumnComponent),
+                    options: {
+                        width: '400px',
+                    },
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-string-widget-filter.component-Di_GFHme.mjs').then((c) => c.AXPStringWidgetFilterComponent),
+                },
+            },
+            filterOptions: {
+                operators: [...STRING_OPERATORS],
+                default: CONTAINS_OPER,
+            },
+            name: widgetSchemas.richText,
+            dataType: 'object',
+        });
+        // map
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-map-widget-view.component-Cv4OCTxz.mjs').then((c) => c.AXPMapWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-map-widget-edit.component-CE3QQBmX.mjs').then((c) => c.AXPMapWidgetEditComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.map,
+            dataType: 'object',
+        });
+        // avatar
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-avatar-widget-view.component-BlA_cFkP.mjs').then((c) => c.AXPAvatarWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-avatar-widget-edit.component-DAmNXjDm.mjs').then((c) => c.AXPAvatarWidgetEditComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.avatar,
+            dataType: 'object',
+        });
+        // messenger
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-messenger-widget-view.component-DzbjgZA7.mjs').then((c) => c.AXPMessengerWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-messenger-widget-edit.component-kiEHxJia.mjs').then((c) => c.AXPMessengerWidgetEditComponent),
+                },
+                column: {
+                    component: () => import('./acorex-platform-common-messenger-widget-column.component-CJdh6TKb.mjs').then((c) => c.AXPMessengerWidgetColumnComponent),
+                    options: {
+                        allowResizing: true
+                    }
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.messenger,
+            dataType: 'object',
+        });
+        //
+        // gallery
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-gallery-widget-view.component-Ci50jeO5.mjs').then((c) => c.AXPGalleryWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-gallery-widget-edit.component-CAOctYzV.mjs').then((c) => c.AXPGalleryWidgetEditComponent),
+                },
+                filter: {
+                    component: () => import('./acorex-platform-common-gallery-widget-filter.component-lgaYDZeD.mjs').then((c) => c.AXPGalleryWidgetFilterComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.gallery,
+            dataType: 'object',
+        });
+        // signature-pad
+        service.register({
+            component: {
+                view: {
+                    component: () => import('./acorex-platform-common-signature-pad-widget-view.component-BWzoR4HM.mjs').then((c) => c.AXPSignaturePadWidgetViewComponent),
+                },
+                edit: {
+                    component: () => import('./acorex-platform-common-signature-pad-widget-edit.component-DF29uWl2.mjs').then((c) => c.AXPSignaturePadWidgetEditComponent),
+                },
+            },
+            filterOptions: {
+                operators: [],
+                default: EQ_OPER,
+            },
+            name: widgetSchemas.signaturePad,
+            dataType: 'object',
+        });
+        //
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonWidgetModule, deps: [{ token: AXPSchemaRegistryService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonWidgetModule, imports: [AXToastModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonWidgetModule, imports: [AXToastModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCommonWidgetModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AXToastModule],
+                    exports: [],
+                    declarations: [],
+                    providers: [],
+                }]
+        }], ctorParameters: () => [{ type: AXPSchemaRegistryService }] });
 
-function initializeAppState(store) {
-    return () => {
-        store.dispatch(AXPLoadInitState());
-    };
+const AXP_SETTINGS_LOADER = new InjectionToken('AXP_SETTINGS_LOADER', {
+    providedIn: 'root',
+    factory: () => {
+        return new AXPSettingsDefaultLoader();
+    }
+});
+class AXPSettingsDefaultLoader {
+    global$() {
+        return of([]);
+    }
+    user$() {
+        return of([]);
+    }
 }
-class AXPStatePersistenceModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStatePersistenceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPStatePersistenceModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStatePersistenceModule, providers: [
-            {
-                provide: APP_INITIALIZER,
-                useFactory: initializeAppState,
-                deps: [Store],
-                multi: true,
-            },
-        ] }); }
+
+class AXPSettingsService {
+    constructor() {
+        this.settingsLoader = inject(AXP_SETTINGS_LOADER);
+        this.settingsSubject = new BehaviorSubject([]);
+        this.settings$ = this.settingsSubject.asObservable().pipe(shareReplay(1));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStatePersistenceModule, decorators: [{
-            type: NgModule,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPSettingsService, decorators: [{
+            type: Injectable,
             args: [{
-                    imports: [],
-                    providers: [
-                        {
-                            provide: APP_INITIALIZER,
-                            useFactory: initializeAppState,
-                            deps: [Store],
-                            multi: true,
-                        },
-                    ]
+                    providedIn: 'root',
                 }]
         }] });
 
@@ -445,81 +2198,138 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImpor
                 }]
         }], ctorParameters: () => [{ type: i2.Router }] });
 
-class AXPStickyDirective {
-    get isSticky() {
-        return this._isSticky;
+class AXPDataGenerator {
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const random = (Math.random() * 16) | 0;
+            const value = char === 'x' ? random : (random & 0x3) | 0x8;
+            return value.toString(16);
+        });
     }
-    set isSticky(v) {
-        this._isSticky = v;
-        this.isStickyChange.emit(v);
+    static number(...args) {
+        let min = 0;
+        let max = 100;
+        if (args.length == 1)
+            max = args[0];
+        if (args.length == 2) {
+            min = args[0];
+            max = args[1];
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    constructor(element, renderer, zone, cdr) {
-        this.element = element;
-        this.renderer = renderer;
-        this.zone = zone;
-        this.cdr = cdr;
-        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.topOffset && !this.isSticky) {
-                    this.stickyClass.split(' ').forEach(c => {
-                        this.renderer.addClass(this.targetElement, c);
-                    });
-                    this.isSticky = true;
-                    this.cdr.markForCheck();
-                }
-                else if (scrollPosition <= this.topOffset && this.isSticky) {
-                    this.stickyClass.split(' ').forEach(c => {
-                        this.renderer.removeClass(this.targetElement, c);
-                    });
-                    this.isSticky = false;
-                    this.cdr.markForCheck();
-                }
-            });
-        };
+    static date(start = new Date(2000, 0, 1), end = new Date()) {
+        const startTime = start.getTime();
+        const endTime = end.getTime();
+        return new Date(startTime + Math.random() * (endTime - startTime));
     }
-    ngOnInit() {
-        if (this.stickyParent instanceof HTMLElement) {
-            this.parentElement = this.stickyParent;
-        }
+    static array(length = 5, generator) {
+        return Array.from({ length }, generator);
+    }
+    static string(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static boolean() {
+        return Math.random() >= 0.5;
+    }
+    static item(array = []) {
+        return array.length > 0 ? array[Math.floor(Math.random() * array.length)] : undefined;
+    }
+    static color() {
+        const color = Math.floor(Math.random() * 16777215).toString(16);
+        return `#${color.padStart(6, '0')}`;
+    }
+    static alphanumeric(length = 10) {
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+}
+
+//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 {
-            this.parentElement = document.querySelector(this.stickyParent) || window;
+            if (payload.commands.toLowerCase().startsWith('http'))
+                window.open(payload.commands, '_blank');
+            else
+                this.router.navigate([payload.commands], payload.extras);
         }
-        this.targetElement = document.querySelector(this.stickyTarget) || this.element.nativeElement;
-        this.topOffset = this.targetElement.offsetTop;
-        this.parentElement.addEventListener('scroll', this.onParentScroll.bind(this));
     }
-    ngOnDestroy() {
-        this.parentElement.removeEventListener('scroll', this.onParentScroll);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowNavigateAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowNavigateAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowNavigateAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPDialogConfirmAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", 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.0.2", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
+    async execute(context) {
+        context.setOutput('deleteConfirmed', false);
+        const dialogResult = await this.dialogService.confirm(this.title, this.message, this.type);
+        context.setOutput('deleteConfirmed', dialogResult.result);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPDialogConfirmAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPDialogConfirmAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", 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']
-            }], isStickyChange: [{
-                type: Output
-            }], stickyParent: [{
-                type: Input
-            }], stickyTarget: [{
-                type: Input
-            }] } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPDialogConfirmAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPToastAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.toastService = inject(AXToastService);
+    }
+    async execute(context) {
+        this.toastService.show({
+            color: this.color,
+            title: this.title,
+            content: this.content,
+            closeButton: true,
+            timeOut: 3000,
+            timeOutProgress: true,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPToastAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPToastAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", 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.0.2", ngImport: i0, type: AXMWorkflowErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMWorkflowErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMWorkflowErrorHandler, decorators: [{
+            type: Injectable
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMenuLoaderDefault, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPComponentLogoConfig, AXPDataProvider, AXPErrorHandlerRegistryService, AXPFontIconLogoConfig, AXPGlobalErrorHandler, AXPImageUrlLogoConfig, AXPLoadInitState, AXPNavigateAction, AXPPlatformDefaultConfigs, AXPRouteUtilityService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStatePersistenceModule, AXPStickyDirective, AXPTextLogoConfig, AXP_MENU_LOADER, AXP_PLATFORM_CONFIG_TOKEN, AXP_SETTINGS_LOADER, configPlatform, initializeAppState, metaReducers, syncStateReducer };
+export { AXEntityLoaderDefault, AXMWorkflowErrorHandler, AXMenuLoaderDefault, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPDataGenerator, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPErrorHandlerRegistryService, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLayoutChildDrawerClose, AXPLayoutChildDrawerToggle, AXPLayoutEffects, AXPLayoutFeature, AXPLayoutRootDrawerClose, AXPLayoutRootDrawerToggle, AXPLayoutService, AXPLayoutThemeDarkToggleAction, AXPLoadInitState, AXPLoadingHideAction, AXPLoadingShowAction, AXPLogoComponent, AXPNavBarSlotComponent, AXPNavigateAction, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPRouteUtilityService, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPThemeSlotComponent, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWindowResizeAction, AXPWorkflowNavigateAction, AXP_ENTITY_LOADER, AXP_MENU_LOADER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTINGS_LOADER, AXP_WIDGET_TOKEN, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, 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, getRootDrawer, initialState, isDarkTheme, isLoading, isSmallScreen, name, reducer, resolveActionLook, selectLayoutState, widgetSchemas };
 //# sourceMappingURL=acorex-platform-common.mjs.map