@acorex/platform 19.0.1 → 19.1.0

package/fesm2022/acorex-platform-common.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { Injectable, provideAppInitializer, inject, RendererFactory2, InjectionToken, Injector, ErrorHandler, NgModule, Inject, Directive, Input, EventEmitter, Output, runInInjectionContext, Optional, Component, ViewEncapsulation, ChangeDetectorRef, ChangeDetectionStrategy, ViewChild } from '@angular/core';
-import { kebabCase, cloneDeep, merge, sortBy, assign, isEqual, get, set } from 'lodash-es';
+import { kebabCase, merge, cloneDeep, sortBy, assign, isEqual, get, set } from 'lodash-es';
 import { AXPopupModule } from '@acorex/components/popup';
 import { AXToastService, AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
@@ -763,38 +763,162 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
+class AXPSettingDefinitionProviderContext {
+    constructor() {
+        this.rootGroups = [];
+        this.groupMap = new Map();
+    }
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.rootGroups.push(newGroup);
+        this.groupMap.set(name, newGroup); // Index by name
+        return new AXPSettingDefinitionGroupBuilder(this, newGroup);
+    }
+    group(name) {
+        const foundGroup = this.groupMap.get(name);
+        if (!foundGroup) {
+            throw new Error(`Group with name "${name}" not found.`);
+        }
+        return new AXPSettingDefinitionGroupBuilder(this, foundGroup);
+    }
+    getGroups() {
+        return this.rootGroups;
+    }
+    // Expose groupMap for controlled access
+    hasGroup(name) {
+        return this.groupMap.has(name);
+    }
+    getGroup(name) {
+        return this.groupMap.get(name);
+    }
+}
+class AXPSettingDefinitionGroupBuilder {
+    constructor(context, group) {
+        this.context = context;
+        this.group = group;
+    }
+    addSection(name, title, description) {
+        const newSection = {
+            name,
+            title,
+            description: description,
+            settings: [],
+        };
+        this.group.sections.push(newSection);
+        return new AXPSettingDefinitionSectionBuilder(this, newSection);
+    }
+    section(name) {
+        const foundSection = this.group.sections.find((section) => section.name === name);
+        if (!foundSection) {
+            throw new Error(`Section with name "${name}" not found in group "${this.group.name}".`);
+        }
+        return new AXPSettingDefinitionSectionBuilder(this, foundSection);
+    }
+    addGroup(name, title, description, icon) {
+        const newGroup = {
+            name,
+            title,
+            description: description,
+            icon,
+            groups: [],
+            sections: [],
+        };
+        this.group.groups.push(newGroup);
+        if (this.context.hasGroup(name)) {
+            throw new Error(`Group with name "${name}" already exists.`);
+        }
+        this.context['groupMap'].set(name, newGroup);
+        return new AXPSettingDefinitionGroupBuilder(this.context, newGroup);
+    }
+    endGroup() {
+        return this.context;
+    }
+}
+class AXPSettingDefinitionSectionBuilder {
+    constructor(groupBuilder, section) {
+        this.groupBuilder = groupBuilder;
+        this.section = section;
+    }
+    addSetting(setting) {
+        const newSetting = {
+            name: setting.key,
+            title: setting.title,
+            description: setting.description,
+            isRequired: setting.isRequired ?? false,
+            isInherited: setting.isInherited ?? false,
+            isEncrypted: setting.isEncrypted ?? false,
+            defaultValue: setting.defaultValue,
+            scope: setting.scope ?? 'G',
+            widget: {
+                type: setting.widget.type,
+                name: setting.key,
+                path: setting.key,
+                defaultValue: setting.defaultValue,
+                options: merge(setting.widget.options ?? {}, { label: setting.widget.options?.['label'] ?? setting.title }),
+                valueTransforms: setting.valueTransforms,
+            },
+        };
+        this.section.settings.push(newSetting);
+        return this;
+    }
+    endSection() {
+        return this.groupBuilder;
+    }
+}
+
 // Injection token for setting providers
-const AXP_SETTING_PROVIDER = new InjectionToken('AXP_SETTING_PROVIDER');
+const AXP_SETTING_DEFINITION_PROVIDER = new InjectionToken('AXP_SETTING_DEFINITION_PROVIDER');
 class AXPSettingDefinitionProviderService {
     constructor() {
-        this.providers = inject(AXP_SETTING_PROVIDER, { optional: true });
+        this.providers = inject(AXP_SETTING_DEFINITION_PROVIDER, { optional: true });
         this.cache = null;
-        this.pendingInserts = [];
-        this.pendingAdditions = [];
     }
-    // Retrieve all setting items, applying any pending operations
     async items() {
         if (this.cache) {
             return this.cache;
         }
-        const items = [];
-        const context = this.createProviderContext(items);
+        const context = new AXPSettingDefinitionProviderContext();
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
-                provider.provide(context);
+                await provider.provide(context);
             }
         }
-        // this.applyPendingOperations(items);
-        this.cache = items;
-        return items;
+        this.cache = context.getGroups();
+        return this.cache;
+    }
+    defaultValues(scope) {
+        const defaults = {};
+        const collectDefaults = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        if (setting.defaultValue !== undefined && (!scope || setting.scope === scope)) {
+                            defaults[setting.name] = setting.defaultValue;
+                        }
+                    });
+                });
+                collectDefaults(group.groups);
+            });
+        };
+        if (this.cache) {
+            collectDefaults(this.cache);
+        }
+        return defaults;
     }
-    findGroupDetails(groupName) {
+    findGroup(groupName) {
         if (this.cache) {
-            return this.searchGroupDetails(this.cache, groupName, []); // Initialize with an empty breadcrumb
+            return this.searchRecursive(this.cache, groupName, []); // Initialize with an empty breadcrumb
         }
         return null;
     }
-    searchGroupDetails(groups, groupName, breadcrumb) {
+    searchRecursive(groups, groupName, breadcrumb) {
         for (const group of groups) {
             const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title }];
             // If the group name matches, return its details
@@ -802,11 +926,11 @@ class AXPSettingDefinitionProviderService {
                 return {
                     breadcrumb: currentBreadcrumb,
                     sections: group.sections.length > 0 ? group.sections : null,
-                    childGroups: group.groups.length > 0 ? group.groups : null,
+                    groups: group.groups.length > 0 ? group.groups : null,
                 };
             }
             // Recursively search in nested groups
-            const nestedResult = this.searchGroupDetails(group.groups, groupName, currentBreadcrumb);
+            const nestedResult = this.searchRecursive(group.groups, groupName, currentBreadcrumb);
             if (nestedResult) {
                 return nestedResult;
             }
@@ -814,128 +938,6 @@ class AXPSettingDefinitionProviderService {
         // If no matching group is found
         return null;
     }
-    // Create the provider context with methods to add items and find existing ones
-    createProviderContext(items) {
-        return {
-            addItems: (newItems) => {
-                items.push(...newItems);
-            },
-            addItem: (item) => {
-                items.push(item);
-            },
-            addGroup: (group) => {
-                items.push(group);
-            },
-            // find: (target: string): AXPSettingDefinitionFinderResult => {
-            //   return {
-            //     insertGroup: (item, position) => {
-            //       this.pendingInserts.push({ target, newItems: [item], position });
-            //     },
-            //     insertSingle: (item, position) => {
-            //       this.pendingInserts.push({ target, newItems: [item], position });
-            //     },
-            //     insertSingles: (items, position) => {
-            //       this.pendingInserts.push({ target, newItems: items, position });
-            //     },
-            //     addItems: (items) => {
-            //       this.pendingAdditions.push({ target, newItems: items });
-            //     },
-            //     addChildSingleAt: (item, index) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           if (index >= 0 && index <= group.singles.length) {
-            //             group.singles.splice(index, 0, item);
-            //           } else {
-            //             console.warn(`Index "${index}" is out of bounds for singles.`);
-            //           }
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child single.`);
-            //       }
-            //     },
-            //     addChildSingleFirst: (item) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           group.singles.unshift(item);
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child single.`);
-            //       }
-            //     },
-            //     addChildSingleLast: (item) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           group.singles.push(item);
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child single.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child single.`);
-            //       }
-            //     },
-            //     addChildGroupAt: (item, index) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           if (index >= 0 && index <= group.groups.length) {
-            //             group.groups.splice(index, 0, item);
-            //           } else {
-            //             console.warn(`Index "${index}" is out of bounds for groups.`);
-            //           }
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child group.`);
-            //       }
-            //     },
-            //     addChildGroupFirst: (item) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           group.groups.unshift(item);
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child group.`);
-            //       }
-            //     },
-            //     addChildGroupLast: (item) => {
-            //       const foundItemInfo = this.findItemWithParent(this.cache || [], target);
-            //       if (foundItemInfo && foundItemInfo.foundItem) {
-            //         const { foundItem } = foundItemInfo;
-            //         if (foundItem.type === AXPSettingDefinitionItemType.Group) {
-            //           const group = foundItem as AXPSettingDefinitionGroup;
-            //           group.groups.push(item);
-            //         } else {
-            //           console.warn(`Target "${target}" is not a group; cannot add a child group.`);
-            //         }
-            //       } else {
-            //         console.warn(`Target "${target}" not found for adding a child group.`);
-            //       }
-            //     },
-            //   };
-            // },
-        };
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingDefinitionProviderService, providedIn: 'root' }); }
 }
@@ -944,13 +946,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-const AXP_SETTINGS_PROVIDER = new InjectionToken('AXP_SETTINGS_PROVIDER', {
+const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDER', {
     providedIn: 'root',
     factory: () => {
-        return new AXPSettingsProviderDefault();
+        return new AXPSettingValueProviderDefault();
     }
 });
-class AXPSettingsProviderDefault {
+class AXPSettingValueProviderDefault {
     constructor() {
         this.cache = new Map();
         this.localStorageKey = 'AXP_SETTINGS';
@@ -967,22 +969,33 @@ class AXPSettingsProviderDefault {
         }
         return Promise.resolve([]);
     }
-    async set(key, value) {
-        this.cache.set(key, value);
-        // Save to localStorage as a single key
+    async set(keyOrValues, value) {
+        if (typeof keyOrValues === 'string') {
+            // Single value update
+            this.cache.set(keyOrValues, value);
+        }
+        else {
+            // Bulk update
+            for (const [key, val] of Object.entries(keyOrValues)) {
+                this.cache.set(key, val);
+            }
+        }
+        await this.saveToLocalStorage();
+    }
+    async saveToLocalStorage() {
         const settingsObject = {};
-        this.cache.forEach((val, k) => {
-            settingsObject[k] = val;
+        this.cache.forEach((value, key) => {
+            settingsObject[key] = value;
         });
         localStorage.setItem(this.localStorageKey, JSON.stringify(settingsObject));
     }
 }
 
-class AXPSettingsService {
+class AXPSettingValueProviderService {
     constructor() {
-        this.settingsProvider = inject(AXP_SETTINGS_PROVIDER);
+        this.settingsProvider = inject(AXP_SETTING_VALUE_PROVIDER);
         this.settingsCache = new Map();
-        this.changed = new Subject();
+        this.onChanged = new Subject();
     }
     async load() {
         try {
@@ -1004,22 +1017,45 @@ class AXPSettingsService {
         }
         return cloneDeep(this.settingsCache.get(key));
     }
-    async set(key, value) {
-        if (this.settingsCache.has(key)) {
+    async all() {
+        if (this.settingsCache.size == 0) {
+            await this.load();
+        }
+        return Object.fromEntries(this.settingsCache);
+    }
+    // Implementation
+    async set(keyOrValues, value) {
+        const changes = {};
+        if (typeof keyOrValues === 'string') {
+            // Single value update
+            const key = keyOrValues;
             this.settingsCache.set(key, value);
-            await this.settingsProvider.set(key, value);
-            this.changed.next({ key, value });
+            changes[key] = value;
+            await this.settingsProvider.set(key, value); // Call single update
         }
         else {
-            console.warn(`Setting with key "${key}" not found.`);
-            this.settingsCache.set(key, value);
-            this.set(key, value);
+            // Bulk update
+            const values = keyOrValues;
+            for (const [key, val] of Object.entries(values)) {
+                this.settingsCache.set(key, val);
+                changes[key] = val;
+            }
+            await this.settingsProvider.set(values); // Call bulk update
         }
+        // Prepare the detailed change event
+        const keys = Object.keys(changes);
+        const entries = Array.from(this.settingsCache.entries()).map(([key, value]) => ({ key, value }));
+        // Emit the enhanced onChanged event
+        this.onChanged.next({
+            keys,
+            values: changes,
+            entries,
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPSettingValueProviderService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -1047,12 +1083,12 @@ class AXPCommonEffects {
             return of();
         })), { dispatch: false });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1.Actions }, { token: i2.Router }, { token: AXPSettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, deps: [{ token: i1.Actions }, { token: i2.Router }, { token: AXPSettingValueProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonEffects, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }, { type: AXPSettingsService }] });
+        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Router }, { type: AXPSettingValueProviderService }] });
 
 //TODO Loading, Redirect, Drawer, Show toast
 const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
@@ -1208,7 +1244,7 @@ class AXPCommonModule {
             },
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingsService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: AXPAppStartUpService }, { token: AXPSettingValueProviderService }, { token: AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXPCommonModule, imports: [i1.EffectsFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule], exports: [RouterModule] }); }
@@ -1274,7 +1310,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['AXPCommonModuleFactory']
-                }] }, { type: AXPAppStartUpService }, { type: AXPSettingsService }, { type: AXPDataSeederService }] });
+                }] }, { type: AXPAppStartUpService }, { type: AXPSettingValueProviderService }, { type: AXPDataSeederService }] });
 
 class AXPTextLogoConfig {
     constructor(text) {
@@ -1386,9 +1422,11 @@ class AXPStickyDirective {
     get isSticky() {
         return this._isSticky;
     }
-    set isSticky(v) {
-        this._isSticky = v;
-        this.isStickyChange.emit(v);
+    set isSticky(value) {
+        if (this._isSticky !== value) {
+            this._isSticky = value;
+            this.isStickyChange.emit(value);
+        }
     }
     constructor(element, renderer, zone, cdr) {
         this.element = element;
@@ -1400,43 +1438,70 @@ class AXPStickyDirective {
         this._isSticky = false;
         this.onParentScroll = () => {
             this.zone.runOutsideAngular(() => {
-                const scrollPosition = this.parentElement === window
+                const scrollTop = this.parentElement === window
                     ? window.scrollY
-                    : this.parentElement.scrollTop + this.targetElement.offsetTop;
-                if (scrollPosition - this.stickyOffset >= this.topOffset && !this.isSticky) {
-                    this.isSticky = true;
-                    this.stickyClass.split(' ').forEach((c) => {
-                        if (c) {
-                            this.renderer.addClass(this.targetElement, c);
-                        }
+                    : this.parentElement.scrollTop;
+                const shouldStick = scrollTop + this.stickyOffset >= this.topOffset;
+                if (shouldStick !== this.isSticky) {
+                    this.zone.run(() => {
+                        this.isSticky = shouldStick;
+                        this.toggleStickyClasses(shouldStick);
+                        this.cdr.markForCheck();
                     });
-                    this.cdr.markForCheck();
-                }
-                else if (scrollPosition <= this.topOffset && this.isSticky) {
-                    this.stickyClass.split(' ').forEach((c) => {
-                        if (c) {
-                            this.renderer.removeClass(this.targetElement, c);
-                        }
-                    });
-                    this.isSticky = false;
-                    this.cdr.markForCheck();
                 }
             });
         };
     }
     ngAfterViewInit() {
+        this.initSticky();
+        // Add mutation observer for dynamic content
+        this.mutationObserver = new MutationObserver(() => {
+            this.updateTopOffset();
+        });
+        this.mutationObserver.observe(this.element.nativeElement, {
+            childList: true,
+            subtree: true,
+        });
+        // Add resize event listener
+        window.addEventListener('resize', this.updateTopOffset.bind(this));
+    }
+    initSticky() {
         if (this.stickyParent instanceof HTMLElement) {
             this.parentElement = this.stickyParent;
         }
         else {
-            this.parentElement = document.querySelector(this.stickyParent) || window;
+            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));
+        this.targetElement =
+            document.querySelector(this.stickyTarget) ||
+                this.element.nativeElement;
+        this.updateTopOffset();
+        this.parentElement.addEventListener('scroll', this.onParentScroll);
+    }
+    updateTopOffset() {
+        this.zone.runOutsideAngular(() => {
+            const rect = this.targetElement.getBoundingClientRect();
+            this.topOffset = rect.top + (window.scrollY || 0);
+        });
+    }
+    toggleStickyClasses(isSticky) {
+        const classes = this.stickyClass.split(' ').filter(Boolean);
+        classes.forEach((className) => {
+            if (isSticky) {
+                this.renderer.addClass(this.targetElement, className);
+            }
+            else {
+                this.renderer.removeClass(this.targetElement, className);
+            }
+        });
     }
     ngOnDestroy() {
         this.parentElement.removeEventListener('scroll', this.onParentScroll);
+        window.removeEventListener('resize', this.updateTopOffset.bind(this));
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+        }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPStickyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AXPStickyDirective, isStandalone: true, selector: "[axpSticky]", inputs: { stickyClass: ["axpSticky", "stickyClass"], stickyOffset: "stickyOffset", stickyParent: "stickyParent", stickyTarget: "stickyTarget" }, outputs: { isStickyChange: "isStickyChange" }, exportAs: ["axpSticky"], ngImport: i0 }); }
@@ -3085,5 +3150,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefinitionProviderService, AXPSettingsService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTINGS_PROVIDER, AXP_SETTING_PROVIDER, AXP_WIDGET_TOKEN, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
+export { ALL_DEFAULT_OPERATORS, AXEntityLoaderDefault, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXMWorkflowErrorHandler, AXPAppStartUpProvider, AXPAppStartUpService, AXPClipBoardService, AXPCommonEffects, AXPCommonModule, AXPCommonWidgetModule, AXPComponentLogoConfig, AXPComponentSlotDirective, AXPComponentSlotLoaderService, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataGenerator, AXPDataProvider, AXPDataSeederService, AXPDexieEntityStorageService, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityListViewConfigEmpty, AXPEntityQueryType, AXPEntityRegistryService, AXPEntityStorageService, AXPErrorHandlerRegistryService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFontIconLogoConfig, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPLogoComponent, AXPMenuProviderService, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateAction, AXPPdfPageSize, AXPPdfService, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPSchemaModule, AXPSchemaRegistryService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingValueProviderService, AXPSignInAction, AXPSignOutAction, AXPStickyDirective, AXPTextLogoConfig, AXPToastAction, AXPWidgetBase, AXPWidgetColumnRendererComponent, AXPWidgetEditBase, AXPWidgetFilterBase, AXPWidgetFilterRendererComponent, AXPWidgetRendererComponent, AXPWorkflowNavigateAction, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_LOADER, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXP_WIDGET_TOKEN, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, convertPropertiesToColumns, convertPropertyToColumn, getEntityInfo, resolveActionLook, widgetSchemas };
 //# sourceMappingURL=acorex-platform-common.mjs.map