@acorex/platform 20.4.2 → 20.5.0-next.0

package/fesm2022/acorex-platform-core.mjs

@@ -1,11 +1,265 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, computed, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, Injector, runInInjectionContext, provideAppInitializer, signal, Pipe } from '@angular/core';
 import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
 import { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, isEqual, differenceWith, union, cloneDeep, isUndefined, endsWith, startsWith, includes, lte, gte, lt, gt, orderBy } from 'lodash-es';
-import * as i0 from '@angular/core';
-import { computed, InjectionToken, inject, Injectable, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, provideAppInitializer, signal, Pipe, Injector, runInInjectionContext } from '@angular/core';
 import { Subject, interval } from 'rxjs';
 import { AXCalendarService } from '@acorex/core/date-time';
 import { startWith, map } 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: "20.3.4", ngImport: i0, type: AXPActivityLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPActivityLogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPActivityLogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXPActivityLogProvider {
+}
+
+//#region ----   Color Palette Provider   ----
+/**
+ * Abstract class for color palette providers
+ * Implement this to provide palettes from different sources (system, app, module, etc.)
+ */
+class AXPColorPaletteProvider {
+}
+/**
+ * Injection token for color palette providers
+ * Use this to register multiple palette providers
+ */
+const AXP_COLOR_PALETTE_PROVIDER = new InjectionToken('AXP_COLOR_PALETTE_PROVIDER');
+//#endregion
+
+//#region ----   Color Palette Service   ----
+/**
+ * Service for managing color palettes from multiple providers
+ * Aggregates palettes from all registered providers
+ */
+class AXPColorPaletteService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.providers = inject(AXP_COLOR_PALETTE_PROVIDER, { optional: true }) ?? [];
+        //#endregion
+        //#region ----   State   ----
+        this.cache = null;
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get all palettes from all providers
+     * @param options Filter options
+     * @returns Promise of palettes
+     */
+    async getPalettes(options) {
+        if (!this.cache) {
+            await this.loadPalettes();
+        }
+        let palettes = this.cache;
+        // Apply category filter
+        if (options?.category) {
+            palettes = palettes.filter((palette) => palette.category === options.category);
+        }
+        // Apply search filter
+        if (options?.search) {
+            const searchLower = options.search.toLowerCase();
+            palettes = palettes.filter((palette) => palette.name.toLowerCase().includes(searchLower) ||
+                palette.title.toLowerCase().includes(searchLower) ||
+                palette.description?.toLowerCase().includes(searchLower));
+        }
+        return palettes;
+    }
+    /**
+     * Get a palette by name
+     * @param name The unique name of the palette
+     * @returns Promise of palette or undefined if not found
+     */
+    async getPalette(name) {
+        if (!this.cache) {
+            await this.loadPalettes();
+        }
+        return this.cache.find((p) => p.name === name);
+    }
+    /**
+     * Get palettes by category
+     * @param category The category to filter by
+     * @returns Promise of palettes in the specified category
+     */
+    async getByCategory(category) {
+        return this.getPalettes({ category });
+    }
+    /**
+     * Check if a palette exists
+     * @param name The unique name of the palette
+     * @returns Promise of true if the palette exists
+     */
+    async has(name) {
+        const palette = await this.getPalette(name);
+        return palette !== undefined;
+    }
+    /**
+     * Reload palettes from all providers
+     */
+    async reload() {
+        this.cache = null;
+        await this.loadPalettes();
+    }
+    //#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: "20.3.4", ngImport: i0, type: AXPColorPaletteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPColorPaletteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", 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: "20.3.4", ngImport: i0, type: AXPDefaultColorPalettesProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDefaultColorPalettesProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDefaultColorPalettesProvider, decorators: [{
+            type: Injectable
+        }] });
+
 function extractNestedFieldsWildcard(obj, basePath, fields) {
     const result = {};
     if (fields.length === 1 && fields[0] === '*') {
@@ -712,6 +966,152 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
                 }]
         }] });
 
+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: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 class AXPBroadcastEventService {
     constructor() {
         this.eventSubjects = new Map();
@@ -991,6 +1391,60 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+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: "20.3.4", ngImport: i0, type: AXPHookService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPHookService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPHookService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class AXPAppStartUpService {
     constructor() {
         this.tasks = [];
@@ -998,35 +1452,197 @@ class AXPAppStartUpService {
     registerTask(task) {
         this.tasks.push(task);
     }
-    async runAllTasks() {
-        for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
-            console.log(`Running "${task.statusText}" with priority "${task.priority}"`);
-            this.updateStatus(task.statusText);
-            await task.run();
+    async runAllTasks() {
+        for (const task of this.tasks.sort((a, b) => a.priority - b.priority)) {
+            console.log(`Running "${task.statusText}" with priority "${task.priority}"`);
+            this.updateStatus(task.statusText);
+            await task.run();
+        }
+    }
+    updateStatus(status) {
+        const loadingText = document.querySelector('#loadingText');
+        if (loadingText) {
+            loadingText.innerHTML = status;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPAppStartUpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+function initAppFactory(appInitService) {
+    return () => appInitService.runAllTasks();
+}
+const AXPAppStartUpProvider = provideAppInitializer(() => {
+    const initializerFn = initAppFactory(inject(AXPAppStartUpService));
+    return initializerFn();
+});
+
+//#region ----   Tag Types   ----
+//#endregion
+
+//#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;
     }
-    updateStatus(status) {
-        const loadingText = document.querySelector('#loadingText');
-        if (loadingText) {
-            loadingText.innerHTML = status;
+    /**
+     * Reload tags from all providers
+     */
+    async reload() {
+        this.cache = null;
+        await this.loadTags();
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Load tags from all providers
+     */
+    async loadTags() {
+        debugger;
+        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: "20.3.4", ngImport: i0, type: AXPAppStartUpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPAppStartUpService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPTagService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPTagService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPAppStartUpService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPTagService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
-function initAppFactory(appInitService) {
-    return () => appInitService.runAllTasks();
-}
-const AXPAppStartUpProvider = provideAppInitializer(() => {
-    const initializerFn = initAppFactory(inject(AXPAppStartUpService));
-    return initializerFn();
-});
 
 /**
  * Additional suggested generic actions for future consideration:
@@ -2382,231 +2998,9 @@ function extractTextFromHtml(value) {
     return div.textContent || div.innerText || '';
 }
 
-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: "20.3.4", ngImport: i0, type: AXPActivityLogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPActivityLogService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPActivityLogService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class AXPActivityLogProvider {
-}
-
-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: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPDistributedEventListenerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-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: "20.3.4", ngImport: i0, type: AXPHookService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPHookService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPHookService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPHookService, AXPImageUrlLogoConfig, AXPPlatformScope, AXPSystemActionType, AXPSystemActions, AXP_ACTIVITY_LOG_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPHookService, AXPImageUrlLogoConfig, AXPPlatformScope, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_TAG_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
 //# sourceMappingURL=acorex-platform-core.mjs.map