@acorex/platform 20.6.0-next.8 → 21.0.0-next.0

package/fesm2022/acorex-platform-core.mjs

@@ -1,10 +1,10 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, computed, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, Injector, runInInjectionContext, provideAppInitializer, signal, Pipe } from '@angular/core';
+import { InjectionToken, inject, Injectable, computed, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, signal, output, DestroyRef, Renderer2, untracked, Injector, runInInjectionContext, provideAppInitializer, Pipe } from '@angular/core';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
 import { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, isEqual, differenceWith, union, cloneDeep, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
-import { Subject, interval } from 'rxjs';
+import { Subject, interval, fromEvent } from 'rxjs';
 import { AXCalendarService } from '@acorex/core/date-time';
-import { startWith, map } from 'rxjs/operators';
+import { startWith, map, debounceTime } from 'rxjs/operators';
 
 const AXP_ACTIVITY_LOG_PROVIDER = new InjectionToken('AXP_ACTIVITY_LOGS_PROVIDER');
 class AXPActivityLogService {
@@ -115,6 +115,41 @@ class AXPColorPaletteService {
         this.cache = null;
         await this.loadPalettes();
     }
+    /**
+     * Get the default palette (material-design) or fallback colors
+     * @returns Promise of default palette, never returns undefined
+     */
+    async getDefaultPalette() {
+        const defaultPalette = await this.getPalette('material-design');
+        if (defaultPalette) {
+            return defaultPalette;
+        }
+        // Fallback to hardcoded material design colors if provider fails
+        return {
+            name: 'material-design',
+            title: 'Material Design',
+            category: 'material',
+            description: 'Google Material Design color palette',
+            colors: [
+                '#F44336', // Red
+                '#E91E63', // Pink
+                '#9C27B0', // Purple
+                '#673AB7', // Deep Purple
+                '#3F51B5', // Indigo
+                '#2196F3', // Blue
+                '#03A9F4', // Light Blue
+                '#00BCD4', // Cyan
+                '#009688', // Teal
+                '#4CAF50', // Green
+                '#8BC34A', // Light Green
+                '#CDDC39', // Lime
+                '#FFEB3B', // Yellow
+                '#FFC107', // Amber
+                '#FF9800', // Orange
+                '#FF5722', // Deep Orange
+            ],
+        };
+    }
     //#endregion
     //#region ----   Private Methods   ----
     /**
@@ -770,6 +805,10 @@ class AXPDataGenerator {
         const country = this.country();
         return `${streetNumber} ${street}, ${city}, ${state} ${zip}, ${country}`;
     }
+    static avatar() {
+        return `https://avatar.iran.liara.run/public/${this.pick([35, 22, 16, 6, 31])}`;
+        //return `https://i.pravatar.cc/300?u=${this.uuid()}`;
+    }
 }
 
 function objectKeyValueTransforms(keyName) {
@@ -783,19 +822,152 @@ function objectKeyValueTransforms(keyName) {
     };
 }
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Provider Registry Service   ----
+/**
+ * Registry service for dynamically loaded module providers.
+ * Stores provider instances that are loaded conditionally based on access control.
+ */
+class AXPModuleProviderRegistry {
+    constructor() {
+        //#region ----   Fields   ----
+        this.permissionProviders = [];
+        this.menuProviders = [];
+        this.entityProviders = [];
+        this.settingProviders = [];
+        this.searchProviders = [];
+        this.featureProviders = [];
+        this.datasourceProviders = [];
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Register a permission provider.
+     */
+    registerPermissionProvider(provider) {
+        this.permissionProviders.push(provider);
+    }
+    /**
+     * Get all registered permission providers.
+     */
+    getPermissionProviders() {
+        return [...this.permissionProviders];
+    }
+    /**
+     * Register a menu provider.
+     */
+    registerMenuProvider(provider) {
+        this.menuProviders.push(provider);
+    }
+    /**
+     * Get all registered menu providers.
+     */
+    getMenuProviders() {
+        return [...this.menuProviders];
+    }
+    /**
+     * Register an entity provider.
+     */
+    registerEntityProvider(provider) {
+        this.entityProviders.push(provider);
+    }
+    /**
+     * Get all registered entity providers.
+     */
+    getEntityProviders() {
+        return [...this.entityProviders];
+    }
+    /**
+     * Register a settings provider.
+     */
+    registerSettingProvider(provider) {
+        this.settingProviders.push(provider);
+    }
+    /**
+     * Get all registered settings providers.
+     */
+    getSettingProviders() {
+        return [...this.settingProviders];
+    }
+    /**
+     * Register a search provider.
+     */
+    registerSearchProvider(provider) {
+        this.searchProviders.push(provider);
+    }
+    /**
+     * Get all registered search providers.
+     */
+    getSearchProviders() {
+        return [...this.searchProviders];
+    }
+    /**
+     * Register a feature provider.
+     */
+    registerFeatureProvider(provider) {
+        this.featureProviders.push(provider);
+    }
+    /**
+     * Get all registered feature providers.
+     */
+    getFeatureProviders() {
+        return [...this.featureProviders];
+    }
+    /**
+     * Register a datasource provider.
+     */
+    registerDatasourceProvider(provider) {
+        this.datasourceProviders.push(provider);
+    }
+    /**
+     * Get all registered datasource providers.
+     */
+    getDatasourceProviders() {
+        return [...this.datasourceProviders];
+    }
+    /**
+     * Clear all registered providers.
+     * Useful for testing or re-initialization.
+     */
+    clear() {
+        this.permissionProviders.length = 0;
+        this.menuProviders.length = 0;
+        this.entityProviders.length = 0;
+        this.settingProviders.length = 0;
+        this.searchProviders.length = 0;
+        this.featureProviders.length = 0;
+        this.datasourceProviders.length = 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleProviderRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleProviderRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleProviderRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 const AXP_DATASOURCE_DEFINITION_PROVIDER = new InjectionToken('AXP_DATASOURCE_TYPE_PROVIDER');
 class AXPDataSourceDefinitionProviderService {
     constructor() {
         this.providers = inject(AXP_DATASOURCE_DEFINITION_PROVIDER, { optional: true });
+        this.providerRegistry = inject(AXPModuleProviderRegistry);
     }
     async items() {
         const items = [];
+        // Load from DI tokens (backward compatibility)
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
                 set(provider, '__parent__', this);
                 items.push(...(await provider.items()));
             }
         }
+        // Load from registry (manifest-based, conditionally loaded)
+        const registryProviders = this.providerRegistry.getDatasourceProviders();
+        for (const provider of registryProviders) {
+            set(provider, '__parent__', this);
+            items.push(...(await provider.items()));
+        }
         return items;
     }
     async get(name) {
@@ -966,6 +1138,203 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Directive   ----
+/**
+ * Fullscreen directive that provides CSS-based fullscreen functionality
+ * Usage: <element axFullscreen #fullscreen="axFullscreen"></element>
+ * Then: fullscreen.toggle() or fullscreen.enter() or fullscreen.exit()
+ */
+class AXFullscreenDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        //#region ----   Properties   ----
+        /**
+         * Current fullscreen state
+         */
+        this.isFullscreenState = signal(false, ...(ngDevMode ? [{ debugName: "isFullscreenState" }] : []));
+        /**
+         * Original element styles to restore
+         */
+        this.originalStyles = {};
+        /**
+         * Original parent element reference
+         */
+        this.originalParent = null;
+        /**
+         * Fullscreen container element
+         */
+        this.fullscreenContainer = null;
+        /**
+         * Fullscreen change event
+         */
+        this.fullscreenChange = output();
+        //#endregion
+        //#region ----   Constructor   ----
+        this.destroyRef = inject(DestroyRef);
+        this.renderer = inject(Renderer2);
+        // Sync state changes to output
+        effect(() => {
+            const isFullscreen = this.isFullscreenState();
+            untracked(() => {
+                this.fullscreenChange.emit(isFullscreen);
+            });
+        });
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Toggle fullscreen state
+     */
+    async toggle() {
+        if (this.isFullscreenState()) {
+            await this.exit();
+        }
+        else {
+            await this.enter();
+        }
+    }
+    /**
+     * Enter fullscreen mode using CSS
+     */
+    async enter() {
+        if (this.isFullscreenState()) {
+            return;
+        }
+        const element = this.elementRef.nativeElement;
+        try {
+            // Store original styles and parent
+            this.storeOriginalStyles(element);
+            this.originalParent = element.parentElement;
+            // Create fullscreen container
+            this.fullscreenContainer = this.renderer.createElement('div');
+            this.renderer.setStyle(this.fullscreenContainer, 'position', 'fixed');
+            this.renderer.setStyle(this.fullscreenContainer, 'top', '0');
+            this.renderer.setStyle(this.fullscreenContainer, 'left', '0');
+            this.renderer.setStyle(this.fullscreenContainer, 'width', '100vw');
+            this.renderer.setStyle(this.fullscreenContainer, 'height', '100vh');
+            this.renderer.setStyle(this.fullscreenContainer, 'z-index', '9999');
+            this.renderer.setStyle(this.fullscreenContainer, 'background-color', '#ffffff');
+            this.renderer.setStyle(this.fullscreenContainer, 'overflow', 'auto');
+            // Move element to container
+            this.renderer.appendChild(this.fullscreenContainer, element);
+            // Apply fullscreen styles to element
+            this.renderer.setStyle(element, 'position', 'relative');
+            this.renderer.setStyle(element, 'width', '100%');
+            this.renderer.setStyle(element, 'height', '100%');
+            this.renderer.setStyle(element, 'margin', '0');
+            this.renderer.setStyle(element, 'padding', '0');
+            // Append container to body
+            this.renderer.appendChild(document.body, this.fullscreenContainer);
+            // Prevent body scroll
+            this.renderer.setStyle(document.body, 'overflow', 'hidden');
+            this.isFullscreenState.set(true);
+        }
+        catch (error) {
+            console.error('Error entering fullscreen:', error);
+            this.restoreOriginalStyles(element);
+        }
+    }
+    /**
+     * Exit fullscreen mode
+     */
+    async exit() {
+        if (!this.isFullscreenState()) {
+            return;
+        }
+        const element = this.elementRef.nativeElement;
+        try {
+            // Restore body scroll
+            this.renderer.removeStyle(document.body, 'overflow');
+            // Move element back to original parent
+            if (this.fullscreenContainer && this.originalParent) {
+                this.renderer.removeChild(this.fullscreenContainer, element);
+                this.renderer.appendChild(this.originalParent, element);
+                // Remove container
+                this.renderer.removeChild(document.body, this.fullscreenContainer);
+                this.fullscreenContainer = null;
+            }
+            // Restore original styles
+            this.restoreOriginalStyles(element);
+            this.isFullscreenState.set(false);
+        }
+        catch (error) {
+            console.error('Error exiting fullscreen:', error);
+        }
+    }
+    /**
+     * Check if currently in fullscreen mode
+     */
+    isFullscreen() {
+        return this.isFullscreenState();
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Store original element styles
+     */
+    storeOriginalStyles(element) {
+        const computedStyle = window.getComputedStyle(element);
+        this.originalStyles = {
+            position: computedStyle.position,
+            top: computedStyle.top,
+            left: computedStyle.left,
+            width: computedStyle.width,
+            height: computedStyle.height,
+            zIndex: computedStyle.zIndex,
+            backgroundColor: computedStyle.backgroundColor,
+            margin: computedStyle.margin,
+            padding: computedStyle.padding,
+        };
+    }
+    /**
+     * Restore original element styles
+     */
+    restoreOriginalStyles(element) {
+        if (!this.originalStyles) {
+            return;
+        }
+        // Restore each style property
+        Object.entries(this.originalStyles).forEach(([key, value]) => {
+            const styleKey = this.camelToKebabCase(key);
+            if (value) {
+                this.renderer.setStyle(element, styleKey, value);
+            }
+            else {
+                this.renderer.removeStyle(element, styleKey);
+            }
+        });
+        this.originalStyles = {};
+    }
+    /**
+     * Convert camelCase to kebab-case for CSS properties
+     */
+    camelToKebabCase(str) {
+        return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2').toLowerCase();
+    }
+    //#endregion
+    //#region ----   Lifecycle   ----
+    ngOnDestroy() {
+        // Exit fullscreen if still active
+        if (this.isFullscreenState()) {
+            this.exit().catch(() => {
+                // Ignore errors during cleanup
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXFullscreenDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: AXFullscreenDirective, isStandalone: true, selector: "[axFullscreen]", outputs: { fullscreenChange: "fullscreenChange" }, exportAs: ["axFullscreen"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXFullscreenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axFullscreen]',
+                    standalone: true,
+                    exportAs: 'axFullscreen',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { fullscreenChange: [{ type: i0.Output, args: ["fullscreenChange"] }] } });
+
 const AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER = new InjectionToken('AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER');
 
 //#region ----   Imports   ----
@@ -1445,448 +1814,362 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
-class AXPAppStartUpService {
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Injection Token   ----
+/**
+ * Injection token for module manifest providers.
+ * Modules register their manifest providers using this token.
+ */
+const AXP_MODULE_MANIFEST_PROVIDER = new InjectionToken('AXP_MODULE_MANIFEST_PROVIDER');
+//#endregion
+//#region ----   Default Provider   ----
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Registry Service   ----
+/**
+ * Registry service for module manifests.
+ * Collects and manages all registered module manifests.
+ */
+class AXPModuleManifestRegistry {
     constructor() {
-        this.tasks = [];
+        //#region ----   Fields   ----
+        this.manifests = new Map();
+        this.featureDefinitions = new Map();
+        this.injector = inject(Injector);
+        this.initializationPromise = null;
+        this.isInitialized = false;
     }
-    registerTask(task) {
-        this.tasks.push(task);
+    //#endregion
+    //#region ----   Initialization   ----
+    /**
+     * Initialize registry by loading all manifest providers.
+     * Should be called during app startup.
+     * Safe to call multiple times - will only initialize once.
+     */
+    async initialize() {
+        // If already initialized, return immediately
+        if (this.isInitialized) {
+            return;
+        }
+        // If initialization is in progress, wait for it
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        // Start initialization
+        this.initializationPromise = this._doInitialize();
+        await this.initializationPromise;
     }
-    async runAllTasks() {
-        for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
-            console.log(`Running "${task.statusText}" with priority "${task.priority}"`);
-            this.updateStatus(task.statusText);
-            await task.run();
+    /**
+     * Internal initialization logic.
+     */
+    async _doInitialize() {
+        // Get manifests from injector (using useValue, they are provided directly)
+        let manifests;
+        try {
+            const injectedManifests = this.injector.get(AXP_MODULE_MANIFEST_PROVIDER, []);
+            manifests = Array.isArray(injectedManifests) ? injectedManifests : injectedManifests ? [injectedManifests] : [];
+        }
+        catch (error) {
+            console.error('Failed to get manifest providers from injector:', error);
+            manifests = [];
         }
+        // Register all manifests directly
+        const registerPromises = manifests.map(async (manifest) => {
+            try {
+                // Validate manifest
+                if (!manifest) {
+                    console.error('Invalid manifest:', manifest);
+                    return;
+                }
+                await this.register(manifest);
+            }
+            catch (error) {
+                console.error(`Failed to register manifest:`, error);
+            }
+        });
+        await Promise.all(registerPromises);
+        this.isInitialized = true;
     }
-    updateStatus(status) {
-        const loadingText = document.querySelector('#loadingText');
-        if (loadingText) {
-            loadingText.innerHTML = status;
+    //#endregion
+    //#region ----   Manifest Management   ----
+    /**
+     * Register a module manifest.
+     */
+    async register(manifest) {
+        // Validate manifest
+        if (!manifest.name) {
+            throw new Error('Manifest must have a name');
+        }
+        if (!manifest.version) {
+            throw new Error(`Manifest for module '${manifest.name}' must have a version`);
         }
+        // Register manifest
+        this.manifests.set(manifest.name, manifest);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
+    /**
+     * Get manifest for a module.
+     */
+    get(moduleName) {
+        return this.manifests.get(moduleName);
+    }
+    /**
+     * Get all registered manifests.
+     */
+    getAll() {
+        return Array.from(this.manifests.values());
+    }
+    /**
+     * Check if a module manifest is registered.
+     */
+    has(moduleName) {
+        return this.manifests.has(moduleName);
+    }
+    //#endregion
+    //#region ----   Feature Definition Management   ----
+    /**
+     * Get all feature definitions from all manifests.
+     */
+    getAllFeatureDefinitions() {
+        return Array.from(this.featureDefinitions.values());
+    }
+    /**
+     * Get feature definition by full name.
+     */
+    getFeatureDefinition(featureName) {
+        return this.featureDefinitions.get(featureName);
+    }
+    /**
+     * Check if a feature is defined in any manifest.
+     */
+    isFeatureDefined(featureName) {
+        return this.featureDefinitions.has(featureName);
+    }
+    /**
+     * Get default value for a feature.
+     * Returns undefined if feature is not defined.
+     */
+    getFeatureDefault(featureName) {
+        const definition = this.getFeatureDefinition(featureName);
+        return definition?.defaultValue;
+    }
+    /**
+     * Get all feature definitions for a specific module.
+     */
+    getModuleFeatures(moduleName) {
+        return Array.from(this.featureDefinitions.values()).filter((def) => def.module === moduleName);
+    }
+    /**
+     * Register a feature definition dynamically (e.g., from feature definition provider).
+     * Used to add features that are defined at runtime via featuresProvider.
+     */
+    registerFeatureDefinition(definition) {
+        this.featureDefinitions.set(definition.name, definition);
+    }
+    //#endregion
+    //#region ----   Dependency Checking   ----
+    /**
+     * Check if module dependencies are satisfied.
+     * Returns array of missing dependencies.
+     */
+    checkDependencies(moduleName) {
+        const manifest = this.get(moduleName);
+        if (!manifest?.dependencies) {
+            return { missingModules: [], missingFeatures: [] };
+        }
+        const missingModules = [];
+        const missingFeatures = [];
+        // Check module dependencies
+        if (manifest.dependencies.modules) {
+            for (const depModule of manifest.dependencies.modules) {
+                if (!this.has(depModule)) {
+                    missingModules.push(depModule);
+                }
+            }
+        }
+        // Check feature dependencies
+        if (manifest.dependencies.features) {
+            for (const featureName of manifest.dependencies.features) {
+                if (!this.isFeatureDefined(featureName)) {
+                    missingFeatures.push(featureName);
+                }
+            }
+        }
+        return { missingModules, missingFeatures };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestRegistry, decorators: [{
             type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+            args: [{ providedIn: 'root' }]
         }] });
-function initAppFactory(appInitService) {
-    return () => appInitService.runAllTasks();
-}
-const AXPAppStartUpProvider = provideAppInitializer(() => {
-    const initializerFn = initAppFactory(inject(AXPAppStartUpService));
-    return initializerFn();
-});
 
-/**
- * Status Definition Types
- * Defines the structure for status definitions and their transitions
- */
-/**
- * Abstract class for status providers
- * Similar to AXPTaskBadgeProvider pattern
- */
-class AXPStatusProvider {
-}
-
-//#region ----   Injection Token   ----
-/**
- * Injection token for status providers
- * Use with multi: true to register multiple providers
- */
-const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
+//#region ----   Imports   ----
 //#endregion
-//#region ----   Provider Service   ----
+//#region ----   Initializer   ----
 /**
- * Service for managing status definitions from multiple providers
- * Similar to AXPTaskBadgeService pattern - no cache, direct access
- *
- * @example
- * ```typescript
- * // In a module providers array:
- * {
- *   provide: AXP_STATUS_PROVIDERS,
- *   useClass: TaskStatusProvider,
- *   multi: true,
- * }
- *
- * // Example provider implementation:
- * export class TaskStatusProvider extends AXPStatusProvider {
- *   readonly key = 'task-management.status';
- *   readonly statuses = [
- *     { name: 'todo', title: 'To Do', color: '#6b7280', icon: 'fa-light fa-circle', isInitial: true },
- *     { name: 'in-progress', title: 'In Progress', color: '#3b82f6', icon: 'fa-light fa-play' },
- *     { name: 'done', title: 'Done', color: '#10b981', icon: 'fa-light fa-check-circle', isFinal: true },
- *   ];
- *   readonly transitions = [
- *     { from: 'todo', to: 'in-progress', title: 'Start', condition: '{{user.canEdit}}' },
- *     { from: 'in-progress', to: 'done', title: 'Complete' },
- *   ];
- *   readonly defaultStatus = 'todo';
- * }
- *
- * // Later, get the status:
- * const status = statusService.getStatus('task-management.status');
- * if (status) {
- *   console.log('Statuses:', status.statuses);
- *   console.log('Transitions:', status.transitions);
- * }
- * ```
+ * Startup task to initialize module manifest registry.
+ * Registers this task with app startup service.
  */
-class AXPStatusDefinitionProviderService {
-    //#endregion
-    //#region ----   Constructor   ----
+class AXPModuleManifestInitializer {
     constructor() {
-        //#region ----   Dependencies   ----
-        this.providers = inject(AXP_STATUS_PROVIDERS, { optional: true }) ?? [];
-        //#endregion
-        //#region ----   State   ----
-        this.statusMap = new Map();
-        // Register all providers in constructor (like badge service)
-        for (const provider of this.providers) {
-            if (this.statusMap.has(provider.key)) {
-                console.warn(`Status with key "${provider.key}" already exists. Overwriting with new status.`);
-            }
-            this.statusMap.set(provider.key, provider);
-        }
+        //#region ----   Fields   ----
+        this.manifestRegistry = inject(AXPModuleManifestRegistry);
     }
     //#endregion
-    //#region ----   Public API   ----
+    //#region ----   Public Methods   ----
     /**
-     * Get a status provider by key
-     * Direct access from Map (no lazy load, no cache)
-     *
-     * @param key - Status key (e.g., 'task-management.status')
-     * @returns Status provider with all statuses and transitions, or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * const status = statusService.getStatus('task-management.status');
-     * if (status) {
-     *   console.log('Statuses:', status.statuses);
-     *   console.log('Transitions:', status.transitions);
-     * }
-     * ```
-     */
-    getStatus(key) {
-        return this.statusMap.get(key);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, providedIn: 'root' }); }
+     * Create startup task for manifest initialization.
+     */
+    createStartupTask() {
+        return {
+            name: 'ModuleManifests',
+            statusText: 'Loading module manifests...',
+            priority: 1, // Load early, before features/permissions
+            run: async () => {
+                await this.manifestRegistry.initialize();
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestInitializer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestInitializer, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestInitializer, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
+        }] });
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Feature Definition Provider Interface   ----
 /**
- * Standard system status types
- * These are the predefined status values used across the platform
+ * Context for feature definition providers.
+ * Allows providers to add additional feature definitions dynamically.
  */
-var AXPSystemStatusType;
-(function (AXPSystemStatusType) {
-    AXPSystemStatusType["Todo"] = "todo";
-    AXPSystemStatusType["InProgress"] = "in-progress";
-    AXPSystemStatusType["InReview"] = "in-review";
-    AXPSystemStatusType["Blocked"] = "blocked";
-    AXPSystemStatusType["Done"] = "done";
-    AXPSystemStatusType["Cancelled"] = "cancelled";
-    AXPSystemStatusType["Draft"] = "draft";
-    AXPSystemStatusType["PendingReview"] = "pending-review";
-    AXPSystemStatusType["Approved"] = "approved";
-    AXPSystemStatusType["Published"] = "published";
-    AXPSystemStatusType["Archived"] = "archived";
-    AXPSystemStatusType["Rejected"] = "rejected";
-    AXPSystemStatusType["Active"] = "active";
-    AXPSystemStatusType["Inactive"] = "inactive";
-    AXPSystemStatusType["Pending"] = "pending";
-    AXPSystemStatusType["Completed"] = "completed";
-    AXPSystemStatusType["Suspended"] = "suspended";
-    AXPSystemStatusType["Failed"] = "failed";
-})(AXPSystemStatusType || (AXPSystemStatusType = {}));
-const i18n$1 = (key) => `@general:statuses.${key}`;
+class AXPFeatureDefinitionProviderContext {
+    constructor() {
+        this.features = new Map();
+    }
+    /**
+     * Add a feature definition.
+     * @param key Full feature key (ModuleName:FeatureKey format with colon separator)
+     * @param definition Feature definition
+     */
+    addFeature(key, definition) {
+        this.features.set(key, definition);
+    }
+    /**
+     * Get all feature definitions.
+     */
+    getFeatures() {
+        return this.features;
+    }
+}
 /**
- * Standard system status definitions
- * Provides consistent status definitions across the platform
- * Uses AXPStatusDefinition interface from status-definition.types.ts
+ * Injection token for feature definition providers.
  */
-const AXPSystemStatuses = Object.freeze({
-    Todo: {
-        name: AXPSystemStatusType.Todo,
-        title: i18n$1('todo.title'),
-        icon: 'fa-light fa-circle',
-        color: '#6b7280',
-        description: i18n$1('todo.description'),
-        order: 1,
-        isActive: true,
-        isInitial: true,
-        isFinal: false,
-    },
-    InProgress: {
-        name: AXPSystemStatusType.InProgress,
-        title: i18n$1('in-progress.title'),
-        icon: 'fa-light fa-play',
-        color: '#3b82f6',
-        description: i18n$1('in-progress.description'),
-        order: 2,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    InReview: {
-        name: AXPSystemStatusType.InReview,
-        title: i18n$1('in-review.title'),
-        icon: 'fa-light fa-eye',
-        color: '#8b5cf6',
-        description: i18n$1('in-review.description'),
-        order: 3,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Blocked: {
-        name: AXPSystemStatusType.Blocked,
-        title: i18n$1('blocked.title'),
-        icon: 'fa-light fa-ban',
-        color: '#ef4444',
-        description: i18n$1('blocked.description'),
-        order: 4,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Done: {
-        name: AXPSystemStatusType.Done,
-        title: i18n$1('done.title'),
-        icon: 'fa-light fa-check-circle',
-        color: '#10b981',
-        description: i18n$1('done.description'),
-        order: 5,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Cancelled: {
-        name: AXPSystemStatusType.Cancelled,
-        title: i18n$1('cancelled.title'),
-        icon: 'fa-light fa-times-circle',
-        color: '#64748b',
-        description: i18n$1('cancelled.description'),
-        order: 6,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Draft: {
-        name: AXPSystemStatusType.Draft,
-        title: i18n$1('draft.title'),
-        icon: 'fa-light fa-file-pen',
-        color: '#6b7280',
-        description: i18n$1('draft.description'),
-        order: 1,
-        isActive: true,
-        isInitial: true,
-        isFinal: false,
-    },
-    PendingReview: {
-        name: AXPSystemStatusType.PendingReview,
-        title: i18n$1('pending-review.title'),
-        icon: 'fa-light fa-clock',
-        color: '#f59e0b',
-        description: i18n$1('pending-review.description'),
-        order: 2,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Approved: {
-        name: AXPSystemStatusType.Approved,
-        title: i18n$1('approved.title'),
-        icon: 'fa-light fa-check-circle',
-        color: '#10b981',
-        description: i18n$1('approved.description'),
-        order: 3,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Published: {
-        name: AXPSystemStatusType.Published,
-        title: i18n$1('published.title'),
-        icon: 'fa-light fa-globe',
-        color: '#3b82f6',
-        description: i18n$1('published.description'),
-        order: 4,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Archived: {
-        name: AXPSystemStatusType.Archived,
-        title: i18n$1('archived.title'),
-        icon: 'fa-light fa-archive',
-        color: '#64748b',
-        description: i18n$1('archived.description'),
-        order: 5,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Rejected: {
-        name: AXPSystemStatusType.Rejected,
-        title: i18n$1('rejected.title'),
-        icon: 'fa-light fa-times-circle',
-        color: '#ef4444',
-        description: i18n$1('rejected.description'),
-        order: 6,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Active: {
-        name: AXPSystemStatusType.Active,
-        title: i18n$1('active.title'),
-        icon: 'fa-light fa-check-circle',
-        color: '#10b981',
-        description: i18n$1('active.description'),
-        order: 1,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Inactive: {
-        name: AXPSystemStatusType.Inactive,
-        title: i18n$1('inactive.title'),
-        icon: 'fa-light fa-circle',
-        color: '#6b7280',
-        description: i18n$1('inactive.description'),
-        order: 2,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Pending: {
-        name: AXPSystemStatusType.Pending,
-        title: i18n$1('pending.title'),
-        icon: 'fa-light fa-clock',
-        color: '#f59e0b',
-        description: i18n$1('pending.description'),
-        order: 1,
-        isActive: true,
-        isInitial: true,
-        isFinal: false,
-    },
-    Completed: {
-        name: AXPSystemStatusType.Completed,
-        title: i18n$1('completed.title'),
-        icon: 'fa-light fa-check-circle',
-        color: '#10b981',
-        description: i18n$1('completed.description'),
-        order: 10,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Suspended: {
-        name: AXPSystemStatusType.Suspended,
-        title: i18n$1('suspended.title'),
-        icon: 'fa-light fa-pause-circle',
-        color: '#f59e0b',
-        description: i18n$1('suspended.description'),
-        order: 5,
-        isActive: true,
-        isInitial: false,
-        isFinal: false,
-    },
-    Failed: {
-        name: AXPSystemStatusType.Failed,
-        title: i18n$1('failed.title'),
-        icon: 'fa-light fa-xmark-circle',
-        color: '#ef4444',
-        description: i18n$1('failed.description'),
-        order: 10,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
+const AXP_FEATURE_DEFINITION_PROVIDER = new InjectionToken('AXP_FEATURE_DEFINITION_PROVIDER', {
+    providedIn: 'root',
+    factory: () => [],
+});
+//#endregion
+
+//#region ----   Provider Interfaces   ----
+/**
+ * Injection token for edition service.
+ * Modules should provide their implementation using this token.
+ */
+const AXP_EDITION_SERVICE = new InjectionToken('AXP_EDITION_SERVICE', {
+    providedIn: 'root',
+    factory: () => {
+        return null;
     },
 });
 /**
- * Get system status definition by type
- * @param type - Status type
- * @returns System status definition or undefined
+ * Injection token for module provider loader.
+ * Implementation: @acorex/platform/auth
  */
-function getSystemStatus(type) {
-    return Object.values(AXPSystemStatuses).find(status => status.name === type);
-}
+const AXP_MODULE_PROVIDER_LOADER = new InjectionToken('AXP_MODULE_PROVIDER_LOADER');
 /**
- * Resolves the visual appearance (color and icon) for status
- * using the system statuses from the core module.
- * @param statusType - Status type string
- * @returns Color and icon for the status
+ * Injection token for module provider initializer.
+ * Implementation: @acorex/platform/auth
  */
-function resolveStatusLook(statusType) {
-    // Try to get system status first
-    const systemStatusType = statusType;
-    if (systemStatusType) {
-        const systemStatus = getSystemStatus(systemStatusType);
-        if (systemStatus) {
-            // Convert hex color to semantic color type if needed
-            // For now, return as-is and let the UI handle it
-            return {
-                color: systemStatus.color,
-                icon: systemStatus.icon || ''
-            };
-        }
-    }
-    // Fallback for unknown statuses
-    return {
-        color: '#6b7280',
-        icon: ''
-    };
-}
+const AXP_MODULE_PROVIDER_INITIALIZER = new InjectionToken('AXP_MODULE_PROVIDER_INITIALIZER');
 /**
- * Resolves the complete status information (title, description, icon, color) for a status
- * using the system statuses from the core module.
- * @param statusType - Status type string
- * @returns Complete status information as AXPStatusDefinition
+ * Injection token for session service.
+ * Implementation: @acorex/platform/auth
  */
-function getStatusInfo(statusType) {
-    const systemStatusType = statusType;
-    if (systemStatusType) {
-        const systemStatus = getSystemStatus(systemStatusType);
-        if (systemStatus) {
-            return systemStatus;
-        }
-    }
-    // Fallback for unknown statuses
-    return {
-        name: statusType,
-        title: statusType,
-        description: `Status: ${statusType}`,
-        icon: '',
-        color: '#6b7280'
-    };
+const AXP_SESSION_SERVICE = new InjectionToken('AXP_SESSION_SERVICE');
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Default Implementation   ----
+/**
+ * Default implementation of module access control service.
+ * Checks if module is enabled in edition.modulesAndFeatures.modules.
+ */
+class DefaultModuleAccessControlService {
+    checkAccess(moduleName, context) {
+        // Check if module is enabled in edition
+        const enabledModules = context.edition.modulesAndFeatures?.modules || [];
+        return enabledModules.includes(moduleName);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: DefaultModuleAccessControlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: DefaultModuleAccessControlService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: DefaultModuleAccessControlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//#endregion
+//#region ----   Injection Token   ----
 /**
- * Get system status definition directly (no conversion needed since it's already AXPStatusDefinition)
- * @param statusType - Status type
- * @param overrides - Optional overrides for the status definition
- * @returns AXPStatusDefinition
+ * Injection token for module access control service.
+ * If not provided, DefaultModuleAccessControlService will be used as fallback.
  */
-function systemStatusToDefinition(statusType, overrides) {
-    const systemStatus = getSystemStatus(statusType);
-    if (!systemStatus) {
-        throw new Error(`System status ${statusType} not found`);
+const AXP_MODULE_ACCESS_CONTROL_SERVICE = new InjectionToken('AXP_MODULE_ACCESS_CONTROL_SERVICE');
+
+class AXPAppStartUpService {
+    constructor() {
+        this.tasks = [];
     }
-    return {
-        ...systemStatus,
-        ...overrides,
-    };
+    registerTask(task) {
+        this.tasks.push(task);
+    }
+    async runAllTasks() {
+        for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
+            this.updateStatus(task.statusText);
+            await task.run();
+        }
+    }
+    updateStatus(status) {
+        const loadingText = document.querySelector('#loadingText');
+        if (loadingText) {
+            loadingText.innerHTML = status;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPAppStartUpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+function initAppFactory(appInitService) {
+    return () => appInitService.runAllTasks();
+}
+const AXPAppStartUpProvider = provideAppInitializer(() => {
+    const initializerFn = initAppFactory(inject(AXPAppStartUpService));
+    return initializerFn();
+});
 
 //#region ----   Tag Types   ----
 //#endregion
@@ -2800,7 +3083,6 @@ const AXPSystemActions = Object.freeze({
         key: AXPSystemActionType.Cancel,
         title: i18n('cancel.title'),
         icon: 'fa-light fa-xmark',
-        color: 'danger',
         critical: true,
         descriptions: {
             title: i18n('cancel.title'),
@@ -2997,6 +3279,12 @@ class AXPComponentLogoConfig {
         this.component = component;
     }
 }
+class AXPIconLogoConfig {
+    constructor(icon, color) {
+        this.icon = icon;
+        this.color = color;
+    }
+}
 
 var AXPPlatformScope;
 (function (AXPPlatformScope) {
@@ -3290,6 +3578,185 @@ async function applyQueryArray(dataArray, query) {
     };
 }
 
+//#region ----   Type Definitions   ----
+/**
+ * Screen Size Enum
+ */
+var AXPScreenSize;
+(function (AXPScreenSize) {
+    AXPScreenSize["Small"] = "small";
+    AXPScreenSize["Medium"] = "medium";
+    AXPScreenSize["Large"] = "large";
+})(AXPScreenSize || (AXPScreenSize = {}));
+/**
+ * Device Type Enum
+ */
+var AXPDeviceType;
+(function (AXPDeviceType) {
+    AXPDeviceType["Mobile"] = "mobile";
+    AXPDeviceType["Tablet"] = "tablet";
+    AXPDeviceType["Desktop"] = "desktop";
+})(AXPDeviceType || (AXPDeviceType = {}));
+//#endregion
+//#region ----   Helper Functions   ----
+/**
+ * Get the initial screen size based on window width
+ */
+const getScreenSize = () => {
+    const width = window.innerWidth;
+    if (width <= 600)
+        return AXPScreenSize.Small;
+    if (width <= 1024)
+        return AXPScreenSize.Medium;
+    return AXPScreenSize.Large;
+};
+/**
+ * Determine device type based on viewport width
+ */
+const getDeviceType = () => {
+    const width = window.innerWidth;
+    if (width <= 600) {
+        return AXPDeviceType.Mobile;
+    }
+    else if (width <= 1024) {
+        return AXPDeviceType.Tablet;
+    }
+    return AXPDeviceType.Desktop;
+};
+/**
+ * Determine if the device supports touch
+ */
+const isTouchDevice = () => {
+    return 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+};
+//#endregion
+//#region ----   Device Service   ----
+/**
+ * Injectable service that provides reactive device and screen size information.
+ * Monitors window resize events and updates signals accordingly.
+ */
+class AXPDeviceService {
+    //#endregion
+    //#region ----   Constructor & Lifecycle   ----
+    constructor() {
+        //#region ----   State Signals   ----
+        /**
+         * Current screen size (Small, Medium, Large)
+         */
+        this.screenSize = signal(getScreenSize(), ...(ngDevMode ? [{ debugName: "screenSize" }] : []));
+        /**
+         * Current device type (Mobile, Tablet, Desktop)
+         */
+        this.deviceType = signal(getDeviceType(), ...(ngDevMode ? [{ debugName: "deviceType" }] : []));
+        /**
+         * Whether the device supports touch input
+         */
+        this.isTouchDevice = signal(isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchDevice" }] : []));
+        //#endregion
+        //#region ----   Computed Signals   ----
+        /**
+         * Whether the screen size is Small
+         */
+        this.isSmall = computed(() => this.screenSize() === AXPScreenSize.Small, ...(ngDevMode ? [{ debugName: "isSmall" }] : []));
+        /**
+         * Whether the screen size is Medium
+         */
+        this.isMedium = computed(() => this.screenSize() === AXPScreenSize.Medium, ...(ngDevMode ? [{ debugName: "isMedium" }] : []));
+        /**
+         * Whether the screen size is Large
+         */
+        this.isLarge = computed(() => this.screenSize() === AXPScreenSize.Large, ...(ngDevMode ? [{ debugName: "isLarge" }] : []));
+        /**
+         * Whether the device is Mobile
+         */
+        this.isMobileDevice = computed(() => this.deviceType() === AXPDeviceType.Mobile, ...(ngDevMode ? [{ debugName: "isMobileDevice" }] : []));
+        /**
+         * Whether the device is Tablet
+         */
+        this.isTabletDevice = computed(() => this.deviceType() === AXPDeviceType.Tablet, ...(ngDevMode ? [{ debugName: "isTabletDevice" }] : []));
+        /**
+         * Whether the device is Desktop
+         */
+        this.isDesktopDevice = computed(() => this.deviceType() === AXPDeviceType.Desktop, ...(ngDevMode ? [{ debugName: "isDesktopDevice" }] : []));
+        /**
+         * Whether the device supports touch (alias for isTouchDevice)
+         */
+        this.isTouchScreen = computed(() => this.isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchScreen" }] : []));
+        //#endregion
+        //#region ----   Private Properties   ----
+        this._resizeListener = null;
+        this._setupResizeListener();
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Update screen size and device type based on window width
+     */
+    _updateScreenSize() {
+        const width = window.innerWidth;
+        let newScreenSize;
+        if (width <= 600) {
+            newScreenSize = AXPScreenSize.Small;
+        }
+        else if (width <= 1024) {
+            newScreenSize = AXPScreenSize.Medium;
+        }
+        else {
+            newScreenSize = AXPScreenSize.Large;
+        }
+        // Determine device type based on width to keep it reactive to devtools emulation
+        let newDeviceType;
+        if (width <= 600) {
+            newDeviceType = AXPDeviceType.Mobile;
+        }
+        else if (width <= 1024) {
+            newDeviceType = AXPDeviceType.Tablet;
+        }
+        else {
+            newDeviceType = AXPDeviceType.Desktop;
+        }
+        if (newScreenSize !== this.screenSize() || newDeviceType !== this.deviceType()) {
+            this.screenSize.set(newScreenSize);
+            this.deviceType.set(newDeviceType);
+        }
+    }
+    /**
+     * Set up event listener for window resize
+     */
+    _setupResizeListener() {
+        this._resizeListener = fromEvent(window, 'resize')
+            .pipe(debounceTime(250)) // 250ms debounce delay
+            .subscribe(() => {
+            this._updateScreenSize();
+        });
+    }
+    /**
+     * Remove event listener for window resize
+     */
+    _removeResizeListener() {
+        if (this._resizeListener) {
+            this._resizeListener.unsubscribe();
+            this._resizeListener = null;
+        }
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    /**
+     * Clean up resources when service is destroyed
+     */
+    destroy() {
+        this._removeResizeListener();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPDeviceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
 /**
  * Service for applying and resetting text highlighting within specified HTML elements.
  */
@@ -3402,10 +3869,22 @@ function extractTextFromHtml(value) {
     div.innerHTML = value;
     return div.textContent || div.innerText || '';
 }
+/**
+ * Generate kebab-case group name from title
+ */
+function generateKebabCase(title) {
+    return title
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '') // Remove special characters
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/-+/g, '-') // Replace multiple hyphens with single
+        .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
+}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPHookService, AXPImageUrlLogoConfig, AXPPlatformScope, AXPStatusDefinitionProviderService, AXPStatusProvider, AXPSystemActionType, AXPSystemActions, AXPSystemStatusType, AXPSystemStatuses, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_STATUS_PROVIDERS, AXP_TAG_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getStatusInfo, getSystemActions, getSystemStatus, objectKeyValueTransforms, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, resolveStatusLook, setSmart, systemStatusToDefinition };
+export { AXFullscreenDirective, AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPModuleManifestInitializer, AXPModuleManifestRegistry, AXPModuleProviderRegistry, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EDITION_SERVICE, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_ACCESS_CONTROL_SERVICE, AXP_MODULE_MANIFEST_PROVIDER, AXP_MODULE_PROVIDER_INITIALIZER, AXP_MODULE_PROVIDER_LOADER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, DefaultModuleAccessControlService, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
 //# sourceMappingURL=acorex-platform-core.mjs.map