@acorex-platform/framework-client 0.0.10

package/fesm2022/acorex-platform-framework-client-core.mjs

@@ -0,0 +1,4655 @@
+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, DestroyRef, untracked, provideAppInitializer, Pipe } from '@angular/core';
+import { AXTranslationService, resolveMultiLanguageString } from '@acorex/core/translation';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXPPlatformCoreDataSourceKeys, isFormContextDirty, getSmart, isSelectionValueEqual, isFormValueEqual, setSmart, extractValue, AXPKeyboardShortcutPriority, getSystemActions, isLocaleStringMap } from '@acorex-platform/framework-shared/core';
+import { cloneDeep, isEmpty, isEqual, has, unset, isPlainObject, get, sortBy, set, isUndefined, isNil, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { AXFormatService } from '@acorex/core/format';
+import * as i1 from '@acorex/components/skeleton';
+import { AXSkeletonModule } from '@acorex/components/skeleton';
+import { Subject, interval, fromEvent } from 'rxjs';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { DOCUMENT } from '@angular/common';
+import { AXLocaleService } from '@acorex/core/locale';
+import { delay } from '@acorex/core/utils';
+import { AXCalendarService } from '@acorex/core/date-time';
+import { startWith, map, debounceTime } from 'rxjs/operators';
+
+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 ---- Catalog scope definition ----
+//#endregion
+
+//#region ---- Provider contract ----
+const AXP_CATALOG_SCOPE_DEFINITION_PROVIDER = new InjectionToken('AXP_CATALOG_SCOPE_DEFINITION_PROVIDER');
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Aggregator service ----
+/**
+ * Collects {@link AXPCatalogScopeDefinition} entries from all registered providers.
+ */
+class AXPCatalogScopeDefinitionProviderService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.providers = inject(AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, { optional: true });
+        this.translation = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        const merged = [];
+        const seen = new Set();
+        if (!Array.isArray(this.providers)) {
+            return merged;
+        }
+        for (const raw of this.providers) {
+            const provider = await Promise.resolve(raw);
+            if (!provider || typeof provider.items !== 'function') {
+                continue;
+            }
+            for (const item of await provider.items()) {
+                const name = item.name?.trim();
+                if (!name) {
+                    continue;
+                }
+                if (seen.has(name)) {
+                    throw new Error(`Duplicate catalog scope definition: "${name}"`);
+                }
+                seen.add(name);
+                merged.push(item);
+            }
+        }
+        return merged.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+    async get(name) {
+        const key = name?.trim();
+        if (!key) {
+            return undefined;
+        }
+        return (await this.items()).find((d) => d.name === key);
+    }
+    /**
+     * Scopes applicable to the given entity ref (`Module.Entity`).
+     */
+    async byTarget(entityRef) {
+        const target = entityRef?.trim();
+        if (!target) {
+            return [];
+        }
+        return (await this.items()).filter((d) => d.targets?.some((t) => t === target));
+    }
+    /**
+     * Resolves display title for a scope key (active locale).
+     */
+    resolveTitle(definition) {
+        const locale = this.translation.getActiveLang() ?? 'en-US';
+        if (typeof definition.title === 'string') {
+            const title = definition.title.trim();
+            if (title.startsWith('@')) {
+                return this.translation.translateSync(title) || title;
+            }
+            return title;
+        }
+        return resolveMultiLanguageString(definition.title, locale) || definition.name;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPCatalogScopeDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Data source definition ----
+/**
+ * Registered catalog scopes for select / selection-list widgets via {@link AXPPlatformCoreDataSourceKeys.CatalogScopes}.
+ */
+class AXPCatalogScopeDefinitionsDataSourceDefinition {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.catalogScopeRegistry = inject(AXPCatalogScopeDefinitionProviderService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        return [
+            {
+                name: AXPPlatformCoreDataSourceKeys.CatalogScopes,
+                title: 'Catalog scopes',
+                source: () => new AXDataSource({
+                    key: 'name',
+                    pageSize: 500,
+                    load: async (e) => {
+                        const all = await this.catalogScopeRegistry.items();
+                        const localeFilter = this.readTargetFilter(e?.filter);
+                        const items = all
+                            .filter((scope) => !localeFilter || scope.targets?.includes(localeFilter))
+                            .map((scope) => ({
+                            name: scope.name,
+                            title: this.catalogScopeRegistry.resolveTitle(scope),
+                            description: scope.description,
+                            targets: scope.targets,
+                            icon: scope.icon,
+                            cssClass: scope.cssClass,
+                        }));
+                        return { items, total: items.length };
+                    },
+                    byKey: async (key) => {
+                        const name = String(key ?? '').trim();
+                        if (!name) {
+                            return undefined;
+                        }
+                        const scope = await this.catalogScopeRegistry.get(name);
+                        if (!scope) {
+                            return undefined;
+                        }
+                        return {
+                            name: scope.name,
+                            title: this.catalogScopeRegistry.resolveTitle(scope),
+                            description: scope.description,
+                            targets: scope.targets,
+                            icon: scope.icon,
+                            cssClass: scope.cssClass,
+                        };
+                    },
+                }),
+                columns: [
+                    { name: 'name', title: 'Name', datatype: 'string', type: 'text-editor' },
+                    { name: 'title', title: 'Title', datatype: 'string', type: 'text-editor' },
+                ],
+                filters: [
+                    {
+                        field: 'targets',
+                        title: 'Target entity',
+                        operator: { type: 'contains' },
+                        widget: { type: 'text-editor' },
+                        filterType: { advance: false, inline: false },
+                    },
+                ],
+                textField: { name: 'title', title: 'Title' },
+                valueField: { name: 'name', title: 'Name' },
+            },
+        ];
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    readTargetFilter(filter) {
+        if (!filter || typeof filter !== 'object') {
+            return undefined;
+        }
+        const f = filter;
+        if (f.field === 'targets' && typeof f.value === 'string' && f.value.trim()) {
+            return f.value.trim();
+        }
+        return undefined;
+    }
+}
+//#endregion
+
+//#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
+        }] });
+
+//#region ---- Context signal store ----
+const AXPContextStore = signalStore(withState(() => ({
+    data: {},
+    state: 'initiated',
+    /** Last committed / saved baseline — discard reverts to this snapshot. */
+    savedSnapshot: {},
+    previousSnapshot: {},
+    /** True after a user-origin update since the last {@link commitSaved}. */
+    userEditedSinceCommit: false,
+    lastChange: {
+        state: 'initiated',
+    },
+})), withComputed(({ data, state, lastChange, savedSnapshot, previousSnapshot, userEditedSinceCommit }) => ({
+    isChanged: computed(() => state() === 'changed'),
+    isReset: computed(() => state() === 'restored'),
+    isInitiated: computed(() => state() === 'initiated'),
+    isEmpty: computed(() => Object.keys(data()).length === 0),
+    isSavedCommitted: computed(() => !isEmpty(savedSnapshot())),
+    hasUserEditedSinceCommit: computed(() => userEditedSinceCommit()),
+    isDirty: computed(() => {
+        const saved = savedSnapshot();
+        if (isEmpty(saved)) {
+            return false;
+        }
+        if (!userEditedSinceCommit()) {
+            return false;
+        }
+        return isFormContextDirty(data(), saved);
+    }),
+    snapshot: computed(() => cloneDeep(data())),
+    saved: computed(() => cloneDeep(savedSnapshot())),
+    /** @deprecated Use {@link saved} — only saved baseline is tracked. */
+    initial: computed(() => cloneDeep(savedSnapshot())),
+    previous: computed(() => cloneDeep(previousSnapshot())),
+    changeEvent: computed(() => lastChange()),
+})), withMethods((store) => {
+    const updateValue = (path, value, options) => {
+        const currentData = cloneDeep(store.data());
+        const oldValue = getSmart(currentData, path);
+        const hasSaved = !isEmpty(store.savedSnapshot());
+        const saved = store.savedSnapshot();
+        const savedAtPath = hasSaved ? getSmart(saved, path) : undefined;
+        const origin = options?.origin ?? 'system';
+        if (hasSaved && isSelectionValueEqual(value, savedAtPath) && !isEqual(value, savedAtPath)) {
+            value = cloneDeep(savedAtPath);
+        }
+        if (hasSaved && !isEqual(value, savedAtPath) && isFormValueEqual(value, savedAtPath)) {
+            value = cloneDeep(savedAtPath);
+        }
+        const isArrayLengthChange = Array.isArray(value) && (!Array.isArray(oldValue) || value.length !== oldValue.length);
+        /** Same selection id as baseline but different object shape (lookup/select item vs scalar). */
+        const needsSavedShapeRestore = hasSaved && isSelectionValueEqual(value, savedAtPath) && !isFormValueEqual(value, savedAtPath);
+        if (!isArrayLengthChange && isEqual(oldValue, value) && !needsSavedShapeRestore) {
+            return;
+        }
+        const shouldNormalizeSavedShape = hasSaved && isSelectionValueEqual(value, savedAtPath) && !isEqual(oldValue, value);
+        if (!isArrayLengthChange &&
+            isFormValueEqual(oldValue, value) &&
+            !shouldNormalizeSavedShape &&
+            !needsSavedShapeRestore) {
+            return;
+        }
+        const updatedData = setSmart(currentData, path, value);
+        const isStillDirty = hasSaved && isFormContextDirty(updatedData, saved);
+        const nextUserEdited = isStillDirty
+            ? origin === 'user'
+                ? true
+                : store.userEditedSinceCommit()
+            : false;
+        const changeEvent = {
+            oldValue,
+            newValue: value,
+            path,
+            state: 'changed',
+            data: updatedData,
+            origin,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(),
+            data: updatedData,
+            state: 'changed',
+            lastChange: changeEvent,
+            userEditedSinceCommit: nextUserEdited,
+        });
+    };
+    const applyObjectPaths = (obj, options, prefix = '') => {
+        for (const [key, value] of Object.entries(obj ?? {})) {
+            const path = prefix ? `${prefix}.${key}` : key;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                applyObjectPaths(value, options, path);
+            }
+            else {
+                updateValue(path, value, options);
+            }
+        }
+    };
+    const removePathFromContext = (path, origin = 'system') => {
+        const currentData = cloneDeep(store.data());
+        if (!has(currentData, path)) {
+            return;
+        }
+        unset(currentData, path);
+        const parts = path.split('.');
+        for (let i = parts.length - 1; i > 0; i--) {
+            const parentPath = parts.slice(0, i).join('.');
+            const parentObj = getSmart(currentData, parentPath);
+            if (isPlainObject(parentObj) && isEmpty(Object.keys(parentObj))) {
+                unset(currentData, parentPath);
+            }
+        }
+        const saved = store.savedSnapshot();
+        const isStillDirty = !isEmpty(saved) && isFormContextDirty(currentData, saved);
+        patchState(store, {
+            previousSnapshot: store.snapshot(),
+            data: currentData,
+            state: 'changed',
+            lastChange: {
+                path,
+                state: 'changed',
+                data: currentData,
+                origin,
+            },
+            userEditedSinceCommit: isStillDirty
+                ? origin === 'user'
+                    ? true
+                    : store.userEditedSinceCommit()
+                : false,
+        });
+    };
+    const syncPathToSavedBaseline = (path, options) => {
+        const saved = store.savedSnapshot();
+        if (isEmpty(saved)) {
+            return;
+        }
+        const origin = options?.origin ?? 'system';
+        if (has(saved, path)) {
+            updateValue(path, cloneDeep(getSmart(saved, path)), { origin });
+            return;
+        }
+        removePathFromContext(path, origin);
+    };
+    const revertToSaved = () => {
+        const savedData = store.saved();
+        const changeEvent = {
+            oldValue: cloneDeep(store.data()),
+            newValue: cloneDeep(savedData),
+            path: '',
+            state: 'restored',
+            data: savedData,
+        };
+        patchState(store, {
+            previousSnapshot: store.snapshot(),
+            data: savedData,
+            state: 'restored',
+            lastChange: changeEvent,
+            userEditedSinceCommit: false,
+        });
+    };
+    return {
+        update(path, value, options) {
+            updateValue(path, value, options);
+        },
+        applyObjectPaths,
+        /** Aligns a context path with the saved baseline (restore value or remove if absent). */
+        syncPathToSavedBaseline,
+        patch(context, options) {
+            const currentData = cloneDeep(store.data());
+            const updatedData = { ...currentData, ...context };
+            const changeEvent = {
+                state: 'patch',
+                data: updatedData,
+            };
+            const syncedSnapshot = cloneDeep(updatedData);
+            patchState(store, {
+                ...(options?.updateSaved
+                    ? { savedSnapshot: syncedSnapshot, previousSnapshot: syncedSnapshot }
+                    : { previousSnapshot: store.snapshot() }),
+                data: updatedData,
+                state: 'changed',
+                lastChange: changeEvent,
+            });
+        },
+        /** Reverts live data to the last saved snapshot. */
+        revertToSaved,
+        reset() {
+            revertToSaved();
+        },
+        /** Loads live data; saved baseline is committed separately via {@link commitSaved}. */
+        set(initialData) {
+            const currentData = store.data();
+            if (isFormValueEqual(currentData, initialData)) {
+                return;
+            }
+            const changeEvent = {
+                oldValue: null,
+                newValue: cloneDeep(initialData),
+                path: '',
+                state: 'initiated',
+                data: initialData,
+            };
+            patchState(store, {
+                previousSnapshot: store.snapshot(),
+                data: initialData,
+                state: 'initiated',
+                lastChange: changeEvent,
+                userEditedSinceCommit: false,
+            });
+        },
+        getValue(path) {
+            return getSmart(store.data(), path);
+        },
+        getSavedValue(path) {
+            return getSmart(store.savedSnapshot(), path);
+        },
+        hasValue(path) {
+            return has(store.data(), path);
+        },
+        /** Marks the current data as the saved baseline. */
+        commitSaved() {
+            const snapshot = cloneDeep(store.data());
+            patchState(store, {
+                savedSnapshot: snapshot,
+                previousSnapshot: snapshot,
+                state: 'initiated',
+                userEditedSinceCommit: false,
+                lastChange: {
+                    state: 'initiated',
+                    data: snapshot,
+                },
+            });
+        },
+        /** Merges parent-bound entity fields without resetting the saved baseline. */
+        applyParentBind(merged) {
+            if (isFormValueEqual(store.data(), merged)) {
+                return;
+            }
+            patchState(store, {
+                data: merged,
+            });
+        },
+    };
+}));
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Pipe normalization ----
+/** Normalizes shorthand pipe names to `{ type, options? }` specs. */
+function normalizeContextEvalPipes(pipes) {
+    return pipes.map((pipe) => (typeof pipe === 'string' ? { type: pipe } : pipe));
+}
+//#endregion
+//#region ---- Pipe application ----
+/**
+ * Applies a left-to-right formatter pipeline via {@link AXFormatService}.
+ * Unknown formatters fall back to a trimmed string representation.
+ */
+function applyContextEvalPipes(value, pipes, formatService) {
+    if (!pipes?.length) {
+        return value;
+    }
+    let current = value;
+    for (const pipe of normalizeContextEvalPipes(pipes)) {
+        try {
+            current = formatService.format(current, pipe.type, pipe.options);
+        }
+        catch {
+            current = current == null ? '' : String(current);
+        }
+    }
+    return current;
+}
+/** Reads a nested path from data and optionally applies display pipes. */
+function contextEvalWithPipes(data, path, formatService, pipes) {
+    return applyContextEvalPipes(get(data, path), pipes, formatService);
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+/**
+ * Builds sync `context.eval(path, { pipes })` functions backed by {@link AXFormatService}.
+ * Supports built-in and custom formatters registered on {@link AXFormatModule}.
+ */
+class AXPContextEvalFactory {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.formatService = inject(AXFormatService);
+    }
+    //#endregion
+    //#region ---- Factory ----
+    /** Creates a sync eval function for the given record/context data object. */
+    create(data) {
+        return (path, options) => {
+            const raw = get(data, path);
+            return applyContextEvalPipes(raw, options?.pipes, this.formatService);
+        };
+    }
+    /** Creates `{ eval }` scope object for expression evaluator scopes. */
+    createScope(data) {
+        return { eval: this.create(data) };
+    }
+    /**
+     * Display-tier scope that re-reads data on each eval (for live stores / changing row context).
+     */
+    createLiveScope(getData) {
+        return {
+            eval: (path, options) => this.create(getData())(path, options),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextEvalFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextEvalFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextEvalFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Types ----
+//#endregion
+
+//#region ---- Template normalization ----
+/**
+ * Normalizes display templates before {@link AXPExpressionEvaluatorService} evaluation.
+ * Converts simple dot paths (e.g. `{{ position.title }}`) to `context.eval("position.title")`
+ * so row data is read from scope.context instead of bare JavaScript identifiers.
+ */
+function normalizeExpressionTemplate(template) {
+    let normalized = template.replace(/\{\{\s*context\.eval\(['"]([^'"]+)['"]\)\s*\}\}/g, '{{ context.eval("$1") }}');
+    if (!normalized.includes('{{')) {
+        normalized = normalized.replace(/\{/g, '{{').replace(/\}/g, '}}');
+    }
+    return normalized.replace(/\{\{\s*(?!context\.)(?!host\.)([\w]+(?:\.[\w]+)*)\s*\}\}/g, '{{ context.eval("$1") }}');
+}
+//#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) {
+            // Resolve lazy-loaded providers (provideLazyProvider useFactory returns Promise<Provider>)
+            const resolved = await Promise.resolve(provider);
+            if (!resolved || typeof resolved.provide !== 'function') {
+                continue;
+            }
+            await resolved.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) {
+        const normalizedTemplate = normalizeExpressionTemplate(templateExpression);
+        // Check if the input is exactly a single {{ ... }} expression (handle multiline)
+        const exactMatch = normalizedTemplate.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(normalizedTemplate)) !== 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 += normalizedTemplate.slice(lastIndex, m.start);
+            const value = values[i];
+            result += value !== undefined && value !== null ? value : '';
+            lastIndex = m.end;
+        });
+        result += normalizedTemplate.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']
+                }] }] });
+
+/** Trace namespace for form dirty-state diagnostics (lookup/select revert, discard, baseline). */
+const FORM_DIRTY_TRACE_NS = 'FORM STATE';
+
+//#region ---- AI metadata ----
+//#endregion
+
+const AXP_CONTEXT_DEFINITION_PROVIDER = new InjectionToken('AXP_CONTEXT_DEFINITION_PROVIDER');
+//#endregion
+
+//#region ---- Aggregator service ----
+/**
+ * Collects {@link AXPContextDefinition} entries from all registered {@link AXPContextDefinitionProvider} instances.
+ */
+class AXPContextDefinitionProviderService {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.providers = inject(AXP_CONTEXT_DEFINITION_PROVIDER, { optional: true });
+    }
+    //#endregion
+    //#region ---- Public API ----
+    async items() {
+        const items = [];
+        if (!Array.isArray(this.providers)) {
+            return items;
+        }
+        for (const raw of this.providers) {
+            const provider = await Promise.resolve(raw);
+            if (provider && typeof provider.items === 'function') {
+                items.push(...(await provider.items()));
+            }
+        }
+        return items;
+    }
+    async get(name) {
+        return (await this.items()).find((d) => d.name === name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPContextDefinitionProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Debug Service ----
+/**
+ * Platform debug and trace logging.
+ * Call `trace` / `traceGroup` for diagnostics (gated by tenant Debug Mode).
+ * Call `warn` / `error` for always-on console output.
+ *
+ * Debug Mode is applied via `setDebugMode()` (wired from settings in platform common).
+ */
+class AXPDebugService {
+    //#endregion
+    //#region ---- Lifecycle ----
+    constructor() {
+        //#endregion
+        //#region ---- State ----
+        this.debugModeEnabled = false;
+        AXPDebugService.instance = this;
+    }
+    //#endregion
+    //#region ---- Debug Mode ----
+    isDebugMode() {
+        return this.debugModeEnabled;
+    }
+    setDebugMode(enabled) {
+        this.debugModeEnabled = enabled;
+    }
+    //#endregion
+    //#region ---- Trace API ----
+    /**
+     * @param namespace Module/feature namespace (kebab-case). Filter console with `[AXP:<namespace>]`.
+     * @param title Short area name (component, service, middleware).
+     * @param message What happened.
+     * @param data Optional structured payload, or a factory evaluated only when Debug Mode is on.
+     */
+    trace(namespace, title, message, data) {
+        if (!this.debugModeEnabled) {
+            return;
+        }
+        this.log('log', namespace, title, message, data);
+    }
+    /**
+     * Same as {@link trace} but emits a collapsible console group (useful for multi-field payloads).
+     */
+    traceGroup(namespace, title, message, data) {
+        if (!this.debugModeEnabled) {
+            return;
+        }
+        const resolved = this.resolveData(data);
+        console.groupCollapsed(this.formatPrefix(namespace, title, message));
+        if (resolved != null) {
+            for (const [key, value] of Object.entries(resolved)) {
+                if (value !== undefined) {
+                    console.log(key, value);
+                }
+            }
+        }
+        console.groupEnd();
+    }
+    warn(namespace, title, message, data) {
+        this.log('warn', namespace, title, message, data);
+    }
+    error(namespace, title, message, data) {
+        this.log('error', namespace, title, message, data);
+    }
+    //#endregion
+    //#region ---- Utility Methods ----
+    formatPrefix(namespace, title, message) {
+        return `[AXP:${namespace}] ${title} — ${message}`;
+    }
+    resolveData(data) {
+        if (data == null) {
+            return undefined;
+        }
+        return typeof data === 'function' ? data() : data;
+    }
+    log(level, namespace, title, message, data) {
+        const prefix = this.formatPrefix(namespace, title, message);
+        const resolved = this.resolveData(data);
+        if (resolved != null) {
+            console[level](prefix, resolved);
+            return;
+        }
+        console[level](prefix);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPDebugService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+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') {
+        const h = Math.floor(Math.random() * 360);
+        const s = Math.floor(Math.random() * 14) + 72;
+        const l = Math.floor(Math.random() * 8) + 50;
+        if (format === 'hsl') {
+            return `hsl(${h}, ${s}%, ${l}%)`;
+        }
+        const { r, g, b } = this.hslToRgb(h, s / 100, l / 100);
+        if (format === 'rgb') {
+            return `rgb(${r}, ${g}, ${b})`;
+        }
+        const toHex = (val) => val.toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+    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 ---- Overlay Layer DOM Utilities ----
+/** Acorex overlay root (modal shell, popup, dialog). */
+const AX_OVERLAY_CONTAINER_SELECTOR = '.ax-overlay-container';
+/** Anchored widget panel inside an overlay (select, date picker, dropdown). */
+const AX_OVERLAY_PANE_SELECTOR = '.ax-overlay-pane';
+/**
+ * True when a visible overlay layer is foreground (modal, popup, widget popover/picker).
+ */
+function hasForegroundOverlayLayer(document) {
+    if (getVisibleAnchoredOverlayPanes(document).length > 0) {
+        return true;
+    }
+    return getVisibleOverlayContainers(document).length > 0;
+}
+/**
+ * Returns visible anchored overlay panes (widget popovers/pickers).
+ */
+function getVisibleAnchoredOverlayPanes(document) {
+    return Array.from(document.querySelectorAll(AX_OVERLAY_PANE_SELECTOR)).filter(isVisibleOverlayElement);
+}
+/**
+ * Visible anchored panes that are not contained by `excludeContainer` (e.g. dialog shell).
+ */
+function getNestedVisibleOverlayPanes(document, excludeContainer) {
+    return getVisibleAnchoredOverlayPanes(document).filter((pane) => !excludeContainer?.contains(pane));
+}
+/**
+ * Collects visible overlay containers in stacking order (later / higher z-index wins).
+ */
+function getVisibleOverlayContainers(document) {
+    return Array.from(document.querySelectorAll(AX_OVERLAY_CONTAINER_SELECTOR))
+        .filter(isVisibleOverlayElement)
+        .sort(compareOverlayStackOrder);
+}
+/** Topmost visible overlay container, if any. */
+function getTopVisibleOverlayContainer(document) {
+    const containers = getVisibleOverlayContainers(document);
+    return containers.length ? containers[containers.length - 1] : null;
+}
+/** Nearest overlay container ancestor of `element`. */
+function findOverlayContainerAncestor(element) {
+    return element.closest(AX_OVERLAY_CONTAINER_SELECTOR);
+}
+/**
+ * Returns true when the overlay element is rendered and visible in the viewport.
+ */
+function isVisibleOverlayElement(element) {
+    if (!(element instanceof HTMLElement)) {
+        return false;
+    }
+    const style = getComputedStyle(element);
+    if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) {
+        return false;
+    }
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+}
+function compareOverlayStackOrder(a, b) {
+    const za = Number(getComputedStyle(a).zIndex) || 0;
+    const zb = Number(getComputedStyle(b).zIndex) || 0;
+    if (za !== zb) {
+        return za - zb;
+    }
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+        return -1;
+    }
+    if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+        return 1;
+    }
+    return 0;
+}
+//#endregion
+
+//#region ---- Imports ----
+const HORIZONTAL_DIRECTIONAL_KEY_MIRRORS = {
+    arrowleft: 'arrowright',
+    arrowright: 'arrowleft',
+    left: 'right',
+    right: 'left',
+    '[': ']',
+    ']': '[',
+};
+/** Maps a horizontal direction key to its RTL semantic counterpart. */
+function mirrorHorizontalDirectionalKey(key) {
+    const normalized = normalizeShortcutToken$1(key);
+    return HORIZONTAL_DIRECTIONAL_KEY_MIRRORS[normalized] ?? normalized;
+}
+/** True when the chord's primary key is a horizontal direction key (`←`/`→`, `[`/`]`). */
+function isHorizontalDirectionalShortcutKey(key) {
+    return normalizeShortcutToken$1(key) in HORIZONTAL_DIRECTIONAL_KEY_MIRRORS;
+}
+/**
+ * Resolves direction behavior for a chord.
+ * Horizontal direction keys default to `semantic`; others default to `physical`.
+ * An explicit binding value always wins.
+ */
+function resolveEffectiveDirectionBehavior(chord, explicit) {
+    if (explicit === 'physical' || explicit === 'semantic') {
+        return explicit;
+    }
+    const { key } = parseKeyboardShortcutChord(chord);
+    return isHorizontalDirectionalShortcutKey(key) ? 'semantic' : 'physical';
+}
+/** Resolves the key the user presses for a semantically registered chord in RTL. */
+function resolveSemanticDirectionalKey(storedKey, rtl) {
+    const normalized = normalizeShortcutToken$1(storedKey);
+    if (!rtl) {
+        return normalized;
+    }
+    return mirrorHorizontalDirectionalKey(normalized);
+}
+/** Chord string with directional key mirrored for RTL display/matching when semantic. */
+function resolveDisplayShortcutChord(chord, isRtl, explicitDirectionBehavior) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, explicitDirectionBehavior);
+    const parts = chord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return chord;
+    }
+    const keyPart = parts.pop() ?? '';
+    const rtl = directionBehavior === 'semantic' && isRtl;
+    const resolvedKey = resolveSemanticDirectionalKey(keyPart, rtl);
+    return [...parts, resolvedKey].join('+');
+}
+const MODIFIER_ALIASES = {
+    ctrl: 'ctrl',
+    control: 'ctrl',
+    shift: 'shift',
+    alt: 'alt',
+    option: 'alt',
+    meta: 'meta',
+    cmd: 'meta',
+    command: 'meta',
+    win: 'meta',
+};
+const KEY_DISPLAY_MAC = {
+    ctrl: '⌃',
+    control: '⌃',
+    shift: '⇧',
+    alt: '⌥',
+    option: '⌥',
+    meta: '⌘',
+    cmd: '⌘',
+    command: '⌘',
+    win: '⌘',
+    enter: '↵',
+    escape: 'Esc',
+    esc: 'Esc',
+    home: 'Home',
+    arrowleft: '←',
+    arrowright: '→',
+    arrowup: '↑',
+    arrowdown: '↓',
+    pageup: 'PgUp',
+    pagedown: 'PgDn',
+    backspace: '⌫',
+    delete: '⌦',
+    space: 'Space',
+};
+/**
+ * Parses a shortcut chord such as `Enter`, `Escape`, or `ctrl+shift+s`.
+ */
+function parseKeyboardShortcutChord(chord) {
+    const parts = chord
+        .trim()
+        .toLowerCase()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const key = normalizeShortcutToken$1(parts.pop() ?? '');
+    const parsed = {
+        ctrl: false,
+        shift: false,
+        alt: false,
+        meta: false,
+        key,
+    };
+    for (const part of parts) {
+        const alias = MODIFIER_ALIASES[part];
+        if (alias) {
+            parsed[alias] = true;
+        }
+    }
+    return parsed;
+}
+/**
+ * Returns true when the keyboard event matches the given chord.
+ * On macOS, `ctrl+*` chords also match `meta+*` for common platform shortcuts.
+ */
+function matchesKeyboardShortcutChord(event, chord, options) {
+    const parsed = parseKeyboardShortcutChord(chord);
+    const mac = isMacPlatform();
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    if (!matchesShortcutModifiers(parsed, event, mac)) {
+        return false;
+    }
+    const actualKey = normalizeShortcutEventKey(event);
+    const expectedKey = normalizeShortcutToken$1(parsed.key);
+    const rtlSemantic = directionBehavior === 'semantic' &&
+        options?.isRtl === true &&
+        isHorizontalDirectionalShortcutKey(expectedKey);
+    if (rtlSemantic) {
+        return actualKey === mirrorHorizontalDirectionalKey(expectedKey);
+    }
+    return actualKey === expectedKey;
+}
+/**
+ * Matches modifier keys for a parsed chord.
+ * `ctrl+alt` chords also accept AltGraph (Windows) so layout-produced characters still match physical keys.
+ */
+function matchesShortcutModifiers(parsed, event, mac) {
+    if (parsed.shift !== event.shiftKey) {
+        return false;
+    }
+    const altGraph = hasAltGraphModifier(event);
+    if (parsed.ctrl && parsed.alt) {
+        if (altGraph) {
+            return true;
+        }
+        return event.ctrlKey && event.altKey;
+    }
+    if (parsed.alt !== event.altKey) {
+        return false;
+    }
+    if (parsed.meta) {
+        if (!event.metaKey) {
+            return false;
+        }
+        return true;
+    }
+    if (parsed.ctrl) {
+        if (mac) {
+            return event.metaKey || event.ctrlKey;
+        }
+        return event.ctrlKey;
+    }
+    if (event.ctrlKey || event.metaKey) {
+        return false;
+    }
+    return true;
+}
+function hasAltGraphModifier(event) {
+    return typeof event.getModifierState === 'function' && event.getModifierState('AltGraph');
+}
+/**
+ * Formats one chord for UI display (OS-aware modifier symbols).
+ */
+function formatKeyboardShortcutChord(chord, options) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    const resolvedChord = options?.skipDirectionResolve
+        ? chord
+        : resolveDisplayShortcutChord(chord, options?.isRtl === true, directionBehavior);
+    const mac = isMacPlatform();
+    const parts = resolvedChord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return '';
+    }
+    const keyPart = normalizeShortcutToken$1(parts.pop() ?? '');
+    const modifierParts = parts.map((part) => formatShortcutPart(part.toLowerCase(), mac));
+    const keyDisplay = formatShortcutPart(keyPart, mac);
+    if (mac) {
+        return [...modifierParts, keyDisplay].join('');
+    }
+    return [...modifierParts, keyDisplay].join('+');
+}
+/**
+ * Formats multiple chords as a single display string (e.g. `← / PgUp`).
+ */
+function formatKeyboardShortcutChords(chords, options) {
+    return chords.map((chord) => formatKeyboardShortcutChord(chord, options)).join(' / ');
+}
+/** Maps a chord to `ax-kbd-item` key parts (modifiers + display symbols). */
+function chordToKbdItemKeys(chord, options) {
+    const directionBehavior = resolveEffectiveDirectionBehavior(chord, options?.directionBehavior);
+    const resolvedChord = options?.skipDirectionResolve
+        ? chord
+        : resolveDisplayShortcutChord(chord, options?.isRtl === true, directionBehavior);
+    const mac = isMacPlatform();
+    const symbolKeys = {
+        arrowleft: '←',
+        arrowright: '→',
+        arrowup: '↑',
+        arrowdown: '↓',
+        pageup: 'PgUp',
+        pagedown: 'PgDn',
+        enter: '↵',
+        escape: 'Esc',
+        esc: 'Esc',
+        space: 'Space',
+        '[': '[',
+        ']': ']',
+    };
+    return resolvedChord
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const normalized = part.toLowerCase();
+        if (mac && (normalized === 'ctrl' || normalized === 'control')) {
+            return '⌘';
+        }
+        return symbolKeys[normalized] ?? part;
+    });
+}
+/**
+ * When focus is in a native edit control, avoid stealing plain key shortcuts.
+ */
+function isKeyboardTargetInsideEditableField(target) {
+    if (!(target instanceof HTMLElement)) {
+        return false;
+    }
+    if (target.isContentEditable) {
+        return true;
+    }
+    const field = target.closest('input, textarea, select');
+    if (!field || field.disabled) {
+        return false;
+    }
+    if (field instanceof HTMLInputElement) {
+        const type = field.type;
+        if (type === 'hidden' ||
+            type === 'checkbox' ||
+            type === 'radio' ||
+            type === 'button' ||
+            type === 'submit' ||
+            type === 'reset' ||
+            type === 'file' ||
+            field.readOnly) {
+            return false;
+        }
+        return true;
+    }
+    if (field instanceof HTMLTextAreaElement) {
+        return !field.readOnly;
+    }
+    return true;
+}
+/**
+ * Returns true when Esc should close an open widget overlay first (select, date picker, popover, modal).
+ * Used by the global shortcut registry so page-level Esc bindings do not swallow overlay dismiss.
+ */
+function shouldDeferEscapeToOpenOverlay(document) {
+    return hasForegroundOverlayLayer(document);
+}
+function isMacPlatform() {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+    return /Mac|iPhone|iPad|iPod/i.test(navigator.userAgent);
+}
+function normalizeShortcutToken$1(key) {
+    const normalized = key.trim().toLowerCase();
+    if (normalized === 'esc') {
+        return 'escape';
+    }
+    if (normalized === 'left') {
+        return 'arrowleft';
+    }
+    if (normalized === 'right') {
+        return 'arrowright';
+    }
+    if (normalized === 'up') {
+        return 'arrowup';
+    }
+    if (normalized === 'down') {
+        return 'arrowdown';
+    }
+    if (normalized === '[' || normalized === 'bracketleft') {
+        return '[';
+    }
+    if (normalized === ']' || normalized === 'bracketright') {
+        return ']';
+    }
+    return normalized;
+}
+function normalizeShortcutEventKey(event) {
+    if (event.key === 'Enter') {
+        return 'enter';
+    }
+    if (event.key === 'Escape') {
+        return 'escape';
+    }
+    if (event.key === 'Home') {
+        return 'home';
+    }
+    if (event.key === ' ') {
+        return 'space';
+    }
+    if (event.key === '[' || event.code === 'BracketLeft') {
+        return '[';
+    }
+    if (event.key === ']' || event.code === 'BracketRight') {
+        return ']';
+    }
+    const codeMatch = event.code.match(/^Key([A-Z])$/);
+    if (codeMatch) {
+        return codeMatch[1].toLowerCase();
+    }
+    const digitMatch = event.code.match(/^Digit([0-9])$/);
+    if (digitMatch) {
+        return digitMatch[1];
+    }
+    if (event.key.length === 1) {
+        return event.key.toLowerCase();
+    }
+    const fnMatch = event.code.match(/^F(\d+)$/);
+    if (fnMatch) {
+        return `f${fnMatch[1]}`;
+    }
+    return event.key.toLowerCase();
+}
+function formatShortcutPart(part, mac) {
+    const normalized = normalizeShortcutToken$1(part);
+    if (mac && KEY_DISPLAY_MAC[normalized]) {
+        return KEY_DISPLAY_MAC[normalized];
+    }
+    if (!mac && MODIFIER_ALIASES[normalized]) {
+        return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+    }
+    if (KEY_DISPLAY_MAC[normalized]) {
+        return KEY_DISPLAY_MAC[normalized];
+    }
+    if (normalized.length === 1) {
+        return normalized.toUpperCase();
+    }
+    return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+//#endregion
+
+//#region ---- Keyboard Shortcut Declaration Utilities ----
+/**
+ * Normalizes a declarative shortcut (`'ctrl+s'` or `{ keys: 'home', allowInEditableFields: false }`).
+ */
+function normalizeKeyboardShortcut(shortcut) {
+    if (typeof shortcut === 'string') {
+        const chord = shortcut.trim();
+        if (!chord) {
+            return undefined;
+        }
+        return { keys: [chord] };
+    }
+    return normalizeKeyboardShortcutConfig(shortcut);
+}
+/**
+ * Normalizes an array of declarative shortcuts. Empty or invalid entries are skipped.
+ */
+function normalizeKeyboardShortcuts(shortcuts) {
+    if (!shortcuts?.length) {
+        return [];
+    }
+    const result = [];
+    for (const shortcut of shortcuts) {
+        const normalized = normalizeKeyboardShortcut(shortcut);
+        if (normalized) {
+            result.push(normalized);
+        }
+    }
+    return result;
+}
+/** Returns the first chord from declarative shortcuts (for UI hints such as `ax-kbd`). */
+function getPrimaryKeyboardShortcutChord(shortcuts) {
+    return normalizeKeyboardShortcuts(shortcuts)[0]?.keys[0];
+}
+function normalizeKeyboardShortcutConfig(shortcut) {
+    const keys = Array.isArray(shortcut.keys) ? shortcut.keys : [shortcut.keys];
+    const normalizedKeys = keys.map((chord) => chord.trim()).filter(Boolean);
+    if (normalizedKeys.length === 0) {
+        return undefined;
+    }
+    return {
+        keys: normalizedKeys,
+        allowInEditableFields: shortcut.allowInEditableFields,
+        when: shortcut.when,
+        directionBehavior: shortcut.directionBehavior,
+    };
+}
+//#endregion
+
+//#region ---- Imports ----
+//#endregion
+class AXPKeyboardShortcutRegistry {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.document = inject(DOCUMENT);
+        this.localeService = inject(AXLocaleService);
+        this.activeProfile = toSignal(this.localeService.profileChanged$, {
+            initialValue: this.localeService.activeProfile(),
+        });
+        this.registrations = signal([], ...(ngDevMode ? [{ debugName: "registrations" }] : /* istanbul ignore next */ []));
+        this.helpDialogHandler = null;
+        this.listenerAttached = false;
+        //#endregion
+        //#region ---- Computed Properties ----
+        /** Active shortcut entries for the help dialog. */
+        this.helpEntries = computed(() => {
+            this.activeProfile();
+            return this.buildHelpEntries();
+        }, ...(ngDevMode ? [{ debugName: "helpEntries" }] : /* istanbul ignore next */ []));
+        this.onDocumentKeyDown = (event) => {
+            if (event.key === 'Escape' && shouldDeferEscapeToOpenOverlay(this.document)) {
+                return;
+            }
+            if (event.key === 'F1') {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                if (hasForegroundOverlayLayer(this.document)) {
+                    return;
+                }
+            }
+            const candidates = this.resolveActiveCandidates(event);
+            if (candidates.length === 0) {
+                return;
+            }
+            const match = candidates[0];
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            void match.binding.handler(event);
+        };
+    }
+    //#endregion
+    //#region ---- Public Methods ----
+    /**
+     * Registers a scope of shortcuts. Unregisters automatically when `owner` is destroyed.
+     */
+    register(options) {
+        const { owner, ...registrationOptions } = options;
+        const registrationId = `${options.id}-${this.createRegistrationId()}`;
+        const entry = {
+            ...registrationOptions,
+            registrationId,
+            priority: options.priority ?? 0,
+        };
+        this.registrations.update((items) => [
+            ...items.filter((item) => item.id !== options.id),
+            entry,
+        ]);
+        this.ensureListener();
+        try {
+            owner.onDestroy(() => {
+                this.unregister(registrationId);
+            });
+        }
+        catch {
+            // Owner view was already destroyed (e.g. async registration after navigation).
+            this.unregister(registrationId);
+        }
+    }
+    /**
+     * Wires the F1 help dialog opener (provided by platform/common).
+     */
+    setHelpDialogHandler(handler) {
+        this.helpDialogHandler = handler;
+        this.ensureHelpShortcutRegistered();
+    }
+    /** OS-aware display string for UI hints. */
+    formatDisplayKeys(chords) {
+        return formatKeyboardShortcutChords(chords, { isRtl: this.isRtlProfile() });
+    }
+    //#endregion
+    //#region ---- Private Methods ----
+    ensureHelpShortcutRegistered() {
+        const alreadyRegistered = this.registrations().some((entry) => entry.id === 'system:keyboard-shortcuts-help');
+        if (alreadyRegistered || !this.helpDialogHandler) {
+            return;
+        }
+        const handler = this.helpDialogHandler;
+        const entry = {
+            registrationId: 'system:keyboard-shortcuts-help',
+            id: 'system:keyboard-shortcuts-help',
+            priority: -1,
+            scope: '@general:keyboard-shortcuts.groups.system',
+            shortcuts: [
+                {
+                    keys: ['f1'],
+                    title: '@general:keyboard-shortcuts.help-action',
+                    allowInEditableFields: true,
+                    handler: () => {
+                        void handler();
+                    },
+                },
+            ],
+        };
+        this.registrations.update((items) => [...items, entry]);
+        this.ensureListener();
+    }
+    createRegistrationId() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    }
+    unregister(registrationId) {
+        this.registrations.update((items) => items.filter((item) => item.registrationId !== registrationId));
+    }
+    ensureListener() {
+        if (this.listenerAttached || typeof this.document === 'undefined') {
+            return;
+        }
+        this.document.addEventListener('keydown', this.onDocumentKeyDown, true);
+        this.listenerAttached = true;
+    }
+    resolveActiveCandidates(event) {
+        const editable = isKeyboardTargetInsideEditableField(event.target);
+        const candidates = [];
+        for (const registration of this.registrations()) {
+            if (!this.isRegistrationActive(registration)) {
+                continue;
+            }
+            const priority = registration.priority ?? 0;
+            for (const binding of registration.shortcuts) {
+                if (binding.when && !binding.when()) {
+                    continue;
+                }
+                if (editable && !binding.allowInEditableFields) {
+                    continue;
+                }
+                for (const chord of binding.keys) {
+                    const directionBehavior = resolveEffectiveDirectionBehavior(chord, binding.directionBehavior);
+                    if (!matchesKeyboardShortcutChord(event, chord, {
+                        directionBehavior,
+                        isRtl: this.isRtlProfile(),
+                    })) {
+                        continue;
+                    }
+                    candidates.push({
+                        priority,
+                        registration,
+                        binding,
+                        chord,
+                    });
+                    break;
+                }
+            }
+        }
+        return candidates.sort((a, b) => b.priority - a.priority);
+    }
+    isRegistrationActive(registration) {
+        if (registration.when && !registration.when()) {
+            return false;
+        }
+        const element = registration.elementRef?.nativeElement;
+        if (element && !this.document.contains(element)) {
+            return false;
+        }
+        return true;
+    }
+    isRtlProfile() {
+        return this.activeProfile()?.i18nMeta?.rtl === true;
+    }
+    buildHelpEntries() {
+        const entries = [];
+        const isRtl = this.isRtlProfile();
+        for (const registration of this.registrations()) {
+            if (!this.isRegistrationActive(registration)) {
+                continue;
+            }
+            if (registration.id === 'system:keyboard-shortcuts-help') {
+                continue;
+            }
+            const priority = registration.priority ?? 0;
+            for (const binding of registration.shortcuts) {
+                const displayChords = binding.keys.map((chord) => {
+                    const directionBehavior = resolveEffectiveDirectionBehavior(chord, binding.directionBehavior);
+                    return resolveDisplayShortcutChord(chord, isRtl, directionBehavior);
+                });
+                entries.push({
+                    registrationId: registration.registrationId,
+                    bindingTitle: binding.title,
+                    chords: [...binding.keys],
+                    displayChords,
+                    displayKeys: formatKeyboardShortcutChords(displayChords, { skipDirectionResolve: true }),
+                    scope: registration.scope,
+                    group: binding.group ?? registration.group,
+                    priority,
+                });
+            }
+        }
+        return entries.sort((a, b) => b.priority - a.priority || a.bindingTitle.localeCompare(b.bindingTitle));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPKeyboardShortcutRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ---- Dialog Action Shortcut Utilities ----
+const DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS = ['Esc'];
+const DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS = ['Enter', 'ctrl+s'];
+const PRIMARY_DIALOG_ACTION_COMMANDS = new Set([
+    'submit',
+    'create',
+    'apply',
+    'save',
+    'select',
+    'entity-form-done',
+    'upload-image',
+]);
+/**
+ * Parses a shortcut string such as `Enter`, `Escape`, or `ctrl+shift+s`.
+ */
+function parseDialogActionShortcut(shortcut) {
+    const parts = shortcut
+        .trim()
+        .toLowerCase()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const key = normalizeShortcutToken(parts.pop() ?? '');
+    return {
+        ctrl: parts.includes('ctrl') || parts.includes('control'),
+        shift: parts.includes('shift'),
+        alt: parts.includes('alt') || parts.includes('option'),
+        meta: parts.includes('meta') || parts.includes('cmd') || parts.includes('command'),
+        key,
+    };
+}
+/**
+ * Returns true when the keyboard event matches the given shortcut definition.
+ */
+function matchesDialogActionShortcut(event, shortcut) {
+    const parsed = parseDialogActionShortcut(shortcut);
+    if (parsed.ctrl !== event.ctrlKey) {
+        return false;
+    }
+    if (parsed.shift !== event.shiftKey) {
+        return false;
+    }
+    if (parsed.alt !== event.altKey) {
+        return false;
+    }
+    if (parsed.meta !== event.metaKey) {
+        return false;
+    }
+    return normalizeShortcutKey(event) === normalizeShortcutToken(parsed.key);
+}
+/**
+ * Resolves footer action shortcuts: defaults when omitted, merge when extras are provided, none when `[]`.
+ */
+function resolveDialogActionShortcuts(defaults, overrides) {
+    if (overrides !== undefined) {
+        if (overrides.length === 0) {
+            return undefined;
+        }
+        return flattenDialogActionShortcutChords([...defaults, ...overrides]);
+    }
+    return flattenDialogActionShortcutChords(defaults);
+}
+/**
+ * Applies built-in footer shortcuts when actions are declared without `shortcuts`
+ * (e.g. workflow `show-layout-popup` raw action config).
+ */
+function resolveConfiguredFooterActionShortcuts(command, explicit) {
+    if (explicit !== undefined) {
+        return resolveDialogActionShortcuts([], explicit);
+    }
+    if (command === 'cancel') {
+        return resolveDialogActionShortcuts(DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS, undefined);
+    }
+    if (command && PRIMARY_DIALOG_ACTION_COMMANDS.has(command)) {
+        return resolveDialogActionShortcuts(DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS, undefined);
+    }
+    return undefined;
+}
+function flattenDialogActionShortcutChords(shortcuts) {
+    const chords = normalizeKeyboardShortcuts(shortcuts).flatMap((shortcut) => shortcut.keys);
+    const deduped = dedupeDialogActionShortcuts(chords);
+    return deduped.length ? deduped : undefined;
+}
+function dedupeDialogActionShortcuts(shortcuts) {
+    const seen = new Set();
+    const result = [];
+    for (const shortcut of shortcuts) {
+        const token = normalizeShortcutToken(shortcut);
+        if (!token || seen.has(token)) {
+            continue;
+        }
+        seen.add(token);
+        result.push(shortcut.trim());
+    }
+    return result;
+}
+function normalizeShortcutToken(key) {
+    const normalized = key.trim().toLowerCase();
+    if (normalized === 'esc') {
+        return 'escape';
+    }
+    return normalized;
+}
+/**
+ * Whether a dialog footer shortcut may fire while focus is inside an editable field.
+ */
+function isDialogShortcutAllowedInEditableField(shortcut) {
+    const parsed = parseDialogActionShortcut(shortcut);
+    const isPlainEnter = parsed.key === 'enter' && !parsed.ctrl && !parsed.shift && !parsed.alt && !parsed.meta;
+    return !isPlainEnter;
+}
+/**
+ * Normalizes dialog footer chord strings for {@link AXPKeyboardShortcutRegistry} (`Esc` → `escape`).
+ */
+function normalizeDialogActionShortcutChord(shortcut) {
+    const parts = shortcut
+        .trim()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return shortcut.trim();
+    }
+    const key = normalizeShortcutToken(parts.pop() ?? '');
+    const modifiers = parts.map((part) => part.toLowerCase());
+    return modifiers.length ? `${modifiers.join('+')}+${key}` : key;
+}
+/**
+ * Whether a shortcut should fire given the current focus target.
+ * Enter without modifiers is suppressed in multiline / rich-text fields.
+ */
+function shouldTriggerDialogActionShortcut(event, shortcut) {
+    const parsed = parseDialogActionShortcut(shortcut);
+    const isPlainEnter = parsed.key === 'enter' && !parsed.ctrl && !parsed.shift && !parsed.alt && !parsed.meta;
+    if (!isPlainEnter) {
+        return true;
+    }
+    return !isKeyboardTargetMultilineEditable(event.target);
+}
+function normalizeShortcutKey(event) {
+    if (event.key === 'Enter') {
+        return 'enter';
+    }
+    if (event.key === 'Escape') {
+        return 'escape';
+    }
+    if (event.key === ' ') {
+        return 'space';
+    }
+    if (event.key.length === 1) {
+        return event.key.toLowerCase();
+    }
+    const codeMatch = event.code.match(/^Key([A-Z])$/);
+    if (codeMatch) {
+        return codeMatch[1].toLowerCase();
+    }
+    const digitMatch = event.code.match(/^Digit([0-9])$/);
+    if (digitMatch) {
+        return digitMatch[1];
+    }
+    return event.key.toLowerCase();
+}
+function isKeyboardTargetMultilineEditable(target) {
+    if (!(target instanceof HTMLElement)) {
+        return false;
+    }
+    if (target.isContentEditable) {
+        return true;
+    }
+    const textarea = target.closest('textarea');
+    if (textarea && !textarea.readOnly && !textarea.disabled) {
+        return true;
+    }
+    const richText = target.closest('[contenteditable="true"]');
+    return richText instanceof HTMLElement;
+}
+//#endregion
+
+//#region ---- Popup Footer Keyboard Shortcuts ----
+/**
+ * Registers popup footer shortcuts at modal priority so they win over page bindings and stop bubbling.
+ */
+function registerPopupFooterKeyboardShortcuts(options) {
+    const group = '@general:keyboard-shortcuts.groups.dialog';
+    const scope = options.scope ?? group;
+    const shortcuts = [];
+    for (const action of options.actions) {
+        if (action.hidden?.()) {
+            continue;
+        }
+        const chords = action.shortcuts !== undefined
+            ? resolveConfiguredFooterActionShortcuts(action.command, action.shortcuts)
+            : resolveConfiguredFooterActionShortcuts(action.command, undefined);
+        if (!chords?.length) {
+            continue;
+        }
+        for (const shortcut of chords) {
+            shortcuts.push({
+                keys: [normalizeDialogActionShortcutChord(shortcut)],
+                title: action.title,
+                group,
+                allowInEditableFields: isDialogShortcutAllowedInEditableField(shortcut),
+                when: () => {
+                    if (options.when && !options.when()) {
+                        return false;
+                    }
+                    if (action.hidden?.()) {
+                        return false;
+                    }
+                    if (action.disabled?.()) {
+                        return false;
+                    }
+                    return true;
+                },
+                handler: () => {
+                    void action.handler();
+                },
+            });
+        }
+    }
+    options.registry.register({
+        owner: options.owner,
+        elementRef: options.elementRef,
+        id: options.id,
+        priority: AXPKeyboardShortcutPriority.Modal,
+        scope,
+        when: options.when,
+        shortcuts,
+    });
+}
+/**
+ * Binds footer shortcuts for AXPopupService-hosted components. Call from the popup constructor.
+ */
+function setupPopupFooterKeyboardShortcuts(getActions, config) {
+    const destroyRef = inject(DestroyRef);
+    const elementRef = inject(ElementRef);
+    const registry = inject(AXPKeyboardShortcutRegistry);
+    const id = config?.id ?? 'popup-footer';
+    effect(() => {
+        getActions();
+        config?.when?.();
+        untracked(() => {
+            registerPopupFooterKeyboardShortcuts({
+                registry,
+                owner: destroyRef,
+                elementRef,
+                id,
+                scope: config?.scope,
+                when: config?.when,
+                actions: getActions(),
+            });
+        });
+    });
+}
+//#endregion
+
+/** Global overlay flag + task count ({@link AXPLayoutThemeService}). */
+const OVERLAY_LAYOUT_TRACE_NS = 'OVERLAY-LAYOUT';
+/** Root shell loading dialog sync ({@link AXPRootLayoutComponent}). */
+const OVERLAY_ROOT_LAYOUT_TRACE_NS = 'OVERLAY-ROOT-LAYOUT';
+/** Details view page load and overlay release orchestration. */
+const OVERLAY_DETAILS_VIEW_TRACE_NS = 'OVERLAY-DETAILS-VIEW';
+/** Widget tree mount / settle polling ({@link AXPWidgetContainerComponent}). */
+const OVERLAY_WIDGET_SETTLE_TRACE_NS = 'OVERLAY-WIDGET-SETTLE';
+
+//#region ----   Imports   ----
+//#endregion
+
+//#region ----   Provider Interfaces   ----
+/**
+ * Injection token for session service.
+ * Implementation: @acorex-platform/framework-client/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 ----
+/**
+ * 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: AXPPlatformCoreDataSourceKeys.ModuleManifests,
+                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.translationService = inject(AXTranslationService);
+        this.tasks = [];
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    registerTask(task) {
+        this.tasks.push(task);
+    }
+    async runAllTasks() {
+        for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
+            await this.updateStatus(task.statusText);
+            await task.run();
+        }
+    }
+    async updateStatus(status) {
+        const loadingText = document.querySelector('#loadingText');
+        if (loadingText) {
+            const translatedStatus = this.translationService.resolve(status);
+            loadingText.innerHTML = await this.translationService.translateAsync(translatedStatus);
+        }
+    }
+    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: '@general:app-startup.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 ---- Constants ----
+const DEFAULT_IDLE_TIMEOUT_MS = 2_000;
+const DEFAULT_MIN_IDLE_MS = 16;
+//#endregion
+//#region ---- Service ----
+/**
+ * Schedules low-priority work during browser idle periods.
+ * Pauses when the tab is hidden or when explicitly paused (e.g. user-initiated seeding).
+ */
+class AXPIdleSchedulerService {
+    constructor() {
+        //#region ---- State ----
+        this.pausedState = signal(false, ...(ngDevMode ? [{ debugName: "pausedState" }] : /* istanbul ignore next */ []));
+        this.paused = this.pausedState.asReadonly();
+        this.queue = [];
+        this.running = false;
+    }
+    //#endregion
+    //#region ---- Public API ----
+    pause() {
+        this.pausedState.set(true);
+    }
+    resume() {
+        this.pausedState.set(false);
+        void this.drainQueue();
+    }
+    /**
+     * Resolves after the browser reports idle time, or after timeoutMs (whichever comes first).
+     */
+    waitForIdle(options) {
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+        const minIdleMs = options?.minIdleMs ?? DEFAULT_MIN_IDLE_MS;
+        if (this.pausedState() || typeof document !== 'undefined' && document.visibilityState === 'hidden') {
+            return delay(timeoutMs);
+        }
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve();
+            };
+            const timeoutId = setTimeout(finish, timeoutMs);
+            if (typeof requestIdleCallback === 'function') {
+                requestIdleCallback(() => {
+                    clearTimeout(timeoutId);
+                    finish();
+                }, { timeout: timeoutMs });
+            }
+            else {
+                clearTimeout(timeoutId);
+                setTimeout(finish, minIdleMs);
+            }
+        });
+    }
+    /** Enqueues async work processed sequentially during idle slices. */
+    enqueue(task, options) {
+        if (options?.key) {
+            this.queue = this.queue.filter((item) => item.key !== options.key);
+        }
+        this.queue.push({ key: options?.key, task });
+        void this.drainQueue();
+    }
+    //#endregion
+    //#region ---- Private ----
+    async drainQueue() {
+        if (this.running || this.pausedState()) {
+            return;
+        }
+        this.running = true;
+        try {
+            while (this.queue.length > 0 && !this.pausedState()) {
+                const next = this.queue.shift();
+                if (!next)
+                    break;
+                await this.waitForIdle();
+                try {
+                    await next.task();
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    console.error('[AXPIdleScheduler] Task failed:', message);
+                }
+            }
+        }
+        finally {
+            this.running = false;
+            if (this.queue.length > 0 && !this.pausedState()) {
+                void this.drainQueue();
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPIdleSchedulerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPIdleSchedulerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPIdleSchedulerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ---- Idle scheduler types ----
+//#endregion
+
+//#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',
+                }]
+        }] });
+
+function applySystemActionDefault(action, type) {
+    const systemAction = getSystemActions(type);
+    return {
+        ...action,
+        name: action.name ?? systemAction.key,
+        title: action.title ?? systemAction.title,
+        icon: action.icon ?? systemAction.icon,
+        color: action.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;
+    }
+}
+
+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
+//#region ---- Multilingual string helpers ----
+/**
+ * Lowercased text for client-side filtering: plain string or all locale values joined.
+ */
+function toFilterSearchText(value) {
+    if (typeof value === 'string') {
+        return value.toLowerCase();
+    }
+    if (isLocaleStringMap(value)) {
+        return Object.values(value).join(' ').toLowerCase();
+    }
+    return undefined;
+}
+function toSortComparableValue(value, locale) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.toLocaleLowerCase(locale);
+    }
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (isLocaleStringMap(value)) {
+        return resolveMultiLanguageString(value, locale).toLocaleLowerCase(locale);
+    }
+    return String(value).toLocaleLowerCase(locale);
+}
+function filterValuesAreEqual(itemRaw, condRaw) {
+    if (typeof condRaw === 'string' && isLocaleStringMap(itemRaw)) {
+        return Object.values(itemRaw).some((v) => v.toLowerCase() === condRaw.toLowerCase());
+    }
+    if (typeof itemRaw === 'string' && isLocaleStringMap(condRaw)) {
+        return Object.values(condRaw).some((v) => v.toLowerCase() === itemRaw.toLowerCase());
+    }
+    const itemScalar = typeof itemRaw === 'string' ? itemRaw.toLowerCase() : itemRaw;
+    const condScalar = typeof condRaw === 'string' ? condRaw.toLowerCase() : condRaw;
+    return isEqual(itemScalar, condScalar);
+}
+//#endregion
+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':
+            if (!isNil(condition.field) && condition.field !== '') {
+                result = filterValuesAreEqual(rawValue, condition.value);
+            }
+            else {
+                result = isEqual(valueToCompare, conditionValue);
+            }
+            if (loggingEnabled) {
+                console.log('Equal check result:', result);
+            }
+            break;
+        case 'notEqual':
+        case 'ne':
+        case 'neq':
+            if (!isNil(condition.field) && condition.field !== '') {
+                result = !filterValuesAreEqual(rawValue, condition.value);
+            }
+            else {
+                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': {
+            const needle = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystack = toFilterSearchText(rawValue);
+            if (haystack !== undefined) {
+                result = includes(haystack, needle);
+            }
+            else if (Array.isArray(rawValue)) {
+                result = includes(rawValue.map((val) => toFilterSearchText(val) ?? val.toString().toLowerCase()), needle);
+            }
+            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 (isLocaleStringMap(rawValue)) {
+                    const localeValues = Object.values(rawValue).map((v) => v.toLowerCase());
+                    result = localeValues.some((localeVal) => conditionValue.some((val) => typeof val === 'string' ? val.toLowerCase() === localeVal : val === localeVal));
+                }
+                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': {
+            const needleNc = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackNc = toFilterSearchText(rawValue);
+            if (haystackNc !== undefined) {
+                result = !includes(haystackNc, needleNc);
+            }
+            else if (Array.isArray(rawValue)) {
+                result = !includes(rawValue.map((val) => toFilterSearchText(val) ?? val.toString().toLowerCase()), needleNc);
+            }
+            else {
+                result = false;
+            }
+            if (loggingEnabled) {
+                console.log('Not contains check result:', result);
+            }
+            break;
+        }
+        case 'startsWith': {
+            const prefix = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackSw = toFilterSearchText(rawValue);
+            result = haystackSw !== undefined && startsWith(haystackSw, prefix);
+            if (loggingEnabled) {
+                console.log('Starts with check result:', result);
+            }
+            break;
+        }
+        case 'endsWith': {
+            const suffix = toFilterSearchText(condition.value) ??
+                (condition.value == null ? '' : String(condition.value).toLowerCase());
+            const haystackEw = toFilterSearchText(rawValue);
+            result = haystackEw !== undefined && endsWith(haystackEw, suffix);
+            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, locale = 'en-US') {
+    if (sorts && sorts.length > 0) {
+        const iteratees = sorts.map((s) => (item) => toSortComparableValue(get(item, s.field), locale));
+        const sortOrders = sorts.map((s) => (s.dir === 'desc' ? 'desc' : 'asc'));
+        return orderBy(dataArray, iteratees, 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,
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPCatalogScopeDefinitionProviderService, AXPCatalogScopeDefinitionsDataSourceDefinition, AXPColorPaletteProvider, AXPColorPaletteService, AXPColumnWidthService, AXPComponentLogoConfig, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPContentCheckerDirective, AXPContextDefinitionProviderService, AXPContextEvalFactory, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDebugService, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPIdleSchedulerService, AXPImageUrlLogoConfig, AXPKeyboardShortcutRegistry, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPModuleManifestsDataSourceDefinition, AXPScreenSize, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_COLUMN_WIDTH_PROVIDER, AXP_CONTEXT_DEFINITION_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, AX_OVERLAY_CONTAINER_SELECTOR, AX_OVERLAY_PANE_SELECTOR, DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS, DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS, FORM_DIRTY_TRACE_NS, OVERLAY_DETAILS_VIEW_TRACE_NS, OVERLAY_LAYOUT_TRACE_NS, OVERLAY_ROOT_LAYOUT_TRACE_NS, OVERLAY_WIDGET_SETTLE_TRACE_NS, applyContextEvalPipes, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, chordToKbdItemKeys, contextEvalWithPipes, createProviderWithInjectionContext, defaultColumnWidthProvider, findOverlayContainerAncestor, formatKeyboardShortcutChord, formatKeyboardShortcutChords, getNestedVisibleOverlayPanes, getPrimaryKeyboardShortcutChord, getTopVisibleOverlayContainer, getVisibleAnchoredOverlayPanes, getVisibleOverlayContainers, hasForegroundOverlayLayer, isDialogShortcutAllowedInEditableField, isHorizontalDirectionalShortcutKey, isKeyboardTargetInsideEditableField, isMacPlatform, isVisibleOverlayElement, matchesDialogActionShortcut, matchesKeyboardShortcutChord, mirrorHorizontalDirectionalKey, normalizeContextEvalPipes, normalizeDialogActionShortcutChord, normalizeExpressionTemplate, normalizeKeyboardShortcut, normalizeKeyboardShortcuts, objectKeyValueTransforms, parseDialogActionShortcut, parseKeyboardShortcutChord, provideLazyProvider, registerPopupFooterKeyboardShortcuts, resolveConfiguredFooterActionShortcuts, resolveDialogActionShortcuts, resolveDisplayShortcutChord, resolveEffectiveDirectionBehavior, resolveSemanticDirectionalKey, setupPopupFooterKeyboardShortcuts, shouldDeferEscapeToOpenOverlay, shouldTriggerDialogActionShortcut };
+//# sourceMappingURL=acorex-platform-framework-client-core.mjs.map