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

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) {
@@ -790,6 +829,7 @@ class AXPDataSourceDefinitionProviderService {
     }
     async items() {
         const items = [];
+        // Load from DI tokens
         if (Array.isArray(this.providers)) {
             for (const provider of this.providers) {
                 set(provider, '__parent__', this);
@@ -966,6 +1006,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 +1682,289 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Provider Interfaces   ----
+/**
+ * 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 ----   Feature Definition Provider Interface   ----
+/**
+ * Context for feature definition providers.
+ * Allows providers to add additional feature definitions dynamically.
+ */
+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;
+    }
+}
+/**
+ * Injection token for feature definition providers.
+ */
+const AXP_FEATURE_DEFINITION_PROVIDER = new InjectionToken('AXP_FEATURE_DEFINITION_PROVIDER', {
+    providedIn: 'root',
+    factory: () => [],
+});
+//#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);
+        // Load and register features from all feature definition providers
+        await this.loadFeatureDefinitions();
+        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);
+    }
+    /**
+     * Load feature definitions from all registered feature definition providers.
+     * Features are automatically associated with modules based on the module name in the feature key.
+     */
+    async loadFeatureDefinitions() {
+        try {
+            const featureProviders = this.injector.get(AXP_FEATURE_DEFINITION_PROVIDER, []);
+            if (!featureProviders || featureProviders.length === 0) {
+                return;
+            }
+            const context = new AXPFeatureDefinitionProviderContext();
+            // Call all providers to collect features
+            for (const provider of featureProviders) {
+                if (provider instanceof Promise) {
+                    // If provider is a promise, resolve it
+                    const resolvedProvider = await provider;
+                    await resolvedProvider.provide(context);
+                }
+                else {
+                    // If provider is a direct instance, use it directly
+                    await provider.provide(context);
+                }
+            }
+            // Register all features and associate them with their modules
+            const features = context.getFeatures();
+            for (const [key, definition] of features.entries()) {
+                // Extract module name from key (format: ModuleName:FeatureKey)
+                const [moduleName, ...keyParts] = key.split(':');
+                const shortKey = keyParts.join(':');
+                // Verify that the module exists
+                if (!this.has(moduleName)) {
+                    console.warn(`Feature '${key}' references unknown module '${moduleName}'. Skipping.`);
+                    continue;
+                }
+                // Register feature definition
+                this.registerFeatureDefinition({
+                    ...definition,
+                    name: key,
+                    module: moduleName,
+                    key: shortKey,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to load feature definitions:', error);
+        }
+    }
+    //#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 AXP_FEATURE_DEFINITION_PROVIDER.
+     */
+    registerFeatureDefinition(definition) {
+        this.featureDefinitions.set(definition.name, definition);
+    }
+    //#endregion
+    //#region ----   Dependency Checking   ----
+    /**
+     * Check if module dependencies are satisfied.
+     * Returns array of missing dependencies.
+     * Dependencies can be module names or feature keys (ModuleName.FeatureKey format).
+     */
+    checkDependencies(moduleName) {
+        const manifest = this.get(moduleName);
+        if (!manifest?.dependencies || manifest.dependencies.length === 0) {
+            return { missingModules: [], missingFeatures: [] };
+        }
+        const missingModules = [];
+        const missingFeatures = [];
+        for (const dependency of manifest.dependencies) {
+            // If dependency contains a dot, it's a feature (ModuleName.FeatureKey)
+            if (dependency.includes('.')) {
+                // Convert dependency format (ModuleName.FeatureKey) to feature name format (ModuleName:Feature:FeatureKey)
+                const [moduleName, featureKey] = dependency.split('.');
+                const featureName = `${moduleName}:Feature:${featureKey}`;
+                if (!this.isFeatureDefined(featureName)) {
+                    missingFeatures.push(dependency);
+                }
+            }
+            else {
+                // Otherwise, it's a module name
+                if (!this.has(dependency)) {
+                    missingModules.push(dependency);
+                }
+            }
+        }
+        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 +1974,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 +2001,40 @@ const AXPAppStartUpProvider = provideAppInitializer(() => {
     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 ----   Imports   ----
 //#endregion
-
-//#region ----   Injection Token   ----
+//#region ----   Module   ----
 /**
- * Injection token for status providers
- * Use with multi: true to register multiple providers
+ * Module for managing module manifests initialization.
+ * Handles the registration of manifest startup tasks.
  */
-const AXP_STATUS_PROVIDERS = new InjectionToken('AXP_STATUS_PROVIDERS');
-//#endregion
-//#region ----   Provider Service   ----
-/**
- * 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);
- * }
- * ```
- */
-class AXPStatusDefinitionProviderService {
-    //#endregion
-    //#region ----   Constructor   ----
-    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);
-        }
-    }
-    //#endregion
-    //#region ----   Public API   ----
+class AXPModuleManifestModule {
     /**
-     * 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' }); }
-}
-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
- */
-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,
-    },
-});
-/**
- * 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
- */
-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'
-    };
-}
-/**
- * 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
- */
-function systemStatusToDefinition(statusType, overrides) {
-    const systemStatus = getSystemStatus(statusType);
-    if (!systemStatus) {
-        throw new Error(`System status ${statusType} not found`);
+     * @ignore
+     * Initializes module manifest tasks on module construction.
+     */
+    constructor(appInitService, injector) {
+        const manifestRegistry = injector.get(AXPModuleManifestRegistry);
+        // Register manifest initialization task
+        appInitService.registerTask({
+            name: 'ModuleManifests',
+            statusText: 'Loading module manifests...',
+            priority: 1, // Load early, before features/permissions
+            run: async () => {
+                await manifestRegistry.initialize();
+            },
+        });
     }
-    return {
-        ...systemStatus,
-        ...overrides,
-    };
+    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 }); }
 }
+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 ----   Tag Types   ----
 //#endregion
@@ -3007,6 +3144,12 @@ class AXPComponentLogoConfig {
         this.component = component;
     }
 }
+class AXPIconLogoConfig {
+    constructor(icon, color) {
+        this.icon = icon;
+        this.color = color;
+    }
+}
 
 var AXPPlatformScope;
 (function (AXPPlatformScope) {
@@ -3586,6 +3729,52 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+/**
+ * Creates a provider instance within an injection context.
+ * Handles dynamic import, injector resolution, and provider instantiation.
+ *
+ * @param loader - Function that returns a promise resolving to the provider class
+ * @returns Promise that resolves to the provider instance
+ *
+ * @example
+ * ```typescript
+ * useFactory: () => createProviderWithInjectionContext(() =>
+ *   import('./settings.provider').then(m => m.AXMSettingProvider)
+ * )
+ * ```
+ */
+async function createProviderWithInjectionContext(loader) {
+    const injector = inject(Injector);
+    const ProviderClass = await loader();
+    return runInInjectionContext(injector, () => new ProviderClass());
+}
+/**
+ * Creates a provider configuration for lazy-loaded providers with injection context.
+ * Simplifies provider registration in NgModule providers array.
+ *
+ * @param token - The injection token to provide
+ * @param loader - Function that returns a promise resolving to the provider class
+ * @param multi - Whether the provider is multi-provider (defaults to true)
+ * @returns Provider configuration object
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   provideLazyProvider(
+ *     AXP_SETTING_DEFINITION_PROVIDER,
+ *     () => import('./settings.provider').then(m => m.AXMSettingProvider)
+ *   )
+ * ]
+ * ```
+ */
+function provideLazyProvider(token, loader, multi = true) {
+    return {
+        provide: token,
+        useFactory: () => createProviderWithInjectionContext(loader),
+        multi,
+    };
+}
+
 function extractTextFromHtml(value) {
     const div = document.createElement('div');
     div.innerHTML = value;
@@ -3608,5 +3797,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, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, 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_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, createProviderWithInjectionContext, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, provideLazyProvider, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
 //# sourceMappingURL=acorex-platform-core.mjs.map