@acorex/platform 21.0.0-next.2 → 21.0.0-next.3

package/fesm2022/acorex-platform-core.mjs

@@ -1,5 +1,5 @@
 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, NgModule, 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, fromEvent } from 'rxjs';
@@ -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,6 +1814,218 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+//#region ----   Imports   ----
+//#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;
+    },
+});
+/**
+ * Injection token for module provider loader.
+ * Implementation: @acorex/platform/auth
+ */
+const AXP_MODULE_PROVIDER_LOADER = new InjectionToken('AXP_MODULE_PROVIDER_LOADER');
+/**
+ * Injection token for session service.
+ * Implementation: @acorex/platform/auth
+ */
+const AXP_SESSION_SERVICE = new InjectionToken('AXP_SESSION_SERVICE');
+/**
+ * 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 ----   Imports   ----
+//#endregion
+//#region ----   Registry Service   ----
+/**
+ * Registry service for module manifests.
+ * Collects and manages all registered module manifests.
+ */
+class AXPModuleManifestRegistry {
+    constructor() {
+        //#region ----   Fields   ----
+        this.manifests = new Map();
+        this.featureDefinitions = new Map();
+        this.injector = inject(Injector);
+        this.initializationPromise = null;
+        this.isInitialized = false;
+    }
+    //#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;
+    }
+    /**
+     * 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;
+    }
+    //#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);
+    }
+    /**
+     * 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: AXPModuleManifestRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXPAppStartUpService {
     constructor() {
         this.tasks = [];
@@ -1454,7 +2035,6 @@ class AXPAppStartUpService {
     }
     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();
         }
@@ -1482,422 +2062,121 @@ const AXPAppStartUpProvider = provideAppInitializer(() => {
     return initializerFn();
 });
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
 /**
- * Status Definition Types
- * Defines the structure for status definitions and their transitions
- */
-/**
- * Abstract class for status providers
- * Similar to AXPTaskBadgeProvider pattern
+ * Module for managing module manifests and providers initialization.
+ * Handles the registration of manifest and module provider startup tasks.
  */
-class AXPStatusProvider {
+class AXPModuleManifestModule {
+    /**
+     * @ignore
+     * Initializes module manifest and provider tasks on module construction.
+     */
+    constructor(appInitService, injector) {
+        const manifestRegistry = injector.get(AXPModuleManifestRegistry);
+        const moduleProviderLoader = injector.get(AXP_MODULE_PROVIDER_LOADER);
+        // Register manifest initialization task
+        appInitService.registerTask({
+            name: 'ModuleManifests',
+            statusText: 'Loading module manifests...',
+            priority: 1, // Load early, before features/permissions
+            run: async () => {
+                await manifestRegistry.initialize();
+            },
+        });
+        // Register module provider tasks
+        appInitService.registerTask({
+            name: 'RequiredModuleProviders',
+            statusText: 'Loading required modules...',
+            priority: 1.5,
+            run: async () => {
+                await moduleProviderLoader.loadRequiredModules();
+            },
+        });
+        appInitService.registerTask({
+            name: 'ModuleProviders',
+            statusText: 'Loading module providers...',
+            priority: 3,
+            run: async () => {
+                await moduleProviderLoader.loadProvidersIfReady();
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule, deps: [{ token: AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule }); }
 }
-//#endregion
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPModuleManifestModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [],
+                }]
+        }], ctorParameters: () => [{ type: AXPAppStartUpService }, { type: i0.Injector }] });
 
-//#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 ----   Feature Definition Provider Interface   ----
 /**
- * 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);
- * }
- * ```
+ * Context for feature definition providers.
+ * Allows providers to add additional feature definitions dynamically.
  */
-class AXPStatusDefinitionProviderService {
-    //#endregion
-    //#region ----   Constructor   ----
+class AXPFeatureDefinitionProviderContext {
     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);
-        }
+        this.features = new Map();
     }
-    //#endregion
-    //#region ----   Public API   ----
     /**
-     * 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' }); }
+     * 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;
+    }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPStatusDefinitionProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-
 /**
- * Standard system status types
- * These are the predefined status values used across the platform
+ * Injection token for feature definition providers.
  */
-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["Review"] = "review";
-})(AXPSystemStatusType || (AXPSystemStatusType = {}));
-const i18n$1 = (key) => `@general:statuses.${key}`;
-/**
- * Standard system status definitions
- * Provides consistent status definitions across the platform
- * Uses AXPStatusDefinition interface from status-definition.types.ts
- */
-const AXPSystemStatuses = Object.freeze({
-    Todo: {
-        name: AXPSystemStatusType.Todo,
-        title: i18n$1('todo.title'),
-        icon: 'fa-light fa-circle',
-        color: 'secondary',
-        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: 'info',
-        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: 'info',
-        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: 'danger',
-        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: 'success',
-        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: 'neutral',
-        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: 'neutral',
-        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: 'warning',
-        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: 'success',
-        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: 'primary',
-        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: 'neutral',
-        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: 'danger',
-        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: 'success',
-        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: 'secondary',
-        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: 'warning',
-        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: 'success',
-        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: 'neutral',
-        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: 'danger',
-        description: i18n$1('failed.description'),
-        order: 10,
-        isActive: true,
-        isInitial: false,
-        isFinal: true,
-    },
-    Review: {
-        name: AXPSystemStatusType.Review,
-        title: i18n$1('review.title'),
-        icon: 'fa-light fa-eye',
-        color: 'info',
-        description: i18n$1('review.description'),
-        order: 3,
-        isActive: true,
-    },
+const AXP_FEATURE_DEFINITION_PROVIDER = new InjectionToken('AXP_FEATURE_DEFINITION_PROVIDER', {
+    providedIn: 'root',
+    factory: () => [],
 });
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Default Implementation   ----
 /**
- * Get system status definition by type
- * @param type - Status type
- * @returns System status definition or undefined
- */
-function getSystemStatus(type) {
-    return Object.values(AXPSystemStatuses).find(status => status.name === type);
-}
-/**
- * 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
- */
-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: 'secondary',
-        icon: ''
-    };
-}
-/**
- * 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
+ * Default implementation of module access control service.
+ * Checks if module is enabled in edition.modulesAndFeatures.modules.
  */
-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: 'secondary'
-    };
+class DefaultModuleAccessControlService {
+    checkAccess(manifest, context) {
+        // Check if module is enabled in edition
+        const enabledModules = context.edition.modulesAndFeatures?.modules || [];
+        return enabledModules.includes(manifest.name);
+    }
+    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`);
-    }
-    return {
-        ...systemStatus,
-        ...overrides,
-    };
-}
+const AXP_MODULE_ACCESS_CONTROL_SERVICE = new InjectionToken('AXP_MODULE_ACCESS_CONTROL_SERVICE');
 
 //#region ----   Tag Types   ----
 //#endregion
@@ -3007,6 +3286,12 @@ class AXPComponentLogoConfig {
         this.component = component;
     }
 }
+class AXPIconLogoConfig {
+    constructor(icon, color) {
+        this.icon = icon;
+        this.color = color;
+    }
+}
 
 var AXPPlatformScope;
 (function (AXPPlatformScope) {
@@ -3608,5 +3893,5 @@ function generateKebabCase(title) {
  * Generated bundle index. Do not edit.
  */
 
-export { 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, AXPGridLayoutDirective, AXPHookService, AXPImageUrlLogoConfig, AXPPlatformScope, AXPScreenSize, 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, generateKebabCase, 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, AXPModuleManifestModule, 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_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