@acorex/platform 0.0.0-ACOREX

package/fesm2022/acorex-platform-core.mjs

@@ -0,0 +1,4374 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, Directive, computed, Injector, ChangeDetectionStrategy, Component, input, ElementRef, ViewContainerRef, signal, effect, runInInjectionContext, Optional, Inject, NgModule, EventEmitter, HostListener, Output, provideAppInitializer, ChangeDetectorRef, Pipe } from '@angular/core';
+import { get, isPlainObject, set, isNil, isEmpty, isArray, merge, isObjectLike, transform, isEqual, differenceWith, union, cloneDeep, has, sortBy, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import * as i1 from '@acorex/components/skeleton';
+import { AXSkeletonModule } from '@acorex/components/skeleton';
+import { Subject, merge as merge$1, of, interval, fromEvent } from 'rxjs';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXTranslationService } from '@acorex/core/translation';
+import { map, distinctUntilChanged, startWith, debounceTime } from 'rxjs/operators';
+import { AXCalendarService } from '@acorex/core/date-time';
+
+const AXP_ACTIVITY_LOG_PROVIDER = new InjectionToken('AXP_ACTIVITY_LOGS_PROVIDER');
+class AXPActivityLogService {
+    constructor() {
+        this.providers = inject(AXP_ACTIVITY_LOG_PROVIDER, { optional: true });
+    }
+    async getHistory(refId, refType, options) {
+        return (await Promise.all(this.providers?.map((p) => p.getHistory(refId, refType, options)) ?? [])).flat();
+    }
+    async getHistoryByIds(refId, refType, ids) {
+        return (await Promise.all(this.providers?.map((p) => p.getHistoryByIds(refId, refType, ids)) ?? [])).flat();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPActivityLogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPActivityLogProvider {
+}
+
+//#region ----   Color Palette Provider   ----
+/**
+ * Abstract class for color palette providers
+ * Implement this to provide palettes from different sources (system, app, module, etc.)
+ */
+class AXPColorPaletteProvider {
+}
+/**
+ * Injection token for color palette providers
+ * Use this to register multiple palette providers
+ */
+const AXP_COLOR_PALETTE_PROVIDER = new InjectionToken('AXP_COLOR_PALETTE_PROVIDER');
+//#endregion
+
+//#region ----   Color Palette Service   ----
+/**
+ * Service for managing color palettes from multiple providers
+ * Aggregates palettes from all registered providers
+ */
+class AXPColorPaletteService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_COLOR_PALETTE_PROVIDER, { optional: true }) ?? [];
+        //#endregion
+        //#region ----   State   ----
+        this.cache = null;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get all palettes from all providers
+     * @param options Filter options
+     * @returns Promise of palettes
+     */
+    async getPalettes(options) {
+        if (!this.cache) {
+            await this.loadPalettes();
+        }
+        let palettes = this.cache;
+        // Apply category filter
+        if (options?.category) {
+            palettes = palettes.filter((palette) => palette.category === options.category);
+        }
+        // Apply search filter
+        if (options?.search) {
+            const searchLower = options.search.toLowerCase();
+            palettes = palettes.filter((palette) => palette.name.toLowerCase().includes(searchLower) ||
+                palette.title.toLowerCase().includes(searchLower) ||
+                palette.description?.toLowerCase().includes(searchLower));
+        }
+        return palettes;
+    }
+    /**
+     * Get a palette by name
+     * @param name The unique name of the palette
+     * @returns Promise of palette or undefined if not found
+     */
+    async getPalette(name) {
+        if (!this.cache) {
+            await this.loadPalettes();
+        }
+        return this.cache.find((p) => p.name === name);
+    }
+    /**
+     * Get palettes by category
+     * @param category The category to filter by
+     * @returns Promise of palettes in the specified category
+     */
+    async getByCategory(category) {
+        return this.getPalettes({ category });
+    }
+    /**
+     * Check if a palette exists
+     * @param name The unique name of the palette
+     * @returns Promise of true if the palette exists
+     */
+    async has(name) {
+        const palette = await this.getPalette(name);
+        return palette !== undefined;
+    }
+    /**
+     * Reload palettes from all providers
+     */
+    async reload() {
+        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   ----
+    /**
+     * Load palettes from all providers
+     */
+    async loadPalettes() {
+        const allPalettes = [];
+        for (const provider of this.providers) {
+            try {
+                const palettes = await provider.provide();
+                allPalettes.push(...palettes);
+            }
+            catch (error) {
+                console.error(`Error loading palettes from provider ${provider.name}:`, error);
+            }
+        }
+        // Remove duplicates based on name
+        const uniquePalettes = allPalettes.filter((palette, index, self) => index === self.findIndex((p) => p.name === palette.name));
+        this.cache = uniquePalettes;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColorPaletteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----   Color Palette Types   ----
+//#endregion
+
+//#region ----   Default System Palettes Provider   ----
+/**
+ * Default system color palette provider
+ * Provides built-in color palettes
+ */
+class AXPDefaultColorPalettesProvider extends AXPColorPaletteProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'system';
+    }
+    async provide() {
+        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
+                ],
+            },
+            {
+                name: 'pastel',
+                title: 'Pastel Colors',
+                category: 'theme',
+                description: 'Soft pastel color palette',
+                colors: [
+                    '#FFB3BA', // Light Pink
+                    '#FFDFBA', // Light Peach
+                    '#FFFFBA', // Light Yellow
+                    '#BAFFC9', // Light Green
+                    '#BAE1FF', // Light Blue
+                    '#E0BBE4', // Light Purple
+                    '#FFDFD3', // Light Coral
+                    '#D4F1F4', // Light Cyan
+                ],
+            },
+            {
+                name: 'vibrant',
+                title: 'Vibrant Colors',
+                category: 'theme',
+                description: 'Bold and vibrant color palette',
+                colors: [
+                    '#FF6B6B', // Vibrant Red
+                    '#4ECDC4', // Vibrant Teal
+                    '#45B7D1', // Vibrant Blue
+                    '#FFA07A', // Vibrant Salmon
+                    '#98D8C8', // Vibrant Mint
+                    '#F7DC6F', // Vibrant Yellow
+                    '#BB8FCE', // Vibrant Purple
+                    '#85C1E2', // Vibrant Sky Blue
+                ],
+            },
+            {
+                name: 'earth-tones',
+                title: 'Earth Tones',
+                category: 'theme',
+                description: 'Natural earth tone color palette',
+                colors: [
+                    '#8B4513', // Saddle Brown
+                    '#A0522D', // Sienna
+                    '#D2691E', // Chocolate
+                    '#CD853F', // Peru
+                    '#DEB887', // Burlywood
+                    '#F5DEB3', // Wheat
+                    '#556B2F', // Dark Olive Green
+                    '#6B8E23', // Olive Drab
+                ],
+            },
+            {
+                name: 'monochrome',
+                title: 'Monochrome',
+                category: 'theme',
+                description: 'Grayscale color palette',
+                colors: [
+                    '#000000', // Black
+                    '#262626', // Very Dark Gray
+                    '#404040', // Dark Gray
+                    '#595959', // Medium Dark Gray
+                    '#737373', // Medium Gray
+                    '#8C8C8C', // Light Medium Gray
+                    '#A6A6A6', // Light Gray
+                    '#BFBFBF', // Very Light Gray
+                    '#D9D9D9', // Lighter Gray
+                    '#F2F2F2', // Almost White
+                    '#FFFFFF', // White
+                ],
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDefaultColorPalettesProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Column Width Provider   ----
+/**
+ * Injection token for column width providers
+ * Use this to register multiple column width providers with multi: true
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: AXP_COLUMN_WIDTH_PROVIDER,
+ *     useValue: {
+ *       matchers: [
+ *         { name: 'title', width: '300px', priority: 10 },
+ *         { widgetType: /text-box/i, width: '200px' }
+ *       ],
+ *       priority: 150
+ *     },
+ *     multi: true
+ *   }
+ * ]
+ * ```
+ */
+const AXP_COLUMN_WIDTH_PROVIDER = new InjectionToken('AXP_COLUMN_WIDTH_PROVIDER');
+//#endregion
+
+//#region ----   Column Width Service   ----
+/**
+ * Service for resolving column widths based on registered providers
+ * Supports matching by column name (priority) and widget type (fallback)
+ * Uses multi-provider pattern for extensibility
+ */
+class AXPColumnWidthService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.providers = inject(AXP_COLUMN_WIDTH_PROVIDER, {
+            optional: true,
+        }) ?? [];
+    }
+    //#region ----   Public Methods   ----
+    /**
+     * Resolve width for a column based on registered providers
+     * Only returns a width if column doesn't already have one set
+     *
+     * @param column Column to resolve width for
+     * @returns Resolved width string (normalized) or undefined if no match or column already has width
+     */
+    resolveWidth(column) {
+        // If column already has a width set, don't override
+        const existingWidth = column.width || column.options?.width;
+        if (existingWidth) {
+            return undefined;
+        }
+        // Get widget type from column (support both widget.type and showAs.type)
+        const widgetType = column.widget?.type || column.showAs?.type;
+        // Collect all matchers from all providers
+        const allMatchers = this.collectMatchers();
+        // Try name-based matches first (higher priority)
+        const nameMatch = this.findNameMatch(column.name, allMatchers);
+        if (nameMatch) {
+            return this.normalizeWidth(nameMatch.width);
+        }
+        // Fallback to widget-type matches (case-insensitive)
+        if (widgetType) {
+            const widgetMatch = this.findWidgetTypeMatch(widgetType, allMatchers);
+            if (widgetMatch) {
+                return this.normalizeWidth(widgetMatch.width);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Apply resolved width to a column (mutates the column)
+     * Only applies if column doesn't already have a width
+     *
+     * @param column Column to apply width to
+     * @returns true if width was applied, false if column already had width or no match found
+     */
+    applyWidth(column) {
+        const width = this.resolveWidth(column);
+        if (!width) {
+            return false;
+        }
+        // Apply to the appropriate property
+        if (column.options) {
+            column.options.width = width;
+        }
+        else {
+            column.width = width;
+        }
+        return true;
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Collect all matchers from all providers, sorted by provider priority and matcher priority
+     */
+    collectMatchers() {
+        const allMatchers = [];
+        for (const provider of this.providers) {
+            const providerPriority = provider.priority ?? 100;
+            for (const matcher of provider.matchers) {
+                allMatchers.push({
+                    matcher,
+                    providerPriority,
+                });
+            }
+        }
+        // Sort by provider priority (descending), then by matcher priority (descending)
+        allMatchers.sort((a, b) => {
+            if (a.providerPriority !== b.providerPriority) {
+                return b.providerPriority - a.providerPriority; // Higher priority first
+            }
+            const priorityA = a.matcher.priority ?? 0;
+            const priorityB = b.matcher.priority ?? 0;
+            return priorityB - priorityA; // Higher priority first
+        });
+        return allMatchers;
+    }
+    /**
+     * Find first matching matcher by column name
+     * Name matches take precedence over widget type matches
+     */
+    findNameMatch(columnName, allMatchers) {
+        for (const { matcher } of allMatchers) {
+            if (!matcher.name) {
+                continue; // Skip if no name matcher
+            }
+            if (typeof matcher.name === 'string') {
+                // Exact string match (case-sensitive for names)
+                if (matcher.name === columnName) {
+                    return matcher;
+                }
+            }
+            else if (matcher.name instanceof RegExp) {
+                // RegExp match
+                if (matcher.name.test(columnName)) {
+                    return matcher;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find first matching matcher by widget type (case-insensitive)
+     */
+    findWidgetTypeMatch(widgetType, allMatchers) {
+        const widgetTypeLower = widgetType.toLowerCase();
+        for (const { matcher } of allMatchers) {
+            if (!matcher.widgetType) {
+                continue; // Skip if no widget type matcher
+            }
+            if (typeof matcher.widgetType === 'string') {
+                // Case-insensitive string match
+                if (matcher.widgetType.toLowerCase() === widgetTypeLower) {
+                    return matcher;
+                }
+            }
+            else if (matcher.widgetType instanceof RegExp) {
+                // RegExp match (should already be case-insensitive if needed, but we'll test case-insensitively)
+                // Create a new regex with case-insensitive flag if not already present
+                let regex = matcher.widgetType;
+                if (!regex.flags.includes('i')) {
+                    regex = new RegExp(regex.source, regex.flags + 'i');
+                }
+                if (regex.test(widgetType)) {
+                    return matcher;
+                }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Normalize width value to string format
+     * Numbers are converted to pixels (e.g., 150 -> '150px')
+     * Strings are preserved as-is (supports any CSS unit)
+     */
+    normalizeWidth(width) {
+        if (typeof width === 'number') {
+            return `${width}px`;
+        }
+        return width;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPColumnWidthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----   Column Width Types   ----
+//#endregion
+
+//#region ----   Default Column Width Provider   ----
+/**
+ * Default column width configuration
+ * Migrated from DEFAULT_COLUMN_WIDTHS in column-width.middleware.ts
+ * Provides sensible defaults for common column names
+ */
+const defaultColumnWidthProvider = {
+    priority: 100,
+    matchers: [
+        // Priority: name-based matches (higher priority = more specific)
+        { name: 'code', width: '150px', priority: 10 },
+        { name: 'name', width: '250px', priority: 10 },
+        { name: 'title', width: '250px', priority: 10 },
+        { name: 'description', width: '350px', priority: 10 },
+        { name: 'note', width: '350px', priority: 10 },
+        { name: 'notes', width: '350px', priority: 10 },
+        { name: 'content', width: '500px', priority: 10 },
+        { name: 'level', width: '100px', priority: 10 },
+        { name: 'order', width: '100px', priority: 10 },
+        { name: 'phones', width: '300px', priority: 10 },
+        { name: 'emails', width: '300px', priority: 10 },
+    ],
+};
+//#endregion
+
+class AXPComponentSlot {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlot, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPComponentSlot, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlot, decorators: [{
+            type: Directive
+        }] });
+
+function extractNestedFieldsWildcard(obj, basePath, fields) {
+    const result = {};
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = get(obj, basePath);
+        return isPlainObject(fullObj) ? fullObj : {};
+    }
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const value = get(obj, fullPath);
+        set(result, field, value);
+    }
+    return result;
+}
+function setSmart(obj, smartPath, value) {
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    if (!fieldMatch) {
+        // Fix: If value is undefined and we're setting a nested property,
+        // check if the parent object exists and if setting this would result in
+        // all properties being undefined. If so, set the parent to null instead.
+        if (isNil(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = get(obj, parentPath);
+            // If parent is already null/undefined, don't recreate the object structure
+            if (isNil(parentObj)) {
+                return obj;
+            }
+            // Check if parent is a plain object (not array, not null)
+            if (isPlainObject(parentObj)) {
+                const existingKeys = Object.keys(parentObj);
+                // Check if all existing properties are null/undefined using lodash
+                const allNil = isEmpty(existingKeys) || existingKeys.every((key) => isNil(parentObj[key]));
+                if (allNil) {
+                    // Set parent to null instead of creating/keeping an object with all undefined properties
+                    set(obj, parentPath, null);
+                    return obj;
+                }
+            }
+        }
+        set(obj, smartPath, value);
+        // After setting, check again if parent should be null using lodash
+        if (isNil(value) && pathParts.length > 1) {
+            const parentPath = pathParts.slice(0, -1).join('.');
+            const parentObj = get(obj, parentPath);
+            if (isPlainObject(parentObj)) {
+                // Use lodash to check if all properties are null/undefined
+                const allNil = Object.keys(parentObj).every((key) => isNil(parentObj[key]));
+                if (allNil) {
+                    set(obj, parentPath, null);
+                }
+            }
+        }
+        return obj;
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const [arrayKey, ...restPath] = basePath.split('.');
+    // Make sure the array exists
+    if (!obj[arrayKey])
+        obj[arrayKey] = [];
+    // 🟡 Case A: value is array (normal set)
+    if (isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            const targetItem = obj[arrayKey][i] ?? {};
+            const nested = {};
+            if (restPath.length > 0) {
+                const picked = extractNestedFieldsWildcard(item, restPath.join('.'), fields);
+                set(nested, restPath.join('.'), picked);
+            }
+            else {
+                const picked = extractNestedFieldsWildcard(item, '', fields);
+                Object.assign(nested, picked);
+            }
+            obj[arrayKey][i] = merge({}, targetItem, nested);
+        }
+    }
+    // 🟢 Case B: value is a single value → broadcast
+    else {
+        for (let i = 0; i < obj[arrayKey].length; i++) {
+            const targetItem = obj[arrayKey][i] ?? {};
+            const nested = {};
+            if (restPath.length > 0) {
+                for (const field of fields) {
+                    set(nested, `${restPath.join('.')}.${field}`, value);
+                }
+            }
+            else {
+                for (const field of fields) {
+                    set(nested, field, value);
+                }
+            }
+            obj[arrayKey][i] = merge({}, targetItem, nested);
+        }
+    }
+    return obj;
+}
+function extractFieldsFromPath(obj, basePath, fields) {
+    if (fields.length === 1 && fields[0] === '*') {
+        const fullObj = basePath ? get(obj, basePath) : obj;
+        return isPlainObject(fullObj) ? fullObj : {};
+    }
+    const result = {};
+    for (const field of fields) {
+        const fullPath = basePath ? `${basePath}.${field}` : field;
+        const val = get(obj, fullPath);
+        if (val !== undefined) {
+            result[field] = val;
+        }
+    }
+    return result;
+}
+function getSmart(obj, smartPath) {
+    const pathParts = smartPath.split('.');
+    const lastPart = pathParts[pathParts.length - 1];
+    const fieldMatch = lastPart.match(/^\{(.+)\}$/);
+    // Simple get (no fields)
+    if (!fieldMatch) {
+        return get(obj, smartPath);
+    }
+    const fields = fieldMatch[1].split(',').map((f) => f.trim());
+    const basePath = pathParts.slice(0, -1).join('.');
+    const items = get(obj, basePath);
+    if (!isArray(items))
+        return [];
+    const nestedPath = basePath.includes('.') ? basePath.split('.').slice(1).join('.') : '';
+    return items.map((item) => {
+        return extractFieldsFromPath(item, nestedPath, fields);
+    });
+}
+function extractValue(value, key = 'id') {
+    if (isNil(value)) {
+        return null;
+    }
+    return isObjectLike(value) ? get(value, key) : value;
+}
+function cleanDeep(obj) {
+    return transform(obj, (result, value, key) => {
+        if (isObjectLike(value)) {
+            const cleaned = cleanDeep(value);
+            if (!isEmpty(cleaned)) {
+                result[key] = cleaned;
+            }
+        }
+        else if (!isNil(value) && // not null or undefined
+            !(typeof value === 'string' && value.trim() === '') && // not empty string
+            !(Array.isArray(value) && value.length === 0) // not empty array
+        ) {
+            result[key] = value;
+        }
+    });
+}
+function getDeepChanges(obj1, obj2) {
+    const changes = [];
+    function walk(o1, o2, currentPath = []) {
+        // If both values are deeply equal, skip
+        if (isEqual(o1, o2))
+            return;
+        const isObj1Nil = o1 === null || o1 === undefined;
+        const isObj2Nil = o2 === null || o2 === undefined;
+        // If obj1 is null/undefined and obj2 is not, treat entire obj2 as added
+        if (isObj1Nil && !isObj2Nil) {
+            if (isPlainObject(o2)) {
+                for (const key of Object.keys(o2)) {
+                    walk(undefined, o2[key], [...currentPath, key]);
+                }
+            }
+            else if (Array.isArray(o2)) {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: undefined,
+                    newValue: o2,
+                    arrayDiff: {
+                        added: o2,
+                        removed: [],
+                    },
+                });
+            }
+            else {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: undefined,
+                    newValue: o2,
+                });
+            }
+            return;
+        }
+        // If obj2 is null/undefined and obj1 is not, treat entire obj1 as removed
+        if (!isObj1Nil && isObj2Nil) {
+            if (isPlainObject(o1)) {
+                for (const key of Object.keys(o1)) {
+                    walk(o1[key], undefined, [...currentPath, key]);
+                }
+            }
+            else if (Array.isArray(o1)) {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: undefined,
+                    arrayDiff: {
+                        added: [],
+                        removed: o1,
+                    },
+                });
+            }
+            else {
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: undefined,
+                });
+            }
+            return;
+        }
+        // If both are arrays, compare items
+        if (Array.isArray(o1) && Array.isArray(o2)) {
+            if (!isEqual(o1, o2)) {
+                const added = differenceWith(o2, o1, isEqual);
+                const removed = differenceWith(o1, o2, isEqual);
+                changes.push({
+                    path: currentPath.join('.'),
+                    oldValue: o1,
+                    newValue: o2,
+                    arrayDiff: {
+                        added,
+                        removed,
+                    },
+                });
+            }
+            return;
+        }
+        // If both are plain objects, walk each key
+        if (isPlainObject(o1) && isPlainObject(o2)) {
+            const allKeys = union(Object.keys(o1), Object.keys(o2));
+            for (const key of allKeys) {
+                walk(o1[key], o2[key], [...currentPath, key]);
+            }
+            return;
+        }
+        // Primitive values or mismatched types
+        changes.push({
+            path: currentPath.join('.'),
+            oldValue: o1,
+            newValue: o2,
+        });
+    }
+    walk(obj1, obj2);
+    return changes;
+}
+// Method 1: Returns only changed paths
+function getChangedPaths(obj1, obj2) {
+    return getDeepChanges(obj1, obj2).map((change) => change.path);
+}
+// Method 2: Returns full change entries
+function getDetailedChanges(obj1, obj2) {
+    return getDeepChanges(obj1, obj2);
+}
+function getEnumValues(enumType) {
+    return Object.entries(enumType).map(([key, value]) => ({ id: value, title: key }));
+}
+
+class AXPContextChangeEvent {
+}
+//#endregion
+//#region ---- Context signal store ----
+// Shared reactive context: root injector has a default instance; widget/layout trees
+const AXPContextStore = signalStore(
+// Initial State
+withState(() => ({
+    data: {}, // Shared context data
+    state: 'initiated', // Current state
+    initialSnapshot: {}, // Snapshot of the first initialized state
+    previousSnapshot: {}, // Snapshot of the previous state
+    lastChange: {
+        state: 'initiated',
+    }, // Last change event
+})), 
+// Computed Signals
+withComputed(({ data, state, lastChange, initialSnapshot, previousSnapshot }) => ({
+    isChanged: computed(() => state() === 'changed'),
+    isReset: computed(() => state() === 'restored'),
+    isInitiated: computed(() => state() === 'initiated'),
+    isEmpty: computed(() => Object.keys(data()).length === 0),
+    isDirty: computed(() => !isEqual(data(), previousSnapshot())),
+    snapshot: computed(() => cloneDeep(data())), // Current data snapshot
+    initial: computed(() => cloneDeep(initialSnapshot())), // Initial snapshot
+    previous: computed(() => cloneDeep(previousSnapshot())), // Previous snapshot
+    changeEvent: computed(() => lastChange()), // Reactive last change event
+})), 
+// Methods for State Management
+withMethods((store) => ({
+    // Update a specific value
+    update(path, value) {
+        const currentData = cloneDeep(store.data());
+        const oldValue = getSmart(currentData, path);
+        // Skip if the value hasn't changed
+        if (isEqual(oldValue, value)) {
+            return;
+        }
+        // Update the value and prepare the change event
+        const updatedData = setSmart(currentData, path, value);
+        const changeEvent = {
+            oldValue,
+            newValue: value,
+            path,
+            state: 'changed',
+            data: updatedData,
+        };
+        // Patch the state
+        patchState(store, {
+            previousSnapshot: store.snapshot(), // Save the previous state
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+        });
+    },
+    patch(context, skipDirtyTracking = false) {
+        const currentData = cloneDeep(store.data());
+        // Update the value and prepare the change event
+        const updatedData = { ...currentData, ...context };
+        const changeEvent = {
+            state: 'patch',
+            data: updatedData,
+        };
+        // Patch the state
+        patchState(store, {
+            ...(skipDirtyTracking ? {} : { previousSnapshot: store.snapshot() }),
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+        });
+    },
+    // Reset to the initial state
+    reset() {
+        const initialData = store.initial();
+        const changeEvent = {
+            oldValue: cloneDeep(store.data()), // Current data becomes old value
+            newValue: cloneDeep(initialData), // Reset to the initial state
+            path: '',
+            state: 'restored',
+            data: initialData,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(), // Save the previous state
+            data: initialData,
+            state: 'restored',
+            lastChange: changeEvent,
+        });
+    },
+    // Initialize the state
+    set(initialData) {
+        const currentData = store.data();
+        if (isEqual(currentData, initialData)) {
+            return; // Skip if the current state matches the initial state
+        }
+        const changeEvent = {
+            oldValue: null,
+            newValue: cloneDeep(initialData),
+            path: '',
+            state: 'initiated',
+            data: initialData,
+        };
+        patchState(store, {
+            initialSnapshot: cloneDeep(initialData), // Save the initial state
+            previousSnapshot: store.snapshot(), // Save the current state as the previous
+            data: initialData,
+            state: 'initiated',
+            lastChange: changeEvent,
+        });
+    },
+    // Get a specific value
+    getValue(path) {
+        return getSmart(store.data(), path);
+    },
+    // Check if a path exists in the context
+    hasValue(path) {
+        return has(store.data(), path);
+    },
+})));
+//#endregion
+
+class AXPExpressionEvaluatorScopeProviderContext {
+    constructor() {
+        this.scopes = {};
+    }
+    addScope(namespace, functions) {
+        this.scopes[namespace] = { ...this.scopes[namespace], ...functions };
+    }
+    getScopes() {
+        return this.scopes;
+    }
+}
+const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER = new InjectionToken('AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER');
+class AXPExpressionEvaluatorScopeProviderService {
+    constructor() {
+        this.injector = inject(Injector);
+        this.cache = null;
+    }
+    async load() {
+        if (this.cache)
+            return;
+        const raw = this.injector.get(AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, [], { optional: true });
+        const providers = Array.isArray(raw)
+            ? raw
+            : typeof raw === 'function'
+                ? raw()
+                : [];
+        const context = new AXPExpressionEvaluatorScopeProviderContext();
+        for (const provider of providers) {
+            await provider.provide(context);
+        }
+        this.cache = context.getScopes();
+    }
+    async getScopesAsync() {
+        await this.load();
+        return this.cache || {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorScopeProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPExpressionEvaluatorService {
+    constructor() {
+        // Memoization cache for compiled expressions
+        this.expressionCache = new Map();
+        this.providerService = inject(AXPExpressionEvaluatorScopeProviderService);
+    }
+    getOrCompileFunction(expression) {
+        if (!this.expressionCache.has(expression)) {
+            // Check if expression contains multiple statements (has semicolons or newlines)
+            const hasMultipleStatements = expression.includes(';') || expression.includes('\n');
+            let fn;
+            if (hasMultipleStatements) {
+                // For multiple statements, execute them in sequence and return the last expression
+                fn = new Function('scope', `with (scope) { return (async function() { ${expression} })(); }`);
+            }
+            else {
+                // For single expressions, use return
+                fn = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
+            }
+            this.expressionCache.set(expression, fn);
+        }
+        return this.expressionCache.get(expression);
+    }
+    async getMergedScope(userScope) {
+        const pluginScopes = await this.providerService.getScopesAsync();
+        // Merge pluginScopes and userScope (userScope takes precedence)
+        return { ...pluginScopes, ...userScope };
+    }
+    async evaluate(source, scope = {}) {
+        try {
+            const mergedScope = await this.getMergedScope(scope);
+            if (typeof source === 'string' && source.includes('{{')) {
+                return await this.evaluateStringExpression(source, mergedScope);
+            }
+            else if (Array.isArray(source)) {
+                const evaluatedArray = [];
+                for (const item of source) {
+                    evaluatedArray.push(await this.evaluate(item, mergedScope));
+                }
+                return evaluatedArray;
+            }
+            else if (typeof source === 'object' && source !== null) {
+                const evaluatedObject = {};
+                for (const key in source) {
+                    if (source.hasOwnProperty(key)) {
+                        evaluatedObject[key] = await this.evaluate(source[key], mergedScope);
+                    }
+                }
+                return evaluatedObject;
+            }
+            else {
+                return source;
+            }
+        }
+        catch (error) {
+            console.error('Expression evaluator - Error evaluating expression:', source, error);
+            return false;
+        }
+    }
+    async evaluateStringExpression(templateExpression, scope) {
+        // Check if the input is exactly a single {{ ... }} expression (handle multiline)
+        const exactMatch = templateExpression.match(/^\s*\{\{\s*([\s\S]*?)\s*\}\}\s*$/);
+        if (exactMatch) {
+            const expression = exactMatch[1];
+            const sandbox = this.getOrCompileFunction(expression);
+            const result = await sandbox(scope);
+            return result;
+        }
+        // Otherwise, interpolate all {{ ... }} expressions in the string
+        const regex = /\{\{\s*([\s\S]*?)\s*\}\}/g;
+        // Collect all matches and their positions
+        const matches = [];
+        let match;
+        while ((match = regex.exec(templateExpression)) !== null) {
+            matches.push({
+                expression: match[1],
+                start: match.index,
+                end: regex.lastIndex,
+                raw: match[0],
+            });
+        }
+        // Evaluate all expressions in parallel
+        const values = await Promise.all(matches.map((m) => {
+            const sandbox = this.getOrCompileFunction(m.expression);
+            return sandbox(scope);
+        }));
+        // Reconstruct the string with evaluated values
+        let result = '';
+        let lastIndex = 0;
+        matches.forEach((m, i) => {
+            result += templateExpression.slice(lastIndex, m.start);
+            const value = values[i];
+            result += value !== undefined && value !== null ? value : '';
+            lastIndex = m.end;
+        });
+        result += templateExpression.slice(lastIndex);
+        return result;
+    }
+    isExpression(expression) {
+        if (typeof expression === 'string') {
+            return expression.trim().startsWith('{{') && expression.trim().endsWith('}}');
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPExpressionEvaluatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPComponentSlotPlaceholderComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotPlaceholderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.9", type: AXPComponentSlotPlaceholderComponent, isStandalone: true, selector: "axp-component-slot-placeholder", ngImport: i0, template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXSkeletonModule }, { kind: "component", type: i1.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotPlaceholderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-component-slot-placeholder',
+                    template: `<div>
+    <ax-skeleton class="ax-w-full ax-h-10 ax-rounded-md"></ax-skeleton>
+  </div>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXSkeletonModule],
+                    standalone: true,
+                }]
+        }] });
+
+class AXPComponentSlotRegistryService {
+    constructor() {
+        this.registry = new Map();
+    }
+    register(slotName, config) {
+        let configs = this.registry.get(slotName) || [];
+        // Check if the component is already registered in this slot
+        const isDuplicate = configs.some(existingConfig => existingConfig.name === config.name);
+        if (!isDuplicate) {
+            configs = [...configs, config]; // Add the new configuration
+            this.registry.set(slotName, configs);
+        }
+    }
+    get(slotName) {
+        return this.registry.get(slotName) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AXPComponentSlotDirective {
+    constructor() {
+        this.name = input.required(...(ngDevMode ? [{ debugName: "name" }] : /* istanbul ignore next */ []));
+        this.host = input(...(ngDevMode ? [undefined, { debugName: "host" }] : /* istanbul ignore next */ []));
+        this.context = input(...(ngDevMode ? [undefined, { debugName: "context" }] : /* istanbul ignore next */ []));
+        this.elementRef = inject(ElementRef);
+        this.registryService = inject(AXPComponentSlotRegistryService);
+        this.injector = inject(Injector);
+        this.evaluator = inject(AXPExpressionEvaluatorService);
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.contextStore = inject(AXPContextStore);
+        this.isEmpty = computed(() => this._viewCount() === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : /* istanbul ignore next */ []));
+        // Create a signal to store the count of children
+        this._viewCount = signal(0, ...(ngDevMode ? [{ debugName: "_viewCount" }] : /* istanbul ignore next */ []));
+        // Track component references for updates
+        this.componentRefs = [];
+        // Track placeholder references for replacement
+        this.placeholderRefs = new Map();
+        // Watch for context changes and update component instances
+        effect(() => {
+            const currentContext = this.context();
+            const currentHost = this.host();
+            // Update all component references with new context and host
+            this.componentRefs.forEach((componentRef) => {
+                if (componentRef.instance) {
+                    Object.assign(componentRef.instance, {
+                        host: currentHost,
+                        context: currentContext,
+                    });
+                }
+            });
+        });
+    }
+    async ngOnInit() {
+        await this.loadComponents();
+        // Update the signal after loading
+        this._viewCount.set(this.viewContainerRef.length);
+    }
+    async loadComponents() {
+        this.viewContainerRef.clear();
+        // Clear previous component references
+        this.componentRefs = [];
+        this.placeholderRefs.clear();
+        const configs = sortBy(this.registryService.get(this.name()), (c) => c.priority ?? 0);
+        if (!configs) {
+            console.error(`No component found for slot ${this.name()}`);
+            return;
+        }
+        // Evaluate conditions and check features in parallel for performance
+        const results = await Promise.all(configs.map(async (c) => {
+            // Check condition if provided
+            const conditionPassed = c.condition ? await this.evaluateCondition(c.condition) : true;
+            // Check features if provided
+            // const featuresPassed =
+            //   c.features && c.features.length > 0 ? this.sessionService.isFeatureEnabled(...c.features) : true;
+            return {
+                config: c,
+                // visible: conditionPassed && featuresPassed,
+                visible: conditionPassed,
+            };
+        }));
+        // Filter visible components while preserving priority order
+        const slots = results.filter((r) => r.visible).map((r) => r.config);
+        // Create skeleton placeholders immediately in priority order
+        slots.forEach((config, index) => {
+            const placeholderRef = this.viewContainerRef.createComponent(AXPComponentSlotPlaceholderComponent);
+            this.placeholderRefs.set(index, placeholderRef);
+        });
+        // Load all components in parallel and replace placeholders as they become ready
+        const loadPromises = slots.map(async (config, index) => {
+            let component;
+            let options = {};
+            // load component
+            if (typeof config.loadComponent === 'function') {
+                await runInInjectionContext(this.injector, async () => {
+                    component = await config.loadComponent?.();
+                });
+            }
+            else if (config.component) {
+                component = config.component;
+            }
+            // load options
+            if (typeof config.options === 'function') {
+                await runInInjectionContext(this.injector, async () => {
+                    const fun = config.options;
+                    options = await fun();
+                });
+            }
+            else if (config.options) {
+                options = await this.evaluator.evaluate(config.options, {});
+            }
+            // Replace placeholder with actual component as soon as it's ready
+            if (!component) {
+                console.warn(`Component failed to load for slot ${this.name()} at index ${index}`);
+                // Remove placeholder if component failed to load
+                const placeholderRef = this.placeholderRefs.get(index);
+                if (placeholderRef) {
+                    placeholderRef.destroy();
+                    this.placeholderRefs.delete(index);
+                }
+                return;
+            }
+            // Get the placeholder reference at this index
+            const placeholderRef = this.placeholderRefs.get(index);
+            if (!placeholderRef) {
+                console.warn(`Placeholder not found for index ${index}`);
+                return;
+            }
+            // Get the index of the placeholder in the view container
+            const placeholderIndex = this.viewContainerRef.indexOf(placeholderRef.hostView);
+            // Remove the placeholder
+            placeholderRef.destroy();
+            this.placeholderRefs.delete(index);
+            // Create the actual component at the same position
+            const componentRef = this.viewContainerRef.createComponent(component, { index: placeholderIndex });
+            // Store the component reference for future updates
+            this.componentRefs.push(componentRef);
+            Object.assign(componentRef.instance, {
+                host: this.host(),
+                context: this.context(),
+                ...options,
+            });
+        });
+        // Wait for all components to finish loading (they render as they become ready)
+        await Promise.all(loadPromises);
+    }
+    async evaluateCondition(condition) {
+        if (typeof condition === 'string') {
+            const result = await this.evaluator.evaluate(condition, {});
+            return result;
+        }
+        return condition(this.contextStore.data());
+        //return condition(this.context());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPComponentSlotDirective, isStandalone: false, selector: "axp-component-slot", inputs: { name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: true, transformFunction: null }, host: { classPropertyName: "host", publicName: "host", isSignal: true, isRequired: false, transformFunction: null }, context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["slot"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'axp-component-slot',
+                    standalone: false,
+                    exportAs: 'slot',
+                }]
+        }], ctorParameters: () => [], propDecorators: { name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: true }] }], host: [{ type: i0.Input, args: [{ isSignal: true, alias: "host", required: false }] }], context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: false }] }] } });
+
+class AXPComponentSlotModule {
+    static forRoot(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild(configs) {
+        return {
+            ngModule: AXPComponentSlotModule,
+            providers: [
+                {
+                    provide: 'AXPComponentSlotModuleFactory',
+                    useFactory: (registry) => () => {
+                        if (configs) {
+                            for (const [key, value] of Object.entries(configs)) {
+                                value.forEach(v => {
+                                    registry.register(key, v);
+                                });
+                            }
+                        }
+                    },
+                    deps: [AXPComponentSlotRegistryService],
+                    multi: true
+                }
+            ]
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach(f => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, deps: [{ token: 'AXPComponentSlotModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, declarations: [AXPComponentSlotDirective], exports: [AXPComponentSlotDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPComponentSlotModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXPComponentSlotDirective],
+                    exports: [AXPComponentSlotDirective]
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPComponentSlotModuleFactory']
+                }] }] });
+
+class AXPDataGenerator {
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const random = (Math.random() * 16) | 0;
+            const value = char === 'x' ? random : (random & 0x3) | 0x8;
+            return value.toString(16);
+        });
+    }
+    static number(...args) {
+        let min = 0;
+        let max = 100;
+        if (args.length == 1)
+            max = args[0];
+        if (args.length == 2) {
+            min = args[0];
+            max = args[1];
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    static date(...args) {
+        let start = new Date(2000, 0, 1);
+        let end = new Date();
+        if (args.length === 1) {
+            start = args[0];
+        }
+        else if (args.length === 2) {
+            start = args[0];
+            end = args[1];
+        }
+        const startTime = start.getTime();
+        const endTime = end.getTime();
+        return new Date(startTime + Math.random() * (endTime - startTime));
+    }
+    static array(length = 5, generator) {
+        return Array.from({ length }, generator);
+    }
+    static pick(...args) {
+        if (args.length < 1) {
+            throw new Error('Invalid parameters');
+        }
+        const items = args[0];
+        const count = args[1] ?? 1;
+        if (count < 1) {
+            throw new Error('Count must be at least 1');
+        }
+        // If the count is greater than the number of items, just return a shuffled copy of the array
+        if (count >= items.length) {
+            return [...items].sort(() => Math.random() - 0.5);
+        }
+        // Shuffle the array and slice the first 'count' elements
+        const shuffled = items.slice();
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]]; // Swap elements
+        }
+        return count == 1 ? shuffled.slice(0, count)[0] : shuffled.slice(0, count);
+    }
+    static string(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static boolean() {
+        return Math.random() >= 0.5;
+    }
+    static item(array = []) {
+        return array.length > 0 ? array[Math.floor(Math.random() * array.length)] : undefined;
+    }
+    static color(format = 'hex') {
+        // Generate HSL values with safe ranges for good contrast
+        const h = Math.floor(Math.random() * 360);
+        const s = Math.floor(Math.random() * 20) + 60; // 60% - 80%
+        const l = Math.floor(Math.random() * 20) + 40; // 40% - 60%
+        if (format === 'hsl') {
+            return `hsl(${h}, ${s}%, ${l}%)`;
+        }
+        // Convert HSL to RGB
+        const { r, g, b } = this.hslToRgb(h, s / 100, l / 100);
+        if (format === 'rgb') {
+            return `rgb(${r}, ${g}, ${b})`;
+        }
+        // Convert RGB to HEX
+        const toHex = (val) => val.toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    //TODO: move or read from utils
+    static hslToRgb(h, s, l) {
+        const c = (1 - Math.abs(2 * l - 1)) * s;
+        const x = c * (1 - Math.abs((h / 60) % 2 - 1));
+        const m = l - c / 2;
+        let r = 0, g = 0, b = 0;
+        if (h < 60)
+            [r, g, b] = [c, x, 0];
+        else if (h < 120)
+            [r, g, b] = [x, c, 0];
+        else if (h < 180)
+            [r, g, b] = [0, c, x];
+        else if (h < 240)
+            [r, g, b] = [0, x, c];
+        else if (h < 300)
+            [r, g, b] = [x, 0, c];
+        else
+            [r, g, b] = [c, 0, x];
+        return {
+            r: Math.round((r + m) * 255),
+            g: Math.round((g + m) * 255),
+            b: Math.round((b + m) * 255)
+        };
+    }
+    static alphanumeric(length = 10) {
+        const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static alphabet(length = 10) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    }
+    static phone() {
+        const areaCode = this.number(100, 999);
+        const exchangeCode = this.number(100, 999);
+        const lineNumber = this.number(1000, 9999);
+        return `${areaCode}-${exchangeCode}-${lineNumber}`;
+    }
+    static firstName() {
+        const firstNames = ['John', 'Allen', 'Jak', 'Rose', 'Kate', 'Liam', 'Olivia', 'Noah', 'Emma', 'Ava'];
+        return this.pick(firstNames);
+    }
+    static lastName() {
+        const lastNames = ['Gates', 'Jonsen', 'Smith', 'Ford', 'Jakson', 'Brown', 'Johnson', 'Williams', 'Jones', 'Garcia'];
+        return this.pick(lastNames);
+    }
+    static email(...args) {
+        const domains = ['gmail.com', 'yahoo.com', 'outlook.com', 'example.com'];
+        const domain = this.pick(domains);
+        const separator = this.pick(['.', '_', '']);
+        const randomSuffix = this.boolean() ? this.number(1, 99).toString() : '';
+        if (args.length === 2) {
+            const firstName = args[0].toLowerCase();
+            const lastName = args[1].toLowerCase();
+            return `${firstName}${separator}${lastName}${randomSuffix}@${domain}`;
+        }
+        else {
+            const firstName = this.firstName().toLowerCase();
+            const lastName = this.lastName().toLowerCase();
+            return `${firstName}${separator}${lastName}${randomSuffix}@${domain}`;
+        }
+    }
+    static country() {
+        const countries = ['USA', 'Canada', 'Mexico', 'Germany', 'France', 'Japan', 'Australia'];
+        return this.pick(countries);
+    }
+    static city() {
+        const cities = ['Los Angeles', 'Toronto', 'Vancouver', 'Berlin', 'Paris', 'Tokyo', 'Sydney'];
+        return this.pick(cities);
+    }
+    static state() {
+        const states = ['NY', 'CA', 'TX', 'ON', 'BC', 'NSW', 'BER', 'IDF', 'TYO'];
+        return this.pick(states);
+    }
+    static address() {
+        const streets = ['Main St', 'High St', 'Maple Ave', 'Oak St', 'Pine St', 'Cedar St'];
+        const streetNumber = this.number(100, 9999);
+        const street = this.pick(streets);
+        const city = this.city();
+        const state = this.state();
+        const zip = this.number(10000, 99999);
+        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) {
+    return {
+        getter: (value) => {
+            return extractValue(value, keyName);
+        },
+        setter: (value) => {
+            return extractValue(value, keyName);
+        },
+    };
+}
+
+const AXP_DATASOURCE_DEFINITION_PROVIDER = new InjectionToken('AXP_DATASOURCE_TYPE_PROVIDER');
+class AXPDataSourceDefinitionProviderService {
+    constructor() {
+        this.providers = inject(AXP_DATASOURCE_DEFINITION_PROVIDER, { optional: true });
+    }
+    async items() {
+        const items = [];
+        // Load from DI tokens; resolve lazy providers (provideLazyProvider uses useFactory that returns Promise<T>)
+        if (Array.isArray(this.providers)) {
+            for (const raw of this.providers) {
+                const provider = await Promise.resolve(raw);
+                if (provider && typeof provider.items === 'function') {
+                    set(provider, '__parent__', this);
+                    items.push(...(await provider.items()));
+                }
+            }
+        }
+        return items;
+    }
+    async get(name) {
+        return (await this.items()).find((c) => c.name == name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDataSourceDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+// src/app/directives/grid-layout.directive.ts
+class AXPContentCheckerDirective {
+    constructor() {
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.elementRef = inject((ElementRef));
+        this.isEmpty = computed(() => this.viewContainerRef.length === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContentCheckerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPContentCheckerDirective, isStandalone: true, selector: "[axp-content-checker]", exportAs: ["checker"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContentCheckerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-content-checker]',
+                    standalone: true,
+                    exportAs: 'checker'
+                }]
+        }] });
+
+class AXPDblClickDirective {
+    constructor() {
+        this.onDblClick = new EventEmitter();
+        this.lastTap = 0;
+        this.doubleTapThreshold = 300; // milliseconds
+    }
+    // Listen for the native dblclick event (desktop)
+    handleOnDblClick(event) {
+        this.onDblClick.emit(event);
+    }
+    // Listen for touchend events (mobile)
+    onTouchEnd(event) {
+        const currentTime = new Date().getTime();
+        const tapGap = currentTime - this.lastTap;
+        if (tapGap > 0 && tapGap < this.doubleTapThreshold) {
+            // Detected a double-tap
+            this.onDblClick.emit(event);
+            event.preventDefault(); // Optionally prevent further default actions
+        }
+        this.lastTap = currentTime;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDblClickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AXPDblClickDirective, isStandalone: true, selector: "[onDblClick]", outputs: { onDblClick: "onDblClick" }, host: { listeners: { "dblclick": "handleOnDblClick($event)", "touchend": "onTouchEnd($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDblClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[onDblClick]'
+                }]
+        }], propDecorators: { onDblClick: [{
+                type: Output
+            }], handleOnDblClick: [{
+                type: HostListener,
+                args: ['dblclick', ['$event']]
+            }], onTouchEnd: [{
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }] } });
+
+class AXPElementDataDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.data = input(null, { ...(ngDevMode ? { debugName: "data" } : /* istanbul ignore next */ {}), alias: 'axp-data' });
+        this.path = input('__data__', { ...(ngDevMode ? { debugName: "path" } : /* istanbul ignore next */ {}), alias: 'axp-data-path' });
+        // Effect to update element data when inputs change
+        this.updateEffect = effect(() => {
+            const currentData = this.data();
+            const currentPath = this.path();
+            set(this.elementRef.nativeElement, currentPath, currentData);
+        }, ...(ngDevMode ? [{ debugName: "updateEffect" }] : /* istanbul ignore next */ []));
+    }
+    ngOnInit() {
+        // Initial data setup
+        set(this.elementRef.nativeElement, this.path(), this.data());
+    }
+    /**
+     * Get data from the element
+     */
+    getData() {
+        return get(this.elementRef.nativeElement, this.path());
+    }
+    /**
+     * Update data at runtime
+     */
+    setData(data) {
+        set(this.elementRef.nativeElement, this.path(), data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPElementDataDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPElementDataDirective, isStandalone: true, selector: "[axp-data]", inputs: { data: { classPropertyName: "data", publicName: "axp-data", isSignal: true, isRequired: false, transformFunction: null }, path: { classPropertyName: "path", publicName: "axp-data-path", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPElementDataDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-data]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { data: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data", required: false }] }], path: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-data-path", required: false }] }] } });
+
+// src/app/directives/grid-layout.directive.ts
+class AXPGridLayoutDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.options = input.required({ ...(ngDevMode ? { debugName: "options" } : /* istanbul ignore next */ {}), alias: 'axp-grid-layout' });
+    }
+    ngOnChanges(changes) {
+        if (changes['options']) {
+            this.applyTailwindClasses();
+        }
+    }
+    applyTailwindClasses() {
+        const placement = this.options()?.positions;
+        if (!placement)
+            return;
+        // Clear existing grid classes
+        this.clearClasses();
+        // Apply new grid classes based on the input options
+        this.setClasses(placement.sm, '');
+        this.setClasses(placement.md, 'md:');
+        this.setClasses(placement.lg, 'lg:');
+        this.setClasses(placement.xl, 'xl:');
+        this.setClasses(placement.xxl, '2xl:');
+    }
+    setClasses(placement, prefix) {
+        if (placement == null)
+            return;
+        const colStart = placement.colStart ? `${prefix}ax-col-start-${placement.colStart}` : '';
+        const colEnd = placement.colEnd ? `${prefix}ax-col-end-${placement.colEnd}` : '';
+        const colSpan = placement.colSpan ? `${prefix}ax-col-span-${placement.colSpan}` : '';
+        const rowStart = placement.rowStart ? `${prefix}ax-row-start-${placement.rowStart}` : '';
+        const rowEnd = placement.rowEnd ? `${prefix}ax-row-end-${placement.rowEnd}` : '';
+        const rowSpan = placement.rowSpan ? `${prefix}ax-row-span-${placement.rowSpan}` : '';
+        const order = placement.order ? `${prefix}ax-order-${placement.order}` : ''; // Handling order
+        [colStart, colEnd, colSpan, rowStart, rowEnd, rowSpan, order].forEach(cls => {
+            if (cls) {
+                this.renderer.addClass(this.el.nativeElement, cls);
+            }
+        });
+    }
+    clearClasses() {
+        const currentClasses = this.el.nativeElement.className.split(' ');
+        currentClasses.forEach((className) => {
+            if (className.startsWith('ax-col-') || className.startsWith('ax-row-') || className.startsWith('ax-order-')) {
+                this.renderer.removeClass(this.el.nativeElement, className);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridLayoutDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: AXPGridLayoutDirective, isStandalone: true, selector: "[axp-grid-layout]", inputs: { options: { classPropertyName: "options", publicName: "axp-grid-layout", isSignal: true, isRequired: true, transformFunction: null } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGridLayoutDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axp-grid-layout]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { options: [{ type: i0.Input, args: [{ isSignal: true, alias: "axp-grid-layout", required: true }] }] } });
+
+const AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER = new InjectionToken('AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER');
+
+//#region ----   Imports   ----
+//#endregion
+class AXPDistributedEventListenerService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.listenerProviders = inject(AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, { optional: true }) || [];
+        this.injector = inject(Injector);
+        /** Cache for listeners by key. */
+        this.listenersByKey = new Map();
+        /** Flag to track if providers have been loaded */
+        this.providersLoaded = false;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Dispatches an event to all registered listeners for the given key.
+     * @param key The event key.
+     * @param data The event data to pass to listeners.
+     */
+    async dispatch(key, data) {
+        const providers = await this.resolveProviders();
+        const matched = providers.filter(p => p.key === key);
+        if (!matched.length) {
+            return;
+        }
+        for (const provider of matched) {
+            try {
+                await Promise.resolve(runInInjectionContext(this.injector, () => provider.execute(data)));
+            }
+            catch (err) {
+                console.error(`[AXPDistributedEventListenerService] Provider for key='${key}' failed`, err);
+            }
+        }
+    }
+    /**
+       * Dispatch with async response (first matching provider, with retry/timeout)
+       */
+    async dispatchAsync(key, data, options = {
+        timeout: 60_000,
+        retries: 3,
+        retryDelay: 1000,
+    }) {
+        const providers = await this.resolveProviders();
+        const matched = providers.filter(p => p.key === key);
+        if (!matched.length) {
+            throw new Error(`No provider found for key='${key}'`);
+        }
+        const attempt = (n) => {
+            return new Promise((resolve, reject) => {
+                let finished = false;
+                const timer = setTimeout(() => {
+                    if (!finished) {
+                        if (n < options.retries) {
+                            resolve(attempt(n + 1));
+                        }
+                        else {
+                            reject(new Error(`Timeout: no response for key='${key}' after ${options.retries} attempts.`));
+                        }
+                    }
+                }, options.timeout);
+                try {
+                    const provider = matched[0];
+                    const result = runInInjectionContext(this.injector, () => provider.execute(data));
+                    Promise.resolve(result)
+                        .then((r) => {
+                        finished = true;
+                        clearTimeout(timer);
+                        resolve(r);
+                    })
+                        .catch(err => {
+                        finished = true;
+                        clearTimeout(timer);
+                        reject(err);
+                    });
+                }
+                catch (err) {
+                    clearTimeout(timer);
+                    reject(err);
+                }
+            });
+        };
+        return attempt(0);
+    }
+    /**
+      * Resolve all providers (handle both direct provider and Promise<provider>)
+      */
+    async resolveProviders() {
+        return Promise.all(this.listenerProviders.map(p => p instanceof Promise ? p : Promise.resolve(p)));
+    }
+    /**
+     * Returns all listeners for a specific event key.
+     * @param key The event key.
+     * @returns Array of listeners for the key.
+     */
+    async getListeners(key) {
+        await this.ensureProvidersLoaded();
+        return this.listenersByKey.get(key) || [];
+    }
+    /**
+     * Returns all registered event keys.
+     * @returns Array of all event keys that have listeners.
+     */
+    async getRegisteredKeys() {
+        await this.ensureProvidersLoaded();
+        return Array.from(this.listenersByKey.keys());
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Ensures that all providers have been loaded and cached.
+     */
+    async ensureProvidersLoaded() {
+        if (this.providersLoaded) {
+            return;
+        }
+        // Resolve all providers
+        const resolvedProviders = await Promise.all(this.listenerProviders);
+        // Group listeners by key
+        for (const provider of resolvedProviders) {
+            if (provider) {
+                const existingListeners = this.listenersByKey.get(provider.key) || [];
+                existingListeners.push(provider);
+                this.listenersByKey.set(provider.key, existingListeners);
+            }
+        }
+        this.providersLoaded = true;
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /** Clears the listeners cache and forces reload on next access. */
+    clearListenersCache() {
+        this.listenersByKey.clear();
+        this.providersLoaded = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDistributedEventListenerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPBroadcastEventService {
+    constructor() {
+        this.eventSubjects = new Map();
+        this.pendingRequests = new Map();
+        this.multiTabEventHistory = new Set(); // Prevent duplicate processing of the same event
+        this.instanceId = AXPDataGenerator.uuid();
+        this.channel = new BroadcastChannel('platform_global_events');
+        // Handle incoming messages
+        this.channel.onmessage = (event) => {
+            const { type, payload, requestId, response, sourceId } = event.data;
+            // Prevent processing the same event multiple times (multi-tab synchronization)
+            if (requestId && this.multiTabEventHistory.has(requestId)) {
+                return;
+            }
+            if (requestId) {
+                this.multiTabEventHistory.add(requestId); // Store processed requestId
+                setTimeout(() => this.multiTabEventHistory.delete(requestId), 10000); // Cleanup after 10 sec
+            }
+            // Handle responses to pending requests
+            if (requestId && !isUndefined(response) && this.pendingRequests.has(requestId)) {
+                this.pendingRequests.get(requestId)(response);
+                this.pendingRequests.delete(requestId);
+                return;
+            }
+            // Handle normal broadcast events
+            // Ignore events originating from this same instance to avoid double-delivery
+            if (sourceId && sourceId === this.instanceId) {
+                return;
+            }
+            if (type && this.eventSubjects.has(type)) {
+                this.eventSubjects.get(type).next({ data: payload, requestId });
+            }
+        };
+    }
+    /**
+     * Publish an event without expecting a response
+     */
+    publish(type, payload) {
+        this.channel.postMessage({ type, payload, sourceId: this.instanceId });
+        // Local echo so same-tab listeners receive the event as well
+        if (this.eventSubjects.has(type)) {
+            this.eventSubjects.get(type).next({ data: payload });
+        }
+    }
+    /**
+     * Subscribe to an event
+     */
+    listen(type) {
+        if (!this.eventSubjects.has(type)) {
+            this.eventSubjects.set(type, new Subject());
+        }
+        return this.eventSubjects.get(type).asObservable();
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    unsubscribe(type) {
+        if (this.eventSubjects.has(type)) {
+            this.eventSubjects.get(type).complete();
+            this.eventSubjects.delete(type);
+        }
+    }
+    /**
+     * Send a message and wait for a response with retry logic
+     */
+    async sendAndWaitForResponse(type, payload, options = {
+        timeout: 60 * 60 * 1000,
+        retries: 3,
+        retryDelay: 1000,
+    }) {
+        const requestId = AXPDataGenerator.uuid();
+        const attemptRequest = (attempt) => {
+            return new Promise((resolve, reject) => {
+                this.pendingRequests.set(requestId, resolve);
+                this.channel.postMessage({ type, payload, requestId });
+                setTimeout(() => {
+                    if (this.pendingRequests.has(requestId)) {
+                        this.pendingRequests.delete(requestId);
+                        if (attempt < options.retries) {
+                            console.warn(`Retrying request '${type}' (${attempt + 1}/${options.retries})...`);
+                            resolve(attemptRequest(attempt + 1)); // Retry request
+                        }
+                        else {
+                            reject(new Error(`Timeout: No response received for event '${type}' after ${options.retries} attempts.`));
+                        }
+                    }
+                }, options.timeout);
+            });
+        };
+        return attemptRequest(0);
+    }
+    /**
+     * Respond to a request
+     */
+    respondToRequest(requestId, response) {
+        if (!requestId) {
+            console.warn('Invalid requestId. Cannot send response.');
+            return;
+        }
+        this.channel.postMessage({ requestId, response });
+    }
+    /**
+     * Cleanup when the service is destroyed
+     */
+    ngOnDestroy() {
+        this.channel.close();
+        // Complete all subjects
+        this.eventSubjects.forEach((subject) => subject.complete());
+        this.eventSubjects.clear();
+        // Reject all pending requests to avoid dangling promises
+        this.pendingRequests.forEach((resolve, requestId) => {
+            resolve(Promise.reject(new Error(`Service destroyed. Request ${requestId} was not completed.`)));
+        });
+        this.pendingRequests.clear();
+        // Cleanup multi-tab event history
+        this.multiTabEventHistory.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPBroadcastEventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class AXPHookService {
+    constructor() {
+        this.listenerProviders = inject(AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, { optional: true }) || [];
+        this.injector = inject(Injector);
+    }
+    /**
+     * Resolve all providers (handle both direct providers and Promise<provider>)
+     */
+    async resolveProviders() {
+        return Promise.all(this.listenerProviders.map(p => p instanceof Promise ? p : Promise.resolve(p)));
+    }
+    /**
+     * Fire sync hooks (fire-and-forget).
+     * All providers with the given key will be executed.
+     * Execution is not awaited.
+     */
+    fire(key, data) {
+        this.resolveProviders().then(providers => {
+            providers
+                .filter(p => p.key === key)
+                .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0))
+                .forEach(p => {
+                try {
+                    runInInjectionContext(this.injector, () => p.execute(data));
+                }
+                catch (err) {
+                    console.error(`[AXPHookService] Hook '${key}' failed`, err);
+                }
+            });
+        });
+    }
+    /**
+     * Run async hooks sequentially (waterfall).
+     * The output of each hook is passed as input to the next hook.
+     * Returns the final merged data after all hooks are executed.
+     */
+    async runAsync(key, initialData) {
+        const providers = (await this.resolveProviders())
+            .filter(p => p.key === key)
+            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        let data = initialData;
+        for (const p of providers) {
+            data = await Promise.resolve(runInInjectionContext(this.injector, () => p.execute(data)));
+        }
+        return data;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPHookService, decorators: [{
+            type: Injectable,
+            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: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Module manifests data source ----
+/**
+ * Registered module manifests for select widgets via dataSource name {@link MODULE_MANIFESTS_DATASOURCE_NAME}.
+ */
+const MODULE_MANIFESTS_DATASOURCE_NAME = 'platform-module-manifests';
+/**
+ * Data source definition for module names/titles from {@link AXPModuleManifestRegistry}.
+ */
+class AXPModuleManifestsDataSourceDefinition {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.manifestRegistry = inject(AXPModuleManifestRegistry);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        return [
+            {
+                name: MODULE_MANIFESTS_DATASOURCE_NAME,
+                title: 'Module manifests',
+                source: () => new AXDataSource({
+                    key: 'id',
+                    load: async () => {
+                        await this.manifestRegistry.initialize();
+                        const list = this.manifestRegistry.getAll().map((m) => ({
+                            id: m.name,
+                            title: m.title || m.name,
+                        }));
+                        return { items: list, total: list.length };
+                    },
+                    byKey: async (key) => {
+                        await this.manifestRegistry.initialize();
+                        const m = this.manifestRegistry.getAll().find((x) => x.name === key);
+                        return m ? { id: m.name, title: m.title || m.name } : undefined;
+                    },
+                    pageSize: 1000,
+                }),
+                columns: [
+                    {
+                        name: 'id',
+                        title: 'ID',
+                        datatype: 'string',
+                        type: 'text-editor',
+                    },
+                    {
+                        name: 'title',
+                        title: 'Title',
+                        datatype: 'string',
+                        type: 'text-editor',
+                    },
+                ],
+                filters: [
+                    {
+                        field: 'title',
+                        title: 'Title',
+                        operator: { type: 'equal' },
+                        widget: { type: 'text-editor' },
+                        filterType: { advance: true, inline: true },
+                    },
+                ],
+                textField: { name: 'title', title: 'Title' },
+                valueField: { name: 'id', title: 'ID' },
+            },
+        ];
+    }
+}
+//#endregion
+
+class AXPAppStartUpService {
+    constructor() {
+        this.tasks = [];
+    }
+    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: "21.2.9", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", 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 ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+/**
+ * Module for managing module manifests initialization.
+ * Handles the registration of manifest startup tasks.
+ */
+class AXPModuleManifestModule {
+    /**
+     * @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();
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule, deps: [{ token: AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPModuleManifestModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [],
+                }]
+        }], ctorParameters: () => [{ type: AXPAppStartUpService }, { type: i0.Injector }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Public API ----
+/**
+ * Resolves {@link AXPMultiLanguageString} to a single string for the given locale.
+ * Fallback order: `currentLocale` → `en-US` → first map value.
+ */
+function resolveMultiLanguageString(content, currentLocale) {
+    if (content == null || content === '') {
+        return '';
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (typeof content !== 'object' || Array.isArray(content)) {
+        return String(content);
+    }
+    const record = content;
+    const pick = record[currentLocale] ??
+        record['en-US'] ??
+        Object.values(record).find((v) => v != null);
+    if (pick == null || pick === '') {
+        return '';
+    }
+    if (typeof pick === 'string') {
+        return pick;
+    }
+    if (typeof pick === 'object' && pick !== null && !Array.isArray(pick)) {
+        return resolveMultiLanguageString(pick, currentLocale);
+    }
+    return String(pick);
+}
+/**
+ * Creates an {@link AXPMultiLanguageString} with `en-US` and `fa-IR` entries.
+ * Use for seed data, tests, and demos that supply English and Persian copy explicitly.
+ */
+function createMultiLanguageString(enUs, faIr) {
+    return { 'en-US': enUs, 'fa-IR': faIr };
+}
+/**
+ * True when there is no displayable text in any locale (plain string or ML map).
+ * Pure helper for predicates (e.g. default section detection); prefer widgets / pipes for display.
+ */
+function isEffectivelyEmptyLocalizedValue(value) {
+    if (value == null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return Object.values(record).every((v) => v == null || String(v).trim() === '');
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- AXPMultiLanguageStringResolverService ----
+/**
+ * Resolves {@link AXPMultiLanguageString} using the active app locale, and exposes
+ * {@link currentLocale$} for code that prefers an observable (e.g. manual subscriptions).
+ * Templates usually use {@link AXPResolveMultiLanguageStringPipe} instead.
+ */
+class AXPMultiLanguageStringResolverService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.translation = inject(AXTranslationService);
+        //#endregion
+        //#region ---- Locale stream ----
+        /**
+         * Emits the active locale on subscribe and whenever the language changes.
+         */
+        this.currentLocale$ = merge$1(of(this.translation.getActiveLang()), this.translation.langChanges$).pipe(map(() => this.translation.getActiveLang()), distinctUntilChanged());
+    }
+    //#endregion
+    //#region ---- Resolve ----
+    /**
+     * Resolves multi-language content for an optional locale (defaults to active).
+     */
+    resolve(content, locale) {
+        return resolveMultiLanguageString(content, locale ?? this.translation.getActiveLang());
+    }
+    /**
+     * Normalizes multi-language content to a locale map for editors (e.g. multi-language popup `values`).
+     * If `content` is already a locale-to-string map, returns a shallow copy.
+     * If it is a plain string or empty, wraps it as `{ [activeLocale]: text }`.
+     */
+    toLocaleMap(content, activeLocale) {
+        if (content && typeof content === 'object' && !Array.isArray(content)) {
+            return { ...content };
+        }
+        const txt = typeof content === 'string' ? content : '';
+        return { [activeLocale]: txt };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMultiLanguageStringResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMultiLanguageStringResolverService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPMultiLanguageStringResolverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- AXPResolveMultiLanguageStringPipe ----
+/**
+ * Resolves {@link AXPMultiLanguageString} via {@link AXPMultiLanguageStringResolverService}.
+ * Impure and subscribes to {@link AXPMultiLanguageStringResolverService#currentLocale$} so
+ * OnPush hosts (e.g. grid cells) still refresh when the language changes.
+ *
+ * Optional second argument: explicit locale (e.g. from a host `locale` input). When omitted or null/empty,
+ * the active language is used.
+ *
+ * @example
+ * ```html
+ * {{ value | axpResolveMultiLanguageString }}
+ * {{ value | axpResolveMultiLanguageString: locale() }}
+ * ```
+ */
+class AXPResolveMultiLanguageStringPipe {
+    constructor() {
+        this.resolver = inject(AXPMultiLanguageStringResolverService);
+        this.cdr = inject(ChangeDetectorRef);
+        this.localeSubscription = this.resolver.currentLocale$.subscribe(() => this.cdr.markForCheck());
+    }
+    transform(value, locale) {
+        const explicitLocale = locale != null && locale !== '' ? locale : undefined;
+        return this.resolver.resolve(value, explicitLocale);
+    }
+    ngOnDestroy() {
+        this.localeSubscription.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPResolveMultiLanguageStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPResolveMultiLanguageStringPipe, isStandalone: true, name: "axpResolveMultiLanguageString", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPResolveMultiLanguageStringPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'axpResolveMultiLanguageString',
+                    standalone: true,
+                    pure: false,
+                }]
+        }] });
+
+//#region ----   Tag Types   ----
+//#endregion
+
+//#region ----   Tag Provider   ----
+/**
+ * Abstract class for tag providers
+ * Implement this to provide tags from different sources (system, tenant, user, etc.)
+ */
+class AXPTagProvider {
+    /**
+     * Create a new tag (optional - not all providers support creation)
+     * @param tag Tag to create
+     * @returns Created tag with id
+     */
+    async create(tag) {
+        throw new Error(`Provider ${this.name} does not support tag creation`);
+    }
+    /**
+     * Update an existing tag (optional)
+     * @param tag Tag to update
+     * @returns Updated tag
+     */
+    async update(tag) {
+        throw new Error(`Provider ${this.name} does not support tag updates`);
+    }
+    /**
+     * Delete a tag (optional)
+     * @param id Tag id to delete
+     */
+    async delete(id) {
+        throw new Error(`Provider ${this.name} does not support tag deletion`);
+    }
+}
+/**
+ * Injection token for tag providers
+ * Use this to register multiple tag providers
+ */
+const AXP_TAG_PROVIDER = new InjectionToken('AXP_TAG_PROVIDER');
+//#endregion
+
+//#region ----   Tag Service   ----
+/**
+ * Service for managing tags from multiple providers
+ * Aggregates tags from all registered providers
+ */
+class AXPTagService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_TAG_PROVIDER, { optional: true }) ?? [];
+        //#endregion
+        //#region ----   State   ----
+        this.cache = null;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get all tags from all providers
+     * @param options Filter options
+     * @returns Promise of tags
+     */
+    async getTags(options) {
+        if (!this.cache) {
+            await this.loadTags();
+        }
+        let tags = this.cache;
+        // Apply scope filter
+        if (options?.scope && options.scope.length > 0) {
+            tags = tags.filter((tag) => tag.scope && options.scope.includes(tag.scope));
+        }
+        // Apply search filter
+        if (options?.search) {
+            const searchLower = options.search.toLowerCase();
+            tags = tags.filter((tag) => tag.title.toLowerCase().includes(searchLower) ||
+                tag.description?.toLowerCase().includes(searchLower));
+        }
+        return tags;
+    }
+    /**
+     * Create a new tag using the appropriate provider
+     * @param tag Tag to create
+     * @param providerName Provider to use (defaults to first writable provider)
+     * @returns Created tag
+     */
+    async createTag(tag, providerName) {
+        const provider = providerName
+            ? this.providers.find((p) => p.name === providerName)
+            : this.providers.find((p) => p.create);
+        if (!provider || !provider.create) {
+            throw new Error('No writable tag provider available');
+        }
+        const createdTag = await provider.create(tag);
+        // Invalidate cache
+        this.cache = null;
+        return createdTag;
+    }
+    /**
+     * Update an existing tag
+     * @param tag Tag to update
+     * @returns Updated tag
+     */
+    async updateTag(tag) {
+        const provider = this.providers.find((p) => p.name === tag.scope && p.update);
+        if (!provider || !provider.update) {
+            throw new Error(`No provider found for updating tag with scope: ${tag.scope}`);
+        }
+        const updatedTag = await provider.update(tag);
+        // Invalidate cache
+        this.cache = null;
+        return updatedTag;
+    }
+    /**
+     * Delete a tag
+     * @param tagId Tag id to delete
+     * @param scope Tag scope
+     */
+    async deleteTag(tagId, scope) {
+        const provider = this.providers.find((p) => p.name === scope && p.delete);
+        if (!provider || !provider.delete) {
+            throw new Error(`No provider found for deleting tag with scope: ${scope}`);
+        }
+        await provider.delete(tagId);
+        // Invalidate cache
+        this.cache = null;
+    }
+    /**
+     * Reload tags from all providers
+     */
+    async reload() {
+        this.cache = null;
+        await this.loadTags();
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Load tags from all providers
+     */
+    async loadTags() {
+        const allTags = [];
+        for (const provider of this.providers) {
+            try {
+                const tags = await provider.provide();
+                allTags.push(...tags);
+            }
+            catch (error) {
+                console.error(`Error loading tags from provider ${provider.name}:`, error);
+            }
+        }
+        // Remove duplicates based on title (case-insensitive)
+        const uniqueTags = allTags.filter((tag, index, self) => index === self.findIndex((t) => t.title.toLowerCase() === tag.title.toLowerCase()));
+        this.cache = uniqueTags;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPTagService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Additional suggested generic actions for future consideration:
+ *
+ * Data & Content Actions:
+ * - Search = 'search' - Search functionality
+ * - Filter = 'filter' - Apply filters
+ * - Sort = 'sort' - Sort data
+ * - Group = 'group' - Group data
+ * - Expand = 'expand' - Expand details
+ * - Collapse = 'collapse' - Collapse details
+ * - Pin = 'pin' - Pin to favorites
+ * - Bookmark = 'bookmark' - Bookmark item
+ * - Favorite = 'favorite' - Mark as favorite
+ * - Star = 'star' - Star rating
+ *
+ * Workflow Actions:
+ * - Start = 'start' - Start process/workflow
+ * - Stop = 'stop' - Stop process
+ * - Pause = 'pause' - Pause process
+ * - Resume = 'resume' - Resume process
+ * - Cancel = 'cancel' - Cancel operation
+ * - Complete = 'complete' - Mark as complete
+ * - Close = 'close' - Close item
+ * - Reopen = 'reopen' - Reopen closed item
+ * - Forward = 'forward' - Forward to next step
+ * - Back = 'back' - Go back
+ *
+ * Communication Actions:
+ * - Reply = 'reply' - Reply to message
+ * - Forward = 'forward' - Forward message
+ * - Notify = 'notify' - Send notification
+ * - Invite = 'invite' - Invite user
+ * - Join = 'join' - Join group/meeting
+ * - Leave = 'leave' - Leave group/meeting
+ *
+ * Security Actions:
+ * - Login = 'login' - User login
+ * - Logout = 'logout' - User logout
+ * - Block = 'block' - Block user/content
+ * - Unblock = 'unblock' - Unblock user/content
+ * - Ban = 'ban' - Ban user
+ * - Unban = 'unban' - Unban user
+ * - Verify = 'verify' - Verify identity
+ * - Authenticate = 'authenticate' - Authenticate
+ *
+ * File & Media Actions:
+ * - Open = 'open' - Open file
+ * - Save = 'save' - Save file
+ * - SaveAs = 'save-as' - Save as new file
+ * - Attach = 'attach' - Attach file
+ * - Detach = 'detach' - Detach file
+ * - Compress = 'compress' - Compress files
+ * - Extract = 'extract' - Extract archive
+ * - Convert = 'convert' - Convert format
+ * - Crop = 'crop' - Crop image
+ * - Resize = 'resize' - Resize image
+ *
+ * System Actions:
+ * - Sync = 'sync' - Synchronize data
+ * - Backup = 'backup' - Create backup
+ * - Restore = 'restore' - Restore from backup
+ * - Reset = 'reset' - Reset to defaults
+ * - Clear = 'clear' - Clear data
+ * - Optimize = 'optimize' - Optimize performance
+ * - Update = 'update' - Update system
+ * - Install = 'install' - Install component
+ * - Uninstall = 'uninstall' - Uninstall component
+ * - Enable = 'enable' - Enable feature
+ * - Disable = 'disable' - Disable feature
+ *
+ * Analytics & Monitoring:
+ * - Monitor = 'monitor' - Monitor activity
+ * - Track = 'track' - Track progress
+ * - Analyze = 'analyze' - Analyze data
+ * - Debug = 'debug' - Debug issue
+ * - Log = 'log' - View logs
+ * - Alert = 'alert' - Set alert
+ * - Dashboard = 'dashboard' - View dashboard
+ * - Metrics = 'metrics' - View metrics
+ *
+ * Collaboration Actions:
+ * - Collaborate = 'collaborate' - Start collaboration
+ * - Share = 'share' - Share content
+ * - Comment = 'comment' - Add comment
+ * - Like = 'like' - Like content
+ * - Follow = 'follow' - Follow user/content
+ * - Subscribe = 'subscribe' - Subscribe to updates
+ * - Unsubscribe = 'unsubscribe' - Unsubscribe
+ * - Rate = 'rate' - Rate content
+ * - Review = 'review' - Review content
+ * - Recommend = 'recommend' - Recommend content
+ */
+var AXPSystemActionType;
+(function (AXPSystemActionType) {
+    AXPSystemActionType["View"] = "view";
+    AXPSystemActionType["Create"] = "create";
+    AXPSystemActionType["Update"] = "update";
+    AXPSystemActionType["Delete"] = "delete";
+    AXPSystemActionType["Approve"] = "approve";
+    AXPSystemActionType["Reject"] = "reject";
+    AXPSystemActionType["Submit"] = "submit";
+    AXPSystemActionType["Export"] = "export";
+    AXPSystemActionType["Import"] = "import";
+    AXPSystemActionType["Print"] = "print";
+    AXPSystemActionType["Assign"] = "assign";
+    AXPSystemActionType["Lock"] = "lock";
+    AXPSystemActionType["Unlock"] = "unlock";
+    AXPSystemActionType["Share"] = "share";
+    AXPSystemActionType["Configure"] = "configure";
+    AXPSystemActionType["Reorder"] = "reorder";
+    AXPSystemActionType["Preview"] = "preview";
+    AXPSystemActionType["Duplicate"] = "duplicate";
+    AXPSystemActionType["Archive"] = "archive";
+    AXPSystemActionType["Publish"] = "publish";
+    AXPSystemActionType["Unpublish"] = "unpublish";
+    AXPSystemActionType["Upload"] = "upload";
+    AXPSystemActionType["Download"] = "download";
+    AXPSystemActionType["Copy"] = "copy";
+    AXPSystemActionType["Move"] = "move";
+    AXPSystemActionType["Rename"] = "rename";
+    AXPSystemActionType["Restore"] = "restore";
+    AXPSystemActionType["Manage"] = "manage";
+    AXPSystemActionType["Info"] = "info";
+    AXPSystemActionType["Confirm"] = "confirm";
+    AXPSystemActionType["Design"] = "design";
+    AXPSystemActionType["VersionHistory"] = "version-history";
+    AXPSystemActionType["Compare"] = "compare";
+    AXPSystemActionType["Comments"] = "comments";
+    AXPSystemActionType["Sign"] = "sign";
+    AXPSystemActionType["Setup"] = "setup";
+    AXPSystemActionType["Send"] = "send";
+    AXPSystemActionType["Report"] = "report";
+    AXPSystemActionType["Sent"] = "sent";
+    AXPSystemActionType["Review"] = "review";
+    AXPSystemActionType["Generate"] = "generate";
+    AXPSystemActionType["Refresh"] = "refresh";
+    AXPSystemActionType["Reload"] = "reload";
+    AXPSystemActionType["Search"] = "search";
+    AXPSystemActionType["Filter"] = "filter";
+    AXPSystemActionType["Sort"] = "sort";
+    AXPSystemActionType["Start"] = "start";
+    AXPSystemActionType["Stop"] = "stop";
+    AXPSystemActionType["Pause"] = "pause";
+    AXPSystemActionType["Cancel"] = "cancel";
+    AXPSystemActionType["Close"] = "close";
+    AXPSystemActionType["Complete"] = "complete";
+    AXPSystemActionType["Save"] = "save";
+    AXPSystemActionType["SaveAs"] = "save-as";
+    AXPSystemActionType["Sync"] = "sync";
+    AXPSystemActionType["Reset"] = "reset";
+    AXPSystemActionType["Clear"] = "clear";
+    AXPSystemActionType["Distribution"] = "distribution";
+})(AXPSystemActionType || (AXPSystemActionType = {}));
+const i18n = (key) => `@general:actions.${key}`;
+const AXPSystemActions = Object.freeze({
+    View: {
+        key: AXPSystemActionType.View,
+        title: i18n('view.title'),
+        icon: 'fa-light fa-eye',
+        color: 'primary',
+        descriptions: {
+            title: i18n('view.title'),
+            tooltip: i18n('view.description'),
+            permission: i18n('view.permission'),
+            audit: i18n('view.audit')
+        }
+    },
+    Create: {
+        key: AXPSystemActionType.Create,
+        title: i18n('create.title'),
+        icon: 'fa-light fa-plus',
+        color: 'primary',
+        descriptions: {
+            title: i18n('create.title'),
+            tooltip: i18n('create.description'),
+            permission: i18n('create.permission'),
+            audit: i18n('create.audit')
+        }
+    },
+    Edit: {
+        key: AXPSystemActionType.Update,
+        title: i18n('edit.title'),
+        icon: 'fa-light fa-pen',
+        color: 'default',
+        descriptions: {
+            title: i18n('edit.title'),
+            tooltip: i18n('edit.description'),
+            permission: i18n('edit.permission'),
+            audit: i18n('edit.audit')
+        }
+    },
+    Delete: {
+        key: AXPSystemActionType.Delete,
+        title: i18n('delete.title'),
+        icon: 'fa-light fa-trash',
+        color: 'danger',
+        critical: true,
+        descriptions: {
+            title: i18n('delete.title'),
+            tooltip: i18n('delete.description'),
+            permission: i18n('delete.permission'),
+            audit: i18n('delete.audit')
+        }
+    },
+    Approve: {
+        key: AXPSystemActionType.Approve,
+        title: i18n('approve.title'),
+        icon: 'fa-light fa-circle-check',
+        color: 'success',
+        critical: true,
+        descriptions: {
+            title: i18n('approve.title'),
+            tooltip: i18n('approve.description'),
+            permission: i18n('approve.permission'),
+            audit: i18n('approve.audit')
+        }
+    },
+    Submit: {
+        key: AXPSystemActionType.Submit,
+        title: i18n('submit.title'),
+        icon: 'fa-light fa-paper-plane',
+        color: 'primary',
+        descriptions: {
+            title: i18n('submit.title'),
+            tooltip: i18n('submit.description'),
+            permission: i18n('submit.permission'),
+            audit: i18n('submit.audit')
+        }
+    },
+    Reject: {
+        key: AXPSystemActionType.Reject,
+        title: i18n('reject.title'),
+        icon: 'fa-light fa-ban',
+        color: 'danger',
+        critical: true,
+        descriptions: {
+            title: i18n('reject.title'),
+            tooltip: i18n('reject.description'),
+            permission: i18n('reject.permission'),
+            audit: i18n('reject.audit')
+        }
+    },
+    Export: {
+        key: AXPSystemActionType.Export,
+        title: i18n('export.title'),
+        icon: 'fa-light fa-download',
+        color: 'default',
+        descriptions: {
+            title: i18n('export.title'),
+            tooltip: i18n('export.description'),
+            permission: i18n('export.permission'),
+            audit: i18n('export.audit')
+        }
+    },
+    Import: {
+        key: AXPSystemActionType.Import,
+        title: i18n('import.title'),
+        icon: 'fa-light fa-upload',
+        color: 'default',
+        descriptions: {
+            title: i18n('import.title'),
+            tooltip: i18n('import.description'),
+            permission: i18n('import.permission'),
+            audit: i18n('import.audit')
+        }
+    },
+    Print: {
+        key: AXPSystemActionType.Print,
+        title: i18n('print.title'),
+        icon: 'fa-light fa-print',
+        color: 'default',
+        descriptions: {
+            title: i18n('print.title'),
+            tooltip: i18n('print.description'),
+            permission: i18n('print.permission'),
+            audit: i18n('print.audit')
+        }
+    },
+    Duplicate: {
+        key: AXPSystemActionType.Duplicate,
+        title: i18n('duplicate.title'),
+        icon: 'fa-light fa-clone',
+        color: 'warning',
+        descriptions: {
+            title: i18n('duplicate.title'),
+            tooltip: i18n('duplicate.description'),
+            permission: i18n('duplicate.permission'),
+            audit: i18n('duplicate.audit')
+        }
+    },
+    Archive: {
+        key: AXPSystemActionType.Archive,
+        title: i18n('archive.title'),
+        icon: 'fa-light fa-box-archive',
+        color: 'default',
+        descriptions: {
+            title: i18n('archive.title'),
+            tooltip: i18n('archive.description'),
+            permission: i18n('archive.permission'),
+            audit: i18n('archive.audit')
+        }
+    },
+    Restore: {
+        key: AXPSystemActionType.Restore,
+        title: i18n('restore.title'),
+        icon: 'fa-light fa-arrow-rotate-left',
+        color: 'default',
+        descriptions: {
+            title: i18n('restore.title'),
+            tooltip: i18n('restore.description'),
+            permission: i18n('restore.permission'),
+            audit: i18n('restore.audit')
+        }
+    },
+    Assign: {
+        key: AXPSystemActionType.Assign,
+        title: i18n('assign.title'),
+        icon: 'fa-light fa-user-plus',
+        color: 'primary',
+        descriptions: {
+            title: i18n('assign.title'),
+            tooltip: i18n('assign.description'),
+            permission: i18n('assign.permission'),
+            audit: i18n('assign.audit')
+        }
+    },
+    Lock: {
+        key: AXPSystemActionType.Lock,
+        title: i18n('lock.title'),
+        icon: 'fa-light fa-lock',
+        color: 'warning',
+        descriptions: {
+            title: i18n('lock.title'),
+            tooltip: i18n('lock.description'),
+            permission: i18n('lock.permission'),
+            audit: i18n('lock.audit')
+        }
+    },
+    Unlock: {
+        key: AXPSystemActionType.Unlock,
+        title: i18n('unlock.title'),
+        icon: 'fa-light fa-unlock',
+        color: 'success',
+        descriptions: {
+            title: i18n('unlock.title'),
+            tooltip: i18n('unlock.description'),
+            permission: i18n('unlock.permission'),
+            audit: i18n('unlock.audit')
+        }
+    },
+    Share: {
+        key: AXPSystemActionType.Share,
+        title: i18n('share.title'),
+        icon: 'fa-light fa-share-nodes',
+        color: 'info',
+        descriptions: {
+            title: i18n('share.title'),
+            tooltip: i18n('share.description'),
+            permission: i18n('share.permission'),
+            audit: i18n('share.audit')
+        }
+    },
+    Configure: {
+        key: AXPSystemActionType.Configure,
+        title: i18n('configure.title'),
+        icon: 'fa-light fa-sliders',
+        color: 'primary',
+        descriptions: {
+            title: i18n('configure.title'),
+            tooltip: i18n('configure.description'),
+            permission: i18n('configure.permission'),
+            audit: i18n('configure.audit')
+        }
+    },
+    Reorder: {
+        key: AXPSystemActionType.Reorder,
+        title: i18n('reorder.title'),
+        icon: 'fa-light fa-arrow-down-up-across-line',
+        color: 'default',
+        descriptions: {
+            title: i18n('reorder.title'),
+            tooltip: i18n('reorder.description'),
+            permission: i18n('reorder.permission'),
+            audit: i18n('reorder.audit')
+        }
+    },
+    Preview: {
+        key: AXPSystemActionType.Preview,
+        title: i18n('preview.title'),
+        icon: 'fa-light fa-magnifying-glass',
+        color: 'default',
+        descriptions: {
+            title: i18n('preview.title'),
+            tooltip: i18n('preview.description'),
+            permission: i18n('preview.permission'),
+            audit: i18n('preview.audit')
+        }
+    },
+    Publish: {
+        key: AXPSystemActionType.Publish,
+        title: i18n('publish.title'),
+        icon: 'fa-light fa-globe',
+        color: 'success',
+        descriptions: {
+            title: i18n('publish.title'),
+            tooltip: i18n('publish.description'),
+            permission: i18n('publish.permission'),
+            audit: i18n('publish.audit')
+        }
+    },
+    Unpublish: {
+        key: AXPSystemActionType.Unpublish,
+        title: i18n('unpublish.title'),
+        icon: 'fa-light fa-globe-slash',
+        color: 'danger',
+        descriptions: {
+            title: i18n('unpublish.title'),
+            tooltip: i18n('unpublish.description'),
+            permission: i18n('unpublish.permission'),
+            audit: i18n('unpublish.audit')
+        }
+    },
+    Upload: {
+        key: AXPSystemActionType.Upload,
+        title: i18n('upload.title'),
+        icon: 'fa-light fa-upload',
+        color: 'default',
+        descriptions: {
+            title: i18n('upload.title'),
+            tooltip: i18n('upload.description'),
+            permission: i18n('upload.permission'),
+            audit: i18n('upload.audit')
+        }
+    },
+    Download: {
+        key: AXPSystemActionType.Download,
+        title: i18n('download.title'),
+        icon: 'fa-light fa-download',
+        color: 'default',
+        descriptions: {
+            title: i18n('download.title'),
+            tooltip: i18n('download.description'),
+            permission: i18n('download.permission'),
+            audit: i18n('download.audit')
+        }
+    },
+    Copy: {
+        key: AXPSystemActionType.Copy,
+        title: i18n('copy.title'),
+        icon: 'fa-light fa-copy',
+        color: 'default',
+        descriptions: {
+            title: i18n('copy.title'),
+            tooltip: i18n('copy.description'),
+            permission: i18n('copy.permission'),
+            audit: i18n('copy.audit')
+        }
+    },
+    Move: {
+        key: AXPSystemActionType.Move,
+        title: i18n('move.title'),
+        icon: 'fa-light fa-arrow-right-arrow-left',
+        color: 'default',
+        descriptions: {
+            title: i18n('move.title'),
+            tooltip: i18n('move.description'),
+            permission: i18n('move.permission'),
+            audit: i18n('move.audit')
+        }
+    },
+    Rename: {
+        key: AXPSystemActionType.Rename,
+        title: i18n('rename.title'),
+        icon: 'fa-light fa-pen',
+        color: 'default',
+        descriptions: {
+            title: i18n('rename.title'),
+            tooltip: i18n('rename.description'),
+            permission: i18n('rename.permission'),
+            audit: i18n('rename.audit')
+        }
+    },
+    Manage: {
+        key: AXPSystemActionType.Manage,
+        title: i18n('manage.title'),
+        icon: 'fa-light fa-gear',
+        color: 'default',
+        descriptions: {
+            title: i18n('manage.title'),
+            tooltip: i18n('manage.description'),
+            permission: i18n('manage.permission'),
+            audit: i18n('manage.audit')
+        }
+    },
+    Info: {
+        key: AXPSystemActionType.Info,
+        title: i18n('info.title'),
+        icon: 'fa-light fa-info',
+        color: 'default',
+        descriptions: {
+            title: i18n('info.title'),
+            tooltip: i18n('info.description'),
+            permission: i18n('info.permission'),
+            audit: i18n('info.audit')
+        }
+    },
+    Confirm: {
+        key: AXPSystemActionType.Confirm,
+        title: i18n('confirm.title'),
+        icon: 'fa-light fa-check',
+        color: 'success',
+        descriptions: {
+            title: i18n('confirm.title'),
+            tooltip: i18n('confirm.description'),
+            permission: i18n('confirm.permission'),
+            audit: i18n('confirm.audit')
+        }
+    },
+    Design: {
+        key: AXPSystemActionType.Design,
+        title: i18n('design.title'),
+        icon: 'fa-light fa-paintbrush',
+        color: 'default',
+        descriptions: {
+            title: i18n('design.title'),
+            tooltip: i18n('design.description'),
+            permission: i18n('design.permission'),
+            audit: i18n('design.audit')
+        }
+    },
+    VersionHistory: {
+        key: AXPSystemActionType.VersionHistory,
+        title: i18n('version-history.title'),
+        icon: 'fa-light fa-history',
+        color: 'default',
+        descriptions: {
+            title: i18n('version-history.title'),
+            tooltip: i18n('version-history.description'),
+            permission: i18n('version-history.permission'),
+            audit: i18n('version-history.audit')
+        }
+    },
+    Compare: {
+        key: AXPSystemActionType.Compare,
+        title: i18n('compare.title'),
+        icon: 'fa-light fa-code-compare',
+        color: 'default',
+        descriptions: {
+            title: i18n('compare.title'),
+            tooltip: i18n('compare.description'),
+            permission: i18n('compare.permission'),
+            audit: i18n('compare.audit')
+        }
+    },
+    Comments: {
+        key: AXPSystemActionType.Comments,
+        title: i18n('comments.title'),
+        icon: 'fa-light fa-comments',
+        color: 'default',
+        descriptions: {
+            title: i18n('comments.title'),
+            tooltip: i18n('comments.description'),
+            permission: i18n('comments.permission'),
+            audit: i18n('comments.audit')
+        }
+    },
+    Sign: {
+        key: AXPSystemActionType.Sign,
+        title: i18n('sign.title'),
+        icon: 'fa-light fa-signature',
+        color: 'default',
+        descriptions: {
+            title: i18n('sign.title'),
+            tooltip: i18n('sign.description'),
+            permission: i18n('sign.permission'),
+            audit: i18n('sign.audit')
+        }
+    },
+    Setup: {
+        key: AXPSystemActionType.Setup,
+        title: i18n('setup.title'),
+        icon: 'fa-light fa-cog',
+        color: 'default',
+        descriptions: {
+            title: i18n('setup.title'),
+            tooltip: i18n('setup.description'),
+            permission: i18n('setup.permission'),
+            audit: i18n('setup.audit')
+        }
+    },
+    Send: {
+        key: AXPSystemActionType.Send,
+        title: i18n('send.title'),
+        icon: 'fa-light fa-envelope',
+        color: 'default',
+        descriptions: {
+            title: i18n('send.title'),
+            tooltip: i18n('send.description'),
+            permission: i18n('send.permission'),
+            audit: i18n('send.audit')
+        }
+    },
+    Report: {
+        key: AXPSystemActionType.Report,
+        title: i18n('report.title'),
+        icon: 'fa-light fa-chart-line',
+        color: 'default',
+        descriptions: {
+            title: i18n('report.title'),
+            tooltip: i18n('report.description'),
+            permission: i18n('report.permission'),
+            audit: i18n('report.audit')
+        }
+    },
+    Sent: {
+        key: AXPSystemActionType.Sent,
+        title: i18n('sent.title'),
+        icon: 'fa-light fa-paper-plane',
+        color: 'default',
+        descriptions: {
+            title: i18n('sent.title'),
+            tooltip: i18n('sent.description'),
+            permission: i18n('sent.permission'),
+            audit: i18n('sent.audit')
+        }
+    },
+    Review: {
+        key: AXPSystemActionType.Review,
+        title: i18n('review.title'),
+        icon: 'fa-light fa-eye',
+        color: 'default',
+        descriptions: {
+            title: i18n('review.title'),
+            tooltip: i18n('review.description'),
+            permission: i18n('review.permission'),
+            audit: i18n('review.audit')
+        }
+    },
+    Generate: {
+        key: AXPSystemActionType.Generate,
+        title: i18n('generate.title'),
+        icon: 'fa-light fa-wand-magic-sparkles',
+        color: 'primary',
+        descriptions: {
+            title: i18n('generate.title'),
+            tooltip: i18n('generate.description'),
+            permission: i18n('generate.permission'),
+            audit: i18n('generate.audit')
+        }
+    },
+    Refresh: {
+        key: AXPSystemActionType.Refresh,
+        title: i18n('refresh.title'),
+        icon: 'fa-light fa-arrows-rotate',
+        color: 'default',
+        descriptions: {
+            title: i18n('refresh.title'),
+            tooltip: i18n('refresh.description'),
+            permission: i18n('refresh.permission'),
+            audit: i18n('refresh.audit')
+        }
+    },
+    Reload: {
+        key: AXPSystemActionType.Reload,
+        title: i18n('reload.title'),
+        icon: 'fa-light fa-arrows-rotate',
+        color: 'default',
+        descriptions: {
+            title: i18n('reload.title'),
+            tooltip: i18n('reload.description'),
+            permission: i18n('reload.permission'),
+            audit: i18n('reload.audit')
+        }
+    },
+    Search: {
+        key: AXPSystemActionType.Search,
+        title: i18n('search.title'),
+        icon: 'fa-light fa-magnifying-glass',
+        color: 'default',
+        descriptions: {
+            title: i18n('search.title'),
+            tooltip: i18n('search.description'),
+            permission: i18n('search.permission'),
+            audit: i18n('search.audit')
+        }
+    },
+    Filter: {
+        key: AXPSystemActionType.Filter,
+        title: i18n('filter.title'),
+        icon: 'fa-light fa-filter',
+        color: 'default',
+        descriptions: {
+            title: i18n('filter.title'),
+            tooltip: i18n('filter.description'),
+            permission: i18n('filter.permission'),
+            audit: i18n('filter.audit')
+        }
+    },
+    Sort: {
+        key: AXPSystemActionType.Sort,
+        title: i18n('sort.title'),
+        icon: 'fa-light fa-arrow-down-up-across-line',
+        color: 'default',
+        descriptions: {
+            title: i18n('sort.title'),
+            tooltip: i18n('sort.description'),
+            permission: i18n('sort.permission'),
+            audit: i18n('sort.audit')
+        }
+    },
+    Start: {
+        key: AXPSystemActionType.Start,
+        title: i18n('start.title'),
+        icon: 'fa-light fa-play',
+        color: 'success',
+        descriptions: {
+            title: i18n('start.title'),
+            tooltip: i18n('start.description'),
+            permission: i18n('start.permission'),
+            audit: i18n('start.audit')
+        }
+    },
+    Stop: {
+        key: AXPSystemActionType.Stop,
+        title: i18n('stop.title'),
+        icon: 'fa-light fa-stop',
+        color: 'danger',
+        critical: true,
+        descriptions: {
+            title: i18n('stop.title'),
+            tooltip: i18n('stop.description'),
+            permission: i18n('stop.permission'),
+            audit: i18n('stop.audit')
+        }
+    },
+    Pause: {
+        key: AXPSystemActionType.Pause,
+        title: i18n('pause.title'),
+        icon: 'fa-light fa-pause',
+        color: 'warning',
+        descriptions: {
+            title: i18n('pause.title'),
+            tooltip: i18n('pause.description'),
+            permission: i18n('pause.permission'),
+            audit: i18n('pause.audit')
+        }
+    },
+    Cancel: {
+        key: AXPSystemActionType.Cancel,
+        title: i18n('cancel.title'),
+        icon: 'fa-light fa-xmark',
+        critical: true,
+        descriptions: {
+            title: i18n('cancel.title'),
+            tooltip: i18n('cancel.description'),
+            permission: i18n('cancel.permission'),
+            audit: i18n('cancel.audit')
+        }
+    },
+    Close: {
+        key: AXPSystemActionType.Close,
+        title: i18n('close.title'),
+        icon: 'fa-light fa-xmark',
+        color: 'default',
+        descriptions: {
+            title: i18n('close.title'),
+            tooltip: i18n('close.description'),
+            permission: i18n('close.permission'),
+            audit: i18n('close.audit')
+        }
+    },
+    Complete: {
+        key: AXPSystemActionType.Complete,
+        title: i18n('complete.title'),
+        icon: 'fa-light fa-check',
+        color: 'success',
+        descriptions: {
+            title: i18n('complete.title'),
+            tooltip: i18n('complete.description'),
+            permission: i18n('complete.permission'),
+            audit: i18n('complete.audit')
+        }
+    },
+    Save: {
+        key: AXPSystemActionType.Save,
+        title: i18n('save.title'),
+        icon: 'fa-light fa-floppy-disk',
+        color: 'primary',
+        descriptions: {
+            title: i18n('save.title'),
+            tooltip: i18n('save.description'),
+            permission: i18n('save.permission'),
+            audit: i18n('save.audit')
+        }
+    },
+    SaveAs: {
+        key: AXPSystemActionType.SaveAs,
+        title: i18n('save-as.title'),
+        icon: 'fa-light fa-floppy-disk',
+        color: 'default',
+        descriptions: {
+            title: i18n('save-as.title'),
+            tooltip: i18n('save-as.description'),
+            permission: i18n('save-as.permission'),
+            audit: i18n('save-as.audit')
+        }
+    },
+    Sync: {
+        key: AXPSystemActionType.Sync,
+        title: i18n('sync.title'),
+        icon: 'fa-light fa-arrows-rotate',
+        color: 'default',
+        descriptions: {
+            title: i18n('sync.title'),
+            tooltip: i18n('sync.description'),
+            permission: i18n('sync.permission'),
+            audit: i18n('sync.audit')
+        }
+    },
+    Reset: {
+        key: AXPSystemActionType.Reset,
+        title: i18n('reset.title'),
+        icon: 'fa-light fa-arrow-rotate-left',
+        color: 'warning',
+        critical: true,
+        descriptions: {
+            title: i18n('reset.title'),
+            tooltip: i18n('reset.description'),
+            permission: i18n('reset.permission'),
+            audit: i18n('reset.audit')
+        }
+    },
+    Clear: {
+        key: AXPSystemActionType.Clear,
+        title: i18n('clear.title'),
+        icon: 'fa-light fa-eraser',
+        color: 'default',
+        descriptions: {
+            title: i18n('clear.title'),
+            tooltip: i18n('clear.description'),
+            permission: i18n('clear.permission'),
+            audit: i18n('clear.audit')
+        }
+    },
+    Distribution: {
+        key: AXPSystemActionType.Distribution,
+        title: i18n('distribution.title'),
+        icon: 'fa-light fa-share-nodes',
+        color: 'default',
+        descriptions: {
+            title: i18n('distribution.title'),
+            tooltip: i18n('distribution.description'),
+            permission: i18n('distribution.permission'),
+            audit: i18n('distribution.audit')
+        }
+    },
+});
+function getSystemActions(type) {
+    return Object.values(AXPSystemActions).find(action => action.key === type);
+}
+/**
+ * Resolves the visual appearance (color and icon) for entity actions
+ * using the system actions from the core module.
+ */
+function resolveActionLook(actionType) {
+    // Try to get system action first
+    const systemActionType = actionType;
+    if (systemActionType) {
+        const systemAction = getSystemActions(systemActionType);
+        if (systemAction) {
+            return {
+                color: (systemAction.color || 'default'),
+                icon: systemAction.icon || ''
+            };
+        }
+    }
+    // Fallback for unknown actions
+    return {
+        color: 'default',
+        icon: ''
+    };
+}
+/**
+ * Resolves the title, description, icon and color for button actions
+ * using the system actions from the core module.
+ * @param actionType
+ * @returns
+ */
+function getActionButton(actionType) {
+    const systemActionType = actionType;
+    if (systemActionType) {
+        const systemAction = getSystemActions(systemActionType);
+        if (systemAction) {
+            return {
+                name: actionType,
+                icon: systemAction.icon || '',
+                color: systemAction.color || 'default',
+                title: systemAction.title,
+                description: systemAction.descriptions.title
+            };
+        }
+    }
+    // Fallback for unknown actions
+    return {
+        name: actionType,
+        title: actionType,
+        description: `Perform ${actionType} action`,
+        icon: '',
+        color: 'default'
+    };
+}
+
+function getNestedKeys(obj, prefix = '') {
+    let keys = [];
+    for (const key in obj) {
+        if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
+            keys = [...keys, ...getNestedKeys(obj[key], prefix + key + '.')];
+        }
+        else {
+            keys.push(prefix + key);
+        }
+    }
+    return keys;
+}
+
+//#region ----   Imports   ----
+//#endregion
+
+function applySystemActionDefault(action, type) {
+    const systemAction = getSystemActions(type);
+    return {
+        name: systemAction.key,
+        title: systemAction.title,
+        icon: systemAction.icon,
+        color: systemAction.color,
+    };
+}
+
+class AXPImageUrlLogoConfig {
+    constructor(url, width, height) {
+        this.url = url;
+        this.width = width;
+        this.height = height;
+    }
+}
+class AXPComponentLogoConfig {
+    constructor(component) {
+        this.component = component;
+    }
+}
+class AXPIconLogoConfig {
+    constructor(icon, color) {
+        this.icon = icon;
+        this.color = color;
+    }
+}
+
+var AXPPlatformScope;
+(function (AXPPlatformScope) {
+    AXPPlatformScope["Platform"] = "P";
+    AXPPlatformScope["Tenant"] = "T";
+    AXPPlatformScope["User"] = "U";
+})(AXPPlatformScope || (AXPPlatformScope = {}));
+;
+function resolvePlatformScopeKey(name) {
+    const scopeMap = {
+        platform: AXPPlatformScope.Platform,
+        tenant: AXPPlatformScope.Tenant,
+        user: AXPPlatformScope.User,
+    };
+    return scopeMap[name.toLowerCase()] ?? AXPPlatformScope.User;
+}
+function resolvePlatformScopeName(scope) {
+    const scopeMap = {
+        P: 'platform',
+        T: 'tenant',
+        U: 'user',
+    };
+    return scopeMap[scope] ?? 'user';
+}
+
+var AXPExportTemplateToken;
+(function (AXPExportTemplateToken) {
+    AXPExportTemplateToken["Date"] = "{date}";
+    AXPExportTemplateToken["Time"] = "{time}";
+    AXPExportTemplateToken["User"] = "{user}";
+    AXPExportTemplateToken["ReportTitle"] = "{title}";
+    AXPExportTemplateToken["UUID"] = "{uuid}";
+})(AXPExportTemplateToken || (AXPExportTemplateToken = {}));
+
+class AXPCountdownPipe {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+        this.countdownSignal = signal(this.setupTimer(), ...(ngDevMode ? [{ debugName: "countdownSignal" }] : /* istanbul ignore next */ []));
+        this.targetDate = 0;
+        this.prevValue = 0;
+    }
+    transform(value) {
+        if (this.prevValue != value) {
+            this.prevValue = value;
+            const expireTime = this.calendarService.calendar.add(new Date(), 'second', value).date;
+            this.updateTargetDate(expireTime.toISOString());
+        }
+        return this.countdownSignal();
+    }
+    setupTimer() {
+        return interval(1000).pipe(startWith(0), map(() => {
+            const diff = this.targetDate - new Date().getTime();
+            if (diff < 0) {
+                return "Time's up!";
+            }
+            const times = [86400, 3600, 60, 1].map((seconds) => Math.floor((diff / 1000 / seconds) % (seconds === 1 ? 60 : 24)));
+            const labels = ['d', 'h', 'm', 's'];
+            return times
+                .map((t, i) => (t > 0 || i === 3 ? `${t}${labels[i]}` : ''))
+                .join(' ')
+                .trim();
+        }));
+    }
+    updateTargetDate(value) {
+        this.targetDate = new Date(value).getTime();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, isStandalone: true, name: "countdown", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCountdownPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'countdown',
+                    pure: false,
+                    standalone: true,
+                }]
+        }] });
+
+const loggingEnabled = false; // Set to true to enable logging, false to disable
+function applyCondition(item, condition) {
+    const rawValue = condition.field ? get(item, condition.field) : null;
+    const itemValue = typeof rawValue === 'string' ? rawValue.toLowerCase() : rawValue;
+    const conditionValue = typeof condition.value === 'string' ? condition.value.toLowerCase() : condition.value;
+    // Conditional Logging for debugging
+    if (loggingEnabled) {
+        console.log('Condition:', condition);
+        console.log('Item Value:', itemValue);
+        console.log('Condition Value:', conditionValue);
+    }
+    let result;
+    const valueToCompare = isNil(condition.field) || condition.field === '' ? conditionValue : itemValue;
+    const conditionType = condition?.operator?.type;
+    if (!conditionType) {
+        return true;
+    }
+    const op = String(conditionType);
+    switch (op) {
+        case 'equal':
+        case 'eq':
+            result = isEqual(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Equal check result:', result);
+            }
+            break;
+        case 'notEqual':
+        case 'ne':
+        case 'neq':
+            result = !isEqual(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Not equal check result:', result);
+            }
+            break;
+        case 'greaterThan':
+        case 'gt':
+            result = gt(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Greater than check result:', result);
+            }
+            break;
+        case 'lessThan':
+        case 'lt':
+            result = lt(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Less than check result:', result);
+            }
+            break;
+        case 'greaterThanOrEqual':
+        case 'gte':
+            result = gte(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Greater than or equal check result:', result);
+            }
+            break;
+        case 'lessThanOrEqual':
+        case 'lte':
+            result = lte(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Less than or equal check result:', result);
+            }
+            break;
+        case 'contains':
+            if (typeof valueToCompare === 'string') {
+                result = includes(valueToCompare, conditionValue);
+            }
+            else if (Array.isArray(valueToCompare)) {
+                result = includes(valueToCompare.map((val) => val.toString().toLowerCase()), conditionValue);
+            }
+            else {
+                result = false;
+            }
+            if (loggingEnabled) {
+                console.log('Contains check result:', result);
+            }
+            break;
+        case 'in':
+            if (Array.isArray(conditionValue)) {
+                if (typeof valueToCompare === 'string') {
+                    result = conditionValue.some(val => typeof val === 'string' ? val.toLowerCase() === valueToCompare : val === valueToCompare);
+                }
+                else if (Array.isArray(valueToCompare)) {
+                    result = valueToCompare.some(val => conditionValue.some(condVal => typeof val === 'string' && typeof condVal === 'string'
+                        ? val.toLowerCase() === condVal.toLowerCase()
+                        : val === condVal));
+                }
+                else {
+                    result = conditionValue.includes(valueToCompare);
+                }
+            }
+            else {
+                result = false;
+            }
+            if (loggingEnabled) {
+                console.log('In check result:', result);
+            }
+            break;
+        case 'notContains':
+            if (typeof valueToCompare === 'string') {
+                result = !includes(valueToCompare, conditionValue);
+            }
+            else if (Array.isArray(valueToCompare)) {
+                result = !includes(valueToCompare.map((val) => val.toString().toLowerCase()), conditionValue);
+            }
+            else {
+                result = false;
+            }
+            if (loggingEnabled) {
+                console.log('Not contains check result:', result);
+            }
+            break;
+        case 'startsWith':
+            result = typeof valueToCompare === 'string' && startsWith(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Starts with check result:', result);
+            }
+            break;
+        case 'endsWith':
+            result = typeof valueToCompare === 'string' && endsWith(valueToCompare, conditionValue);
+            if (loggingEnabled) {
+                console.log('Ends with check result:', result);
+            }
+            break;
+        case 'isEmpty':
+            result = isEmpty(valueToCompare);
+            if (loggingEnabled) {
+                console.log('Is empty check result:', result);
+            }
+            break;
+        case 'isNull':
+            result = isNil(valueToCompare);
+            if (loggingEnabled) {
+                console.log('Is null check result:', result);
+            }
+            break;
+        case 'isNotEmpty':
+            result = !isEmpty(valueToCompare);
+            if (loggingEnabled) {
+                console.log('Is not empty check result:', result);
+            }
+            break;
+        case 'between':
+            result = !isNil(valueToCompare) && valueToCompare >= condition.value.from && valueToCompare <= condition.value.to;
+            if (loggingEnabled) {
+                console.log('Between check result:', result);
+            }
+            break;
+        default:
+            result = true;
+            if (loggingEnabled) {
+                console.log('Default case, returning true');
+            }
+    }
+    // Apply negative flag if present on operator (invert the result)
+    const isNegative = !!condition?.operator?.negative;
+    return isNegative ? !result : result;
+}
+function applyFilterArray(dataArray, filters, logic = 'and') {
+    if (filters && filters.length) {
+        return dataArray.filter((item) => {
+            if (logic === 'and') {
+                return filters.every((f) => {
+                    return f.filters ? applyFilterArray([item], f.filters, f.logic).length > 0 : applyCondition(item, f);
+                });
+            }
+            else {
+                // logic === 'or'
+                return filters.some((f) => {
+                    return f.filters ? applyFilterArray([item], f.filters, f.logic).length > 0 : applyCondition(item, f);
+                });
+            }
+        });
+    }
+    else {
+        return dataArray;
+    }
+}
+function applySortArray(dataArray, sorts) {
+    if (sorts && sorts.length > 0) {
+        const sortFields = sorts.map((s) => s.field);
+        const sortOrders = sorts.map((s) => s.dir);
+        return orderBy(dataArray, sortFields, sortOrders);
+    }
+    else
+        return dataArray;
+}
+function applyPagination(dataArray, skip, take) {
+    return dataArray.slice(skip, skip + take);
+}
+async function applyQueryArray(dataArray, query) {
+    let result = [...dataArray];
+    // Apply filtering
+    if (query.filter) {
+        result = applyFilterArray(result, [query.filter], query.filter.logic ?? 'and');
+    }
+    // Store total count before pagination
+    const total = result.length;
+    // Apply sorting
+    if (query.sort && query.sort.length > 0) {
+        result = applySortArray(result, query.sort);
+    }
+    // Apply pagination
+    result = applyPagination(result, query.skip, query.take);
+    return {
+        items: result,
+        total,
+    };
+}
+
+//#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" }] : /* istanbul ignore next */ []));
+        /**
+         * Current device type (Mobile, Tablet, Desktop)
+         */
+        this.deviceType = signal(getDeviceType(), ...(ngDevMode ? [{ debugName: "deviceType" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the device supports touch input
+         */
+        this.isTouchDevice = signal(isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchDevice" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Computed Signals   ----
+        /**
+         * Whether the screen size is Small
+         */
+        this.isSmall = computed(() => this.screenSize() === AXPScreenSize.Small, ...(ngDevMode ? [{ debugName: "isSmall" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the screen size is Medium
+         */
+        this.isMedium = computed(() => this.screenSize() === AXPScreenSize.Medium, ...(ngDevMode ? [{ debugName: "isMedium" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the screen size is Large
+         */
+        this.isLarge = computed(() => this.screenSize() === AXPScreenSize.Large, ...(ngDevMode ? [{ debugName: "isLarge" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the device is Mobile
+         */
+        this.isMobileDevice = computed(() => this.deviceType() === AXPDeviceType.Mobile, ...(ngDevMode ? [{ debugName: "isMobileDevice" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the device is Tablet
+         */
+        this.isTabletDevice = computed(() => this.deviceType() === AXPDeviceType.Tablet, ...(ngDevMode ? [{ debugName: "isTabletDevice" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the device is Desktop
+         */
+        this.isDesktopDevice = computed(() => this.deviceType() === AXPDeviceType.Desktop, ...(ngDevMode ? [{ debugName: "isDesktopDevice" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the device supports touch (alias for isTouchDevice)
+         */
+        this.isTouchScreen = computed(() => this.isTouchDevice(), ...(ngDevMode ? [{ debugName: "isTouchScreen" }] : /* istanbul ignore next */ []));
+        //#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: "21.2.9", ngImport: i0, type: AXPDeviceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDeviceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDeviceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Service for applying and resetting text highlighting within specified HTML elements.
+ */
+class AXHighlightService {
+    constructor() { }
+    /**
+     * Highlights all occurrences of a search value within the elements matching the provided query selector.
+     *
+     * @param querySelector - CSS selector to identify target elements.
+     * @param searchValue - Text to search and highlight.
+     */
+    highlight(querySelector, searchValue) {
+        this.clear();
+        if (!querySelector || !searchValue) {
+            return;
+        }
+        this.querySelector = querySelector;
+        this.searchValue = searchValue;
+        const elements = document.querySelectorAll(querySelector);
+        elements.forEach((element) => {
+            this.applyHighlight(element);
+        });
+    }
+    /**
+     * Resets all highlighted text within the elements matching the previously used query selector.
+     */
+    clear() {
+        const elements = document.querySelectorAll(`${this.querySelector}  .ax-highlight-text`);
+        elements.forEach((element) => {
+            let combinedText = '';
+            element.querySelectorAll('span').forEach((span) => {
+                combinedText += span.textContent;
+            });
+            const mergedSpan = document.createElement('span');
+            mergedSpan.textContent = combinedText;
+            element?.parentNode?.replaceChild(mergedSpan, element);
+        });
+    }
+    /**
+     * Applies highlighting to a specific element by matching text against the search value.
+     *
+     * @param element - The HTML element to apply highlights to.
+     */
+    applyHighlight(element) {
+        const searchRegex = new RegExp(`(${this.searchValue})`, 'gi');
+        this.recursivelyHighlight(element, searchRegex);
+    }
+    /**
+     * Recursively applies highlighting to text nodes within an element.
+     *
+     * @param element - The current node being processed.
+     * @param searchRegex - Regular expression for matching text to highlight.
+     */
+    recursivelyHighlight(element, searchRegex) {
+        const childNodes = Array.from(element.childNodes);
+        childNodes.forEach((node) => {
+            if (node.nodeType === Node.TEXT_NODE) {
+                const textContent = node.textContent || '';
+                if (textContent.match(searchRegex)) {
+                    const highlightedHTML = this.createHighlightedHTML(textContent, searchRegex);
+                    const tempContainer = document.createElement('div');
+                    tempContainer.innerHTML = highlightedHTML;
+                    const fragment = document.createDocumentFragment();
+                    Array.from(tempContainer.childNodes).forEach((child) => fragment.appendChild(child));
+                    node.replaceWith(fragment);
+                }
+            }
+            else if (node.nodeType === Node.ELEMENT_NODE) {
+                this.recursivelyHighlight(node, searchRegex);
+            }
+        });
+    }
+    /**
+     * Generates the HTML structure for highlighted text.
+     *
+     * @param textContent - The original text content to process.
+     * @param searchRegex - Regular expression for matching text to highlight.
+     * @returns A string of HTML with highlighted portions wrapped in span elements.
+     */
+    createHighlightedHTML(textContent, searchRegex) {
+        let parts = [];
+        let match;
+        let lastIndex = 0;
+        let resultHTML = '<span class="ax-highlight-text">';
+        while ((match = searchRegex.exec(textContent)) !== null) {
+            if (match.index > lastIndex) {
+                resultHTML += `<span>${textContent.slice(lastIndex, match.index)}</span>`;
+            }
+            resultHTML += `<span class="ax-highlight">${match[0]}</span>`;
+            lastIndex = searchRegex.lastIndex;
+        }
+        if (lastIndex < textContent.length) {
+            resultHTML += `<span>${textContent.slice(lastIndex)}</span>`;
+        }
+        resultHTML += '</span>';
+        return resultHTML;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXHighlightService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], 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 - Optional. Whether the provider is a multi-provider (array of values). Defaults to `true`. Pass `false` for a single provider.
+ * @returns Provider configuration object
+ *
+ * @example
+ * ```typescript
+ * // Multi-provider (default)
+ * provideLazyProvider(
+ *   AXP_DATASOURCE_DEFINITION_PROVIDER,
+ *   () => import('./datasource.provider').then(m => m.AXMDataSourceProvider)
+ * )
+ *
+ * // Single provider
+ * provideLazyProvider(
+ *   SOME_TOKEN,
+ *   () => import('./my.provider').then(m => m.MyProvider),
+ *   false
+ * )
+ * ```
+ */
+function provideLazyProvider(token, loader, multi = true) {
+    return {
+        provide: token,
+        useFactory: () => createProviderWithInjectionContext(loader),
+        multi,
+    };
+}
+
+function extractTextFromHtml(value) {
+    const div = document.createElement('div');
+    div.innerHTML = value;
+    return div.textContent || div.innerText || '';
+}
+/**
+ * True when the string likely contains HTML markup (e.g. `<p>`, `<ul>`), as opposed to plain text.
+ * Used to choose innerHTML vs text interpolation for multilingual fields.
+ */
+function containsHtmlMarkup(value) {
+    if (value == null) {
+        return false;
+    }
+    const t = value.trim();
+    if (!t) {
+        return false;
+    }
+    return /<\/?[a-z][\s\S]*?>/i.test(t);
+}
+/**
+ * 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, AXPColumnWidthService, AXPComponentLogoConfig, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPModuleManifestsDataSourceDefinition, AXPMultiLanguageStringResolverService, AXPPlatformScope, AXPResolveMultiLanguageStringPipe, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_COLUMN_WIDTH_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, MODULE_MANIFESTS_DATASOURCE_NAME, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, containsHtmlMarkup, createMultiLanguageString, createProviderWithInjectionContext, defaultColumnWidthProvider, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, isEffectivelyEmptyLocalizedValue, objectKeyValueTransforms, provideLazyProvider, resolveActionLook, resolveMultiLanguageString, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+//# sourceMappingURL=acorex-platform-core.mjs.map