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

package/fesm2022/acorex-platform-workflow.mjs

@@ -1,14 +1,9 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, InjectionToken, Optional, SkipSelf, Inject, NgModule } from '@angular/core';
+import { Injectable, inject, Optional, Inject, NgModule, InjectionToken } from '@angular/core';
 import { Subject, filter } from 'rxjs';
 import { cloneDeep, get, set } from 'lodash-es';
 import { setSmart } from '@acorex/platform/core';
-import { AXPCommandService, AXPCommandRegistry, AXPQueryService, provideCommandSetups, AXP_COMMAND_SETUP } from '@acorex/platform/runtime';
-import { AXDialogService } from '@acorex/components/dialog';
-import { AXTranslationService } from '@acorex/core/translation';
-import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
-import { AXToastService } from '@acorex/components/toast';
-import { Router } from '@angular/router';
+import { AXPCommandService } from '@acorex/platform/runtime';
 
 class AXPWorkflowError extends Error {
     constructor(message, inner = null) {
@@ -416,6 +411,108 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
                 }]
         }] });
 
+class AXPWorkflowModule {
+    static forRoot(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
+                        registry.registerAction('decide', AXPWorkflowDecideAction);
+                        //
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true,
+                },
+                ...Object.values(config?.actions ?? { AXPStartWorkflowAction }),
+                ...Object.values(config?.functions ?? {}),
+            ],
+        };
+    }
+    static forChild(config) {
+        return {
+            ngModule: AXPWorkflowModule,
+            providers: [
+                // Built-in activities are already registered in forRoot via @NgModule providers
+                // No need to register again in forChild
+                {
+                    provide: 'AXPWorkflowModuleFactory',
+                    useFactory: (registry) => () => {
+                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
+                        registry.registerAction('decide', AXPWorkflowDecideAction);
+                        //
+                        if (config?.functions) {
+                            for (const [key, type] of Object.entries(config.functions)) {
+                                registry.registerFunction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.actions) {
+                            for (const [key, type] of Object.entries(config.actions)) {
+                                registry.registerAction(key, type);
+                            }
+                        }
+                        //
+                        if (config?.workflows) {
+                            for (const [key, type] of Object.entries(config.workflows)) {
+                                registry.registerWorkflow(key, type);
+                            }
+                        }
+                    },
+                    deps: [AXPWorkflowRegistryService],
+                    multi: true,
+                },
+                ...Object.values(config?.actions ?? {}),
+                ...Object.values(config?.functions ?? {}),
+            ],
+        };
+    }
+    /**
+     * @ignore
+     */
+    constructor(instances) {
+        instances?.forEach((f) => {
+            f();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [],
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AXPWorkflowModuleFactory']
+                }] }] });
+
 /**
  * Injection token for workflow definition loaders.
  * Multiple loaders can be provided (multi: true).
@@ -578,256 +675,435 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 // Compatible with Elsa backend while using ACoreX naming conventions
 // ============================================
 
+const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER', {
+    factory: () => [],
+});
+const AXP_ACTIVITY_CATEGORY_PROVIDER = new InjectionToken('AXP_ACTIVITY_CATEGORY_PROVIDER', {
+    factory: () => [],
+});
+
+//#region ----   Imports   ----
+//#endregion
 /**
- * Base abstract class for activities.
- * Extend this to create custom activities.
+ * Optimized Activity Definition Service
+ *
+ * Manages activity definitions (metadata) for UI and tooling.
+ * Similar to AXPReportDefinitionService - only handles metadata, not execution.
+ *
+ * Performance optimizations:
+ * 1. Uses childrenCount to determine if category has children (no query needed)
+ * 2. Uses itemsCount to determine if category has activities (no query needed)
+ * 3. Aggressive caching prevents duplicate API calls
+ * 4. Single pending request per resource prevents race conditions
+ * 5. Lazy loading - only loads data when needed
  */
-class Activity {
-    constructor(type, name) {
-        this.type = type;
-        this.name = name;
+class AXPActivityDefinitionService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.categoryProviders = inject(AXP_ACTIVITY_CATEGORY_PROVIDER, { optional: true }) || [];
+        this.activityProviders = inject(AXP_ACTIVITY_PROVIDER, { optional: true }) || [];
+        //#endregion
+        //#region ----   Cache Storage   ----
+        /** Cache for categories by id - O(1) lookup */
+        this.categoriesById = new Map();
+        /** Cache for categories by parentId - O(1) lookup */
+        this.categoriesByParentId = new Map();
+        /** Cache for activity definitions by categoryId - O(1) lookup */
+        this.activitiesByCategory = new Map();
+        /** Cache for individual activity definitions by name - O(1) lookup */
+        this.activitiesByName = new Map();
+        /** Track which provider index owns each category (by category ID) */
+        this.categoryOwnership = new Map(); // Maps categoryId → provider index
+        /** Pending API requests to prevent duplicate calls */
+        this.pendingCategoriesRequests = new Map();
+        this.pendingActivitiesRequests = new Map();
+        this.pendingActivityRequests = new Map();
     }
+    //#endregion
+    //#region ----   Initialization   ----
+    //#endregion
+    //#region ----   Public API: Categories   ----
     /**
-     * Helper method that returns Done outcome by default.
+     * Get categories by parentId with aggressive caching
+     *
+     * Optimization: Returns cached result immediately if available,
+     * preventing unnecessary API calls during navigation
+     *
+     * @param parentId - Parent category ID (undefined = root categories)
+     * @returns Array of categories with count metadata (childrenCount, itemsCount)
      */
-    createResult(output, outcome = 'Done') {
-        return {
-            success: true,
-            data: {
-                output,
-                outcomes: { [outcome]: true },
-            },
-        };
-    }
-}
-/**
- * Activity registry for registering and creating activities.
- */
-class ActivityRegistry {
-    constructor() {
-        this.registry = new Map();
-        this.descriptors = new Map();
+    async getCategories(parentId) {
+        // ✅ Fast path: Return cached result
+        if (this.categoriesByParentId.has(parentId)) {
+            return this.categoriesByParentId.get(parentId);
+        }
+        // ✅ Prevent duplicate requests: Return pending promise
+        if (this.pendingCategoriesRequests.has(parentId)) {
+            return this.pendingCategoriesRequests.get(parentId);
+        }
+        // ✅ Create single request and cache it
+        const requestPromise = this.loadCategoriesFromProviders(parentId);
+        this.pendingCategoriesRequests.set(parentId, requestPromise);
+        return requestPromise;
     }
     /**
-     * Register an activity type.
+     * Get single category by ID with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval, falls back to
+     * searching cache, then providers if not found
      */
-    register(type, factory, descriptor) {
-        this.registry.set(type, factory);
-        this.descriptors.set(type, descriptor);
+    async getCategoryById(categoryId) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.categoriesById.has(categoryId)) {
+            return this.categoriesById.get(categoryId);
+        }
+        // ✅ Search in cached parent-child lists
+        for (const categories of this.categoriesByParentId.values()) {
+            const found = categories.find(cat => cat.id === categoryId);
+            if (found) {
+                this.categoriesById.set(categoryId, found);
+                return found;
+            }
+        }
+        // ✅ Load root categories if not loaded
+        if (!this.categoriesByParentId.has(undefined)) {
+            await this.getCategories();
+            if (this.categoriesById.has(categoryId)) {
+                return this.categoriesById.get(categoryId);
+            }
+        }
+        // ✅ Breadth-first search through hierarchy
+        return this.searchCategoryInHierarchy(categoryId);
     }
     /**
-     * Create an activity instance.
+     * Get category path from root to specified category
+     *
+     * Optimization: Builds path using cached categories only
      */
-    create(type) {
-        const factory = this.registry.get(type);
-        if (!factory) {
-            throw new Error(`Unknown activity type: ${type}`);
+    async getCategoriesPathById(categoryId) {
+        const path = [];
+        let currentCategoryId = categoryId;
+        while (currentCategoryId) {
+            const category = await this.getCategoryById(currentCategoryId);
+            if (!category) {
+                throw new Error(`Category '${currentCategoryId}' not found`);
+            }
+            path.unshift(category);
+            currentCategoryId = category.parentId;
         }
-        return factory();
+        return path;
     }
+    //#endregion
+    //#region ----   Public API: Activity Definitions   ----
     /**
-     * Get activity descriptor.
+     * Get activity definitions for a category with smart caching
+     *
+     * Optimization: Checks itemsCount before querying
+     * - If itemsCount = 0, returns empty array (no API call)
+     * - If itemsCount > 0, loads and caches activity definitions
+     * - Returns cached result on subsequent calls
+     *
+     * @param categoryId - Category ID to get activity definitions from
+     * @returns Array of activity definitions
      */
-    getDescriptor(type) {
-        return this.descriptors.get(type);
+    async getActivitiesByCategoryId(categoryId) {
+        // ✅ Fast path: Return cached result
+        if (this.activitiesByCategory.has(categoryId)) {
+            return this.activitiesByCategory.get(categoryId);
+        }
+        // ✅ Smart optimization: Check itemsCount before querying
+        const category = await this.getCategoryById(categoryId);
+        if (category && category.itemsCount !== undefined && category.itemsCount === 0) {
+            // Category has no activities - cache empty array and skip API call
+            const emptyArray = [];
+            this.activitiesByCategory.set(categoryId, emptyArray);
+            return emptyArray;
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingActivitiesRequests.has(categoryId)) {
+            return this.pendingActivitiesRequests.get(categoryId);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadActivitiesFromProviders(categoryId);
+        this.pendingActivitiesRequests.set(categoryId, requestPromise);
+        return requestPromise;
     }
     /**
-     * Get all registered types.
+     * Get single activity definition by name with O(1) lookup
+     *
+     * Optimization: Uses Map for instant retrieval
+     *
+     * @param name - Activity name (unique identifier and command key)
+     * @returns Activity definition or undefined if not found
      */
-    getTypes() {
-        return Array.from(this.registry.keys());
+    async getActivityByName(name) {
+        // ✅ Fast path: O(1) lookup in cache
+        if (this.activitiesByName.has(name)) {
+            return this.activitiesByName.get(name);
+        }
+        // ✅ Prevent duplicate requests
+        if (this.pendingActivityRequests.has(name)) {
+            return this.pendingActivityRequests.get(name);
+        }
+        // ✅ Load from providers
+        const requestPromise = this.loadActivityFromProviders(name);
+        this.pendingActivityRequests.set(name, requestPromise);
+        return requestPromise;
     }
     /**
-     * Get all descriptors.
+     * Get category ID containing a specific activity definition
+     *
+     * Optimization: Searches cache first, loads on-demand if needed
      */
-    getAllDescriptors() {
-        return Array.from(this.descriptors.values());
+    async getCategoryIdByActivityName(activityName) {
+        // ✅ Search in cached activity definitions
+        for (const [categoryId, definitions] of this.activitiesByCategory.entries()) {
+            if (definitions.some(def => def.name === activityName)) {
+                return categoryId;
+            }
+        }
+        // ✅ Try loading the activity definition to find its category
+        const definition = await this.getActivityByName(activityName);
+        if (definition && definition.category) {
+            // Try to find category by name/id
+            const categories = await this.getCategories();
+            const found = categories.find(cat => cat.id === definition.category || cat.title === definition.category);
+            if (found) {
+                return found.id;
+            }
+        }
+        return undefined;
     }
     /**
-     * Get descriptors by category.
+     * Get category path for an activity
      */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
-    }
-}
-
-/**
- * Injection token for activity providers.
- */
-const AXP_ACTIVITY_PROVIDER = new InjectionToken('AXP_ACTIVITY_PROVIDER');
-/**
- * Activity Provider Service.
- * Collects all activity providers and manages activity registration.
- */
-class AXPActivityProviderService {
-    constructor() {
-        this.activityDescriptors = new Map();
-        this.categories = [];
-        this.providers = [];
-        this.categoryProviders = [];
-        this.initialized = false;
-        this.commandService = inject(AXPCommandService);
-        this.commandRegistry = inject(AXPCommandRegistry);
+    async getCategoriesPathByActivityName(activityName) {
+        const categoryId = await this.getCategoryIdByActivityName(activityName);
+        if (!categoryId) {
+            throw new Error(`Activity '${activityName}' not found in any category`);
+        }
+        return this.getCategoriesPathById(categoryId);
     }
+    //#endregion
+    //#region ----   Private: Data Loading   ----
     /**
-     * Register an activity provider.
+     * Load categories from providers and cache results
+     *
+     * Optimization: Tracks provider ownership to avoid unnecessary API calls
+     * - For root (parentId = undefined): Query ALL providers
+     * - For children: Only query the provider that owns the parent
      */
-    registerProvider(provider) {
-        this.providers.push(provider);
-        if (this.initialized) {
-            this.initializeProvider(provider);
+    async loadCategoriesFromProviders(parentId) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.categoryProviders);
+            const categories = [];
+            // Determine which provider(s) to query
+            const providerIndicesToQuery = parentId
+                ? this.getProviderIndexForCategory(parentId)
+                : null; // Root: query all providers
+            for (let i = 0; i < resolvedProviders.length; i++) {
+                const p = resolvedProviders[i];
+                // Skip if we have a specific provider index and this isn't it
+                if (providerIndicesToQuery !== null && !providerIndicesToQuery.includes(i)) {
+                    continue;
+                }
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getList === 'function') {
+                    try {
+                        const cats = await p.value.getList(parentId);
+                        if (Array.isArray(cats) && cats.length > 0) {
+                            categories.push(...cats);
+                            // ✅ Track ownership: This provider INDEX owns these categories
+                            cats.forEach(cat => this.categoryOwnership.set(cat.id, i));
+                        }
+                    }
+                    catch {
+                        // Continue on error - try other providers
+                    }
+                }
+            }
+            // ✅ Cache results for fast subsequent access
+            this.categoriesByParentId.set(parentId, categories);
+            categories.forEach(cat => this.categoriesById.set(cat.id, cat));
+            return categories;
+        }
+        finally {
+            this.pendingCategoriesRequests.delete(parentId);
         }
     }
     /**
-     * Register a category provider.
+     * Get the provider index that owns a specific category
+     *
+     * @returns Array with provider index, or null if ownership unknown (query all)
      */
-    registerCategoryProvider(provider) {
-        this.categoryProviders.push(provider);
-        if (this.initialized) {
-            this.initializeCategoryProvider(provider);
+    getProviderIndexForCategory(categoryId) {
+        const ownerIndex = this.categoryOwnership.get(categoryId);
+        if (ownerIndex !== undefined) {
+            return [ownerIndex];
         }
+        // Ownership unknown - will query all providers (fallback)
+        return null;
     }
     /**
-     * Initialize all providers.
+     * Load activity definitions from providers and cache results
+     *
+     * Optimization: Only queries the provider that owns the category
+     * Uses provider INDEX to match category provider with activity provider
      */
-    async initialize() {
-        if (this.initialized)
-            return;
-        // Initialize category providers first
-        for (const provider of this.categoryProviders) {
-            await this.initializeCategoryProvider(provider);
+    async loadActivitiesFromProviders(categoryId) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.activityProviders);
+            const definitions = [];
+            // ✅ Smart routing: Get provider INDEX that owns this category
+            const ownerIndex = this.categoryOwnership.get(categoryId);
+            const providerIndicesToQuery = ownerIndex !== undefined ? [ownerIndex] : null;
+            for (let i = 0; i < resolvedProviders.length; i++) {
+                const p = resolvedProviders[i];
+                // Skip if we have a specific provider index and this isn't it
+                if (providerIndicesToQuery !== null && !providerIndicesToQuery.includes(i)) {
+                    continue;
+                }
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getList === 'function') {
+                    try {
+                        const defs = await p.value.getList(categoryId);
+                        if (Array.isArray(defs)) {
+                            definitions.push(...defs);
+                        }
+                    }
+                    catch {
+                        // Continue on error - try other providers
+                    }
+                }
+            }
+            // ✅ Cache results for fast subsequent access
+            this.activitiesByCategory.set(categoryId, definitions);
+            definitions.forEach(def => {
+                if (def.name) {
+                    this.activitiesByName.set(def.name, def);
+                }
+            });
+            return definitions;
         }
-        // Initialize activity providers
-        for (const provider of this.providers) {
-            await this.initializeProvider(provider);
+        finally {
+            this.pendingActivitiesRequests.delete(categoryId);
         }
-        this.initialized = true;
     }
     /**
-     * Get activity descriptor by key.
+     * Load single activity definition from providers and cache result
      */
-    getDescriptor(key) {
-        return this.activityDescriptors.get(key);
+    async loadActivityFromProviders(name) {
+        try {
+            const resolvedProviders = await Promise.allSettled(this.activityProviders);
+            // Try providers first
+            for (const p of resolvedProviders) {
+                if (p.status === 'fulfilled' && p.value && typeof p.value.getById === 'function') {
+                    try {
+                        const result = await p.value.getById(name);
+                        if (result) {
+                            this.activitiesByName.set(name, result);
+                            return result;
+                        }
+                    }
+                    catch {
+                        // Continue on error
+                    }
+                }
+            }
+            // Fallback: Search in cached activity definitions
+            for (const definitions of this.activitiesByCategory.values()) {
+                const found = definitions.find(def => def.name === name);
+                if (found) {
+                    this.activitiesByName.set(name, found);
+                    return found;
+                }
+            }
+            return undefined;
+        }
+        finally {
+            this.pendingActivityRequests.delete(name);
+        }
     }
     /**
-     * Get all activity descriptors.
+     * Breadth-first search through category hierarchy
      */
-    getAllDescriptors() {
-        return Array.from(this.activityDescriptors.values());
+    async searchCategoryInHierarchy(categoryId) {
+        const searchQueue = [undefined];
+        const searched = new Set();
+        while (searchQueue.length > 0) {
+            const parentId = searchQueue.shift();
+            if (searched.has(parentId))
+                continue;
+            searched.add(parentId);
+            const categories = await this.getCategories(parentId);
+            const found = categories.find(cat => cat.id === categoryId);
+            if (found) {
+                return found;
+            }
+            // ✅ Optimization: Only search children if childrenCount > 0
+            for (const category of categories) {
+                if (category.childrenCount > 0 && !searched.has(category.id)) {
+                    searchQueue.push(category.id);
+                }
+            }
+        }
+        return undefined;
     }
+    //#endregion
+    //#region ----   Cache Management   ----
     /**
-     * Get descriptors by category.
+     * Check if category has children (uses cached count)
      */
-    getDescriptorsByCategory(category) {
-        return this.getAllDescriptors().filter(d => d.category === category);
+    categoryHasChildren(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? category.childrenCount > 0 : false;
     }
     /**
-     * Get all categories.
+     * Check if category has activities (uses cached count)
      */
-    getCategories() {
-        return [...this.categories].sort((a, b) => (a.order || 999) - (b.order || 999));
+    categoryHasActivities(categoryId) {
+        const category = this.categoriesById.get(categoryId);
+        return category ? (category.itemsCount ?? 0) > 0 : false;
     }
     /**
-     * Create an activity instance by key using AXPCommandService.
+     * Clear all caches
      */
-    async createActivity(key) {
-        try {
-            // Check if command exists
-            if (!this.commandService.exists(key)) {
-                return null;
-            }
-            // Get command loader from registry
-            const loader = this.commandRegistry.getLoader(key);
-            if (!loader) {
-                return null;
-            }
-            // Create command instance
-            const command = await loader();
-            return command;
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    // ============================================
-    // PRIVATE METHODS
-    // ============================================
-    async initializeProvider(provider) {
-        const context = {
-            registerActivity: (config) => {
-                this.activityDescriptors.set(config.key, config.descriptor);
-            }
-        };
-        await provider.provide(context);
+    clearAllCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.activitiesByCategory.clear();
+        this.activitiesByName.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
+        this.pendingActivitiesRequests.clear();
+        this.pendingActivityRequests.clear();
     }
-    async initializeCategoryProvider(provider) {
-        const context = {
-            registerCategories: (categories) => {
-                this.categories.push(...categories);
-            }
-        };
-        await provider.provide(context);
+    /**
+     * Clear categories cache only
+     */
+    clearCategoriesCache() {
+        this.categoriesById.clear();
+        this.categoriesByParentId.clear();
+        this.categoryOwnership.clear();
+        this.pendingCategoriesRequests.clear();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, providedIn: 'root' }); }
+    /**
+     * Clear activities cache only
+     */
+    clearActivitiesCache() {
+        this.activitiesByCategory.clear();
+        this.activitiesByName.clear();
+        this.pendingActivitiesRequests.clear();
+        this.pendingActivityRequests.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityProviderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityDefinitionService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 
-/**
- * Injection token for activity category providers.
- */
-const AXP_ACTIVITY_CATEGORY_PROVIDER = new InjectionToken('AXP_ACTIVITY_CATEGORY_PROVIDER');
-class AXPActivityCategoryProviderService {
-    constructor(parent, providers = []) {
-        this.parent = parent;
-        this.providers = providers;
-        this.categories = new Map();
-        this.isInitialized = false;
-        if (!parent) {
-            this.initialize();
-        }
-    }
-    async initialize() {
-        if (this.isInitialized) {
-            return;
-        }
-        for (const provider of this.providers) {
-            await provider.provide({
-                registerCategories: (categories) => {
-                    categories.forEach(cat => this.categories.set(cat.name, cat));
-                }
-            });
-        }
-        this.isInitialized = true;
-    }
-    getAllCategories() {
-        return Array.from(this.categories.values()).sort((a, b) => (a.order || 0) - (b.order || 0));
-    }
-    getCategory(name) {
-        return this.categories.get(name);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, deps: [{ token: AXPActivityCategoryProviderService, optional: true, skipSelf: true }, { token: AXP_ACTIVITY_CATEGORY_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPActivityCategoryProviderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: AXPActivityCategoryProviderService, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [AXP_ACTIVITY_CATEGORY_PROVIDER]
-                }] }] });
-
 /**
  * Abstract service for workflow execution operations.
  *
@@ -1177,1340 +1453,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImpo
 
 // Production Workflow Coordinator (Frontend/Backend Separation)
 
-/**
- * WriteLine Activity - Simple console logging activity.
- *
- * Usage:
- * ```typescript
- * const activity = new WriteLine();
- * await activity.execute({ text: 'Hello World' });
- * ```
- */
-class WriteLine extends Activity {
-    constructor() {
-        super('WriteLine');
-    }
-    async execute(input) {
-        const text = input.text || '';
-        if (text !== undefined && text !== null) {
-            console.log(`[WriteLine] ${text}`);
-        }
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var writeLine_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    WriteLine: WriteLine
-});
-
-/**
- * Sequence Activity - Executes activities in sequential order.
- *
- * Usage:
- * ```typescript
- * const sequence = new Sequence();
- * sequence.activities = [activity1, activity2, activity3];
- * await sequence.execute({});
- * ```
- */
-class Sequence extends Activity {
-    constructor() {
-        super('Sequence');
-        /**
-         * Activities to execute in sequence.
-         */
-        this.activities = [];
-    }
-    async execute(input) {
-        // Execute all activities in sequence
-        for (const activity of this.activities) {
-            const result = await activity.execute(input);
-            if (!result.success) {
-                return {
-                    success: false,
-                    message: result.message,
-                    data: {
-                        output: undefined,
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
-            }
-        }
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var sequence_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Sequence: Sequence
-});
-
-/**
- * Show Confirm Dialog Activity - Displays confirmation dialog to user.
- *
- * Has two outcomes:
- * - 'Confirmed': User clicked confirm/yes
- * - 'Cancelled': User clicked cancel/no
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowConfirmDialog();
- * await dialog.execute({
- *   title: 'Confirm Delete',
- *   message: 'Are you sure?',
- *   color: 'danger'
- * });
- * ```
- */
-class ShowConfirmDialog extends Activity {
-    //#endregion
-    constructor() {
-        super('ShowConfirmDialog');
-        //#region ----   Services & Dependencies   ----
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { title = '', message = '', color = 'primary', defaultAction = 'cancel', align = 'horizontal', backdrop = false } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            const confirmResult = await this.dialogService.confirm(translatedTitle, translatedMessage, color, align, backdrop, defaultAction);
-            const result = confirmResult.result;
-            const action = result ? 'confirm' : 'cancel';
-            return this.createResult({
-                result,
-                action
-            }, result ? 'Confirmed' : 'Cancelled');
-        }
-        catch (err) {
-            console.error('[ShowConfirmDialog] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show confirm dialog',
-                },
-                data: {
-                    output: {
-                        result: false,
-                        action: 'error',
-                    },
-                    outcomes: {
-                        Cancelled: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var showConfirmDialog_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowConfirmDialog: ShowConfirmDialog
-});
-
-/**
- * Show Alert Dialog Activity - Displays alert dialog to user.
- *
- * Has one outcome:
- * - 'Done': User clicked OK
- *
- * Usage:
- * ```typescript
- * const dialog = new ShowAlertDialog();
- * await dialog.execute({
- *   title: 'Alert',
- *   message: 'This is an alert',
- *   color: 'info'
- * });
- * ```
- */
-class ShowAlertDialog extends Activity {
-    //#endregion
-    constructor() {
-        super('ShowAlertDialog');
-        //#region ----   Services & Dependencies   ----
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { title = '', message = '', color = 'primary' } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            await this.dialogService.alert(translatedTitle, translatedMessage, color);
-            return this.createResult({
-                result: true,
-                action: 'ok'
-            }, 'Done');
-        }
-        catch (err) {
-            console.error('[ShowAlertDialog] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show alert dialog',
-                },
-                data: {
-                    output: {
-                        result: false,
-                        action: 'error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var showAlertDialog_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowAlertDialog: ShowAlertDialog
-});
-
-/**
- * Show Dialog Layout Builder Activity - Displays dialog using Layout Builder.
- *
- * This activity allows you to create custom dialogs using the Layout Builder API.
- * It accepts JSON-serializable content (AXPWidgetNode) and actions configuration.
- *
- * The content can be created using Layout Builder and then converted to JSON:
- * ```typescript
- * const builder = layoutBuilderService.create();
- * builder.flex(flex => {
- *   flex.setDirection('column')
- *     .formField('First Name', field => {
- *       field.path('firstName');
- *       field.textBox({ placeholder: 'Enter first name' });
- *     });
- * });
- * const contentNode = builder.build();
- * ```
- *
- * Usage in Workflow:
- * ```typescript
- * const dialog = new ShowDialogLayoutBuilder();
- * await dialog.execute({
- *   title: 'User Information',
- *   size: 'md',
- *   context: { firstName: '', lastName: '' },
- *   content: {
- *     type: 'flex-layout',
- *     mode: 'edit',
- *     options: {
- *       flexDirection: 'column',
- *       gap: '16px'
- *     },
- *     children: [
- *       {
- *         type: 'form-field',
- *         mode: 'edit',
- *         options: {
- *           label: 'First Name',
- *           showLabel: true
- *         },
- *         children: [{
- *           type: 'text-editor',
- *           path: 'firstName',
- *           options: {
- *             placeholder: 'Enter first name'
- *           }
- *         }]
- *       }
- *     ]
- *   },
- *   actions: {
- *     cancel: '@general:actions.cancel.title',
- *     submit: '@general:actions.submit.title',
- *     custom: [{
- *       title: 'Save Draft',
- *       icon: 'fa-save',
- *       color: 'secondary',
- *       command: { name: 'save-draft' }
- *     }]
- *   }
- * });
- * ```
- *
- * Usage in JSON Workflow Definition:
- * ```json
- * {
- *   "type": "ShowDialogLayoutBuilder",
- *   "properties": {
- *     "title": "User Information",
- *     "size": "md",
- *     "context": { "firstName": "", "lastName": "" },
- *     "content": {
- *       "type": "flex-layout",
- *       "mode": "edit",
- *       "options": {
- *         "flexDirection": "column",
- *         "gap": "16px"
- *       },
- *       "children": [
- *         {
- *           "type": "form-field",
- *           "mode": "edit",
- *           "options": {
- *             "label": "First Name",
- *             "showLabel": true
- *           },
- *           "children": [{
- *             "type": "text-editor",
- *             "path": "firstName",
- *             "options": {
- *               "placeholder": "Enter first name"
- *             }
- *           }]
- *         }
- *       ]
- *     },
- *     "actions": {
- *       "cancel": "@general:actions.cancel.title",
- *       "submit": "@general:actions.submit.title"
- *     }
- *   }
- * }
- * ```
- */
-class ShowDialogLayoutBuilder extends Activity {
-    //#endregion
-    constructor() {
-        super('ShowDialogLayoutBuilder');
-        //#region ----   Services & Dependencies   ----
-        this.layoutBuilder = inject(AXPLayoutBuilderService);
-    }
-    async execute(input) {
-        const { title = '', size = 'md', context = {}, closeButton = false, message, content, actions } = input;
-        try {
-            // Create dialog using layout builder
-            const dialogRef = await this.layoutBuilder
-                .create()
-                .dialog(dialog => {
-                // Set basic dialog options
-                dialog
-                    .setTitle(title)
-                    .setSize(size)
-                    .setCloseButton(closeButton)
-                    .setContext(context);
-                // Set message if provided
-                if (message) {
-                    dialog.setMessage(message);
-                }
-                // Set content if provided
-                if (content) {
-                    // If content is already a flex-layout, use it directly
-                    // Otherwise, wrap it in a flex container with column direction
-                    if (content.type === 'flex-layout') {
-                        // Set content layout directly (accessing internal state of DialogContainerBuilder)
-                        dialog.contentLayout = content;
-                    }
-                    else {
-                        // Wrap content in a flex container
-                        const wrappedContent = {
-                            type: 'flex-layout',
-                            mode: 'edit',
-                            options: {
-                                flexDirection: 'column',
-                                gap: '10px',
-                            },
-                            children: [content],
-                        };
-                        dialog.contentLayout = wrappedContent;
-                    }
-                }
-                // Set actions if provided
-                if (actions) {
-                    dialog.setActions(actionBuilder => {
-                        if (actions.cancel) {
-                            actionBuilder.cancel(actions.cancel);
-                        }
-                        if (actions.submit) {
-                            actionBuilder.submit(actions.submit);
-                        }
-                        if (actions.custom) {
-                            actions.custom.forEach(action => {
-                                actionBuilder.custom(action);
-                            });
-                        }
-                    });
-                }
-            })
-                .show();
-            // Get user action and context
-            const action = dialogRef.action() || 'cancel';
-            const dialogContext = dialogRef.context();
-            // Determine outcomes
-            const cancelled = action === 'cancel';
-            const confirmed = action === 'submit' || (!cancelled && action !== 'error');
-            // Close dialog
-            dialogRef.close();
-            // Return result with appropriate outcome
-            const outcome = cancelled ? 'Cancelled' : confirmed ? 'Confirmed' : 'Done';
-            return this.createResult({
-                context: dialogContext,
-                action,
-                cancelled,
-                confirmed
-            }, outcome);
-        }
-        catch (err) {
-            console.error('[ShowDialogLayoutBuilder] Error showing dialog:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show dialog',
-                },
-                data: {
-                    output: {
-                        context: {},
-                        action: 'error',
-                        cancelled: true,
-                        confirmed: false,
-                    },
-                    outcomes: {
-                        Error: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-/**
- * Show Toast Activity - Displays toast notification to user.
- *
- * Usage:
- * ```typescript
- * const toast = new ShowToast();
- * await toast.execute({
- *   color: 'success',
- *   title: 'Success',
- *   message: 'Operation completed successfully!'
- * });
- * ```
- */
-class ShowToast extends Activity {
-    constructor() {
-        super('ShowToast');
-        this.toastService = inject(AXToastService);
-        this.translationService = inject(AXTranslationService);
-    }
-    async execute(input) {
-        const { color = 'primary', title = '', message = '', duration = 3000 } = input;
-        // Translate title and message only if they start with '@' (translation key)
-        // Otherwise use the text as-is
-        const translatedTitle = title
-            ? (title.startsWith('@')
-                ? await this.translationService.translateAsync(title) || title
-                : title)
-            : '';
-        const translatedMessage = message
-            ? (message.startsWith('@')
-                ? await this.translationService.translateAsync(message) || message
-                : message)
-            : '';
-        try {
-            await this.toastService.show({
-                color: color,
-                title: translatedTitle,
-                content: translatedMessage,
-                closeButton: true,
-                timeOut: duration,
-                timeOutProgress: true,
-            });
-            return this.createResult(undefined, 'Done');
-        }
-        catch (err) {
-            console.error('[ShowToast] Error showing toast:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to show toast',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var showToast_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ShowToast: ShowToast
-});
-
-/**
- * Navigate Activity - Navigates to different pages/routes.
- *
- * Usage:
- * ```typescript
- * const navigate = new Navigate();
- * await navigate.execute({
- *   mode: 'route',
- *   route: '/users',
- *   params: { id: '123' }
- * });
- * ```
- */
-class Navigate extends Activity {
-    constructor() {
-        super('Navigate');
-        this.router = inject(Router);
-    }
-    async execute(input) {
-        const { mode = 'route', route = '', params = {}, queryParams = {}, entity = '', entityId = '', url = '' } = input;
-        try {
-            switch (mode) {
-                case 'route':
-                    await this.router.navigate([route], { queryParams });
-                    break;
-                case 'entity-details':
-                    const detailsRoute = `/entities/${entity}/details/${entityId}`;
-                    await this.router.navigate([detailsRoute], { queryParams });
-                    break;
-                case 'entity-list':
-                    const listRoute = `/entities/${entity}`;
-                    await this.router.navigate([listRoute], { queryParams });
-                    break;
-                case 'external':
-                    if (url) {
-                        window.open(url, '_blank');
-                    }
-                    break;
-                default:
-                    console.error(`[Navigate] Unknown navigation mode: ${mode}`);
-                    return {
-                        success: false,
-                        message: {
-                            text: `Unknown navigation mode: ${mode}`,
-                        },
-                        data: {
-                            output: undefined,
-                            outcomes: {
-                                Failed: true,
-                            },
-                        },
-                    };
-            }
-            return this.createResult(undefined, 'Done');
-        }
-        catch (err) {
-            console.error('[Navigate] Error navigating:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to navigate',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var navigate_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Navigate: Navigate
-});
-
-/**
- * Set Variable Activity - Sets a variable value in workflow context.
- *
- * Usage:
- * ```typescript
- * const setVar = new SetVariable();
- * await setVar.execute({
- *   variableName: 'userId',
- *   value: '12345'
- * });
- * ```
- */
-class SetVariable extends Activity {
-    constructor() {
-        super('workflow-activity:set-variable', 'Set Variable');
-    }
-    async execute(input) {
-        const { variableName, value } = input;
-        try {
-            // In a real implementation, this would set the variable in workflow context
-            // For now, we'll just log it
-            console.log(`[SetVariable] Setting ${variableName} = ${JSON.stringify(value)}`);
-            return this.createResult(undefined, 'Done');
-        }
-        catch (err) {
-            console.error('[SetVariable] Error setting variable:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to set variable',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var setVariable_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    SetVariable: SetVariable
-});
-
-/**
- * Dispatch Event Activity - Dispatches an event to the system.
- *
- * Usage:
- * ```typescript
- * const dispatch = new DispatchEvent();
- * await dispatch.execute({
- *   eventName: 'user-created',
- *   eventData: { userId: '123', name: 'John' }
- * });
- * ```
- */
-class DispatchEvent extends Activity {
-    constructor() {
-        super('DispatchEvent');
-    }
-    async execute(input) {
-        const { eventName, eventData } = input;
-        try {
-            // In a real implementation, this would dispatch the event through an event bus
-            // For now, we'll just log it
-            console.log(`[DispatchEvent] Dispatching event: ${eventName}`, eventData);
-            return this.createResult(undefined, 'Done');
-        }
-        catch (err) {
-            console.error('[DispatchEvent] Error dispatching event:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to dispatch event',
-                },
-                data: {
-                    output: undefined,
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var dispatchEvent_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    DispatchEvent: DispatchEvent
-});
-
-/**
- * If Activity - Conditional execution based on a condition.
- *
- * Usage:
- * ```typescript
- * const ifActivity = new If();
- * ifActivity.condition = '{{user.isAdmin}}';
- * ifActivity.thenActivities = [activity1, activity2];
- * ifActivity.elseActivities = [activity3];
- * ```
- */
-class If extends Activity {
-    constructor() {
-        super('If');
-    }
-    async execute(input) {
-        const { condition, thenActivities = [], elseActivities = [] } = input;
-        try {
-            // Evaluate condition (simplified - in real implementation, use expression evaluator)
-            const conditionResult = this.evaluateCondition(condition);
-            let result;
-            let activities;
-            if (conditionResult) {
-                activities = thenActivities;
-                result = { branch: 'then' };
-            }
-            else {
-                activities = elseActivities;
-                result = { branch: 'else' };
-            }
-            // Execute activities in the chosen branch
-            for (const activity of activities) {
-                const activityResult = await activity.execute(input);
-                if (!activityResult.success) {
-                    return {
-                        success: false,
-                        message: activityResult.message,
-                        data: {
-                            output: { branch: conditionResult ? 'then' : 'else', failedActivity: activity },
-                            outcomes: {
-                                Failed: true,
-                            },
-                        },
-                    };
-                }
-            }
-            return this.createResult(result, conditionResult ? 'Then' : 'Else');
-        }
-        catch (err) {
-            console.error('[If] Error evaluating condition:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed to evaluate condition',
-                },
-                data: {
-                    output: { branch: 'error' },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-    evaluateCondition(condition) {
-        if (typeof condition === 'boolean') {
-            return condition;
-        }
-        if (typeof condition === 'string') {
-            // Simple evaluation - in real implementation, use proper expression evaluator
-            return condition === 'true' || condition === '1' || condition === 'yes';
-        }
-        return false;
-    }
-}
-
-var if_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    If: If
-});
-
-/**
- * While Activity - Loop execution while condition is true.
- *
- * Usage:
- * ```typescript
- * const whileActivity = new While();
- * whileActivity.condition = '{{counter < 10}}';
- * whileActivity.activities = [incrementActivity, logActivity];
- * ```
- */
-class While extends Activity {
-    constructor() {
-        super('While');
-    }
-    async execute(input) {
-        const { condition, activities = [], maxIterations = 1000 } = input;
-        try {
-            let iteration = 0;
-            let conditionResult = this.evaluateCondition(condition);
-            while (conditionResult && iteration < maxIterations) {
-                // Execute activities in the loop
-                for (const activity of activities) {
-                    const activityResult = await activity.execute(input);
-                    if (!activityResult.success) {
-                        return {
-                            success: false,
-                            message: activityResult.message,
-                            data: {
-                                output: {
-                                    iterations: iteration,
-                                    completed: false,
-                                },
-                                outcomes: {
-                                    Failed: true,
-                                },
-                            },
-                        };
-                    }
-                }
-                iteration++;
-                conditionResult = this.evaluateCondition(condition);
-            }
-            const result = {
-                iterations: iteration,
-                completed: iteration < maxIterations
-            };
-            return this.createResult(result, 'Done');
-        }
-        catch (err) {
-            console.error('[While] Error in loop execution:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed during loop execution',
-                },
-                data: {
-                    output: { iterations: 0, completed: false },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-    evaluateCondition(condition) {
-        if (typeof condition === 'boolean') {
-            return condition;
-        }
-        if (typeof condition === 'string') {
-            // Simple evaluation - in real implementation, use proper expression evaluator
-            return condition === 'true' || condition === '1' || condition === 'yes';
-        }
-        return false;
-    }
-}
-
-var while_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    While: While
-});
-
-/**
- * ForEach Activity - Iterates over a collection of items.
- *
- * Usage:
- * ```typescript
- * const forEach = new ForEach();
- * await forEach.execute({
- *   items: ['item1', 'item2', 'item3'],
- *   activities: [processItemActivity]
- * });
- * ```
- */
-class ForEach extends Activity {
-    constructor() {
-        super('ForEach');
-    }
-    async execute(input) {
-        const { items = [], activities = [], itemVariableName = 'currentItem', indexVariableName = 'currentIndex' } = input;
-        try {
-            const results = [];
-            for (let index = 0; index < items.length; index++) {
-                const currentItem = items[index];
-                // Create context with current item and index
-                const itemContext = {
-                    ...input,
-                    [itemVariableName]: currentItem,
-                    [indexVariableName]: index
-                };
-                // Execute activities for current item
-                for (const activity of activities) {
-                    const activityResult = await activity.execute(itemContext);
-                    if (!activityResult.success) {
-                        return {
-                            success: false,
-                            message: activityResult.message,
-                            data: {
-                                output: {
-                                    totalItems: items.length,
-                                    processedItems: results.length,
-                                    results,
-                                },
-                                outcomes: {
-                                    Failed: true,
-                                },
-                            },
-                        };
-                    }
-                }
-                results.push({
-                    item: currentItem,
-                    index,
-                    processed: true
-                });
-            }
-            const result = {
-                totalItems: items.length,
-                processedItems: results.length,
-                results
-            };
-            return this.createResult(result, 'Done');
-        }
-        catch (err) {
-            console.error('[ForEach] Error in iteration:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Failed during iteration',
-                },
-                data: {
-                    output: { totalItems: 0, processedItems: 0, results: [] },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var forEach_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ForEach: ForEach
-});
-
-/**
- * Execute Command Activity - Executes a command through Command Bus.
- *
- * Usage:
- * ```typescript
- * const executeCmd = new ExecuteCommand();
- * await executeCmd.execute({
- *   commandKey: 'UserManagement.CreateUser',
- *   input: { name: 'John', email: 'john@example.com' }
- * });
- * ```
- */
-class ExecuteCommand extends Activity {
-    constructor() {
-        super('workflow-activity:execute-command', 'Execute Command');
-        this.commandService = inject(AXPCommandService);
-    }
-    async execute(input) {
-        const { commandKey, input: commandInput = {} } = input;
-        try {
-            // Check if command exists
-            if (!this.commandService.exists(commandKey)) {
-                console.warn(`[ExecuteCommand] Command '${commandKey}' is not registered. Simulating execution.`);
-                // Simulate command execution for unregistered commands
-                const result = {
-                    commandKey,
-                    success: true,
-                    output: commandInput,
-                    executedAt: new Date().toISOString(),
-                    simulated: true
-                };
-                return this.createResult(result, 'Done');
-            }
-            // Execute command through Command Bus
-            const result = await this.commandService.execute(commandKey, commandInput);
-            if (!result) {
-                return {
-                    success: false,
-                    message: {
-                        text: `Command '${commandKey}' returned no result`,
-                    },
-                    data: {
-                        output: {
-                            commandKey,
-                            success: false,
-                            executedAt: new Date().toISOString(),
-                        },
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
-            }
-            if (!result.success) {
-                return {
-                    success: false,
-                    message: result.message,
-                    data: {
-                        output: {
-                            commandKey,
-                            success: false,
-                            executedAt: new Date().toISOString(),
-                            error: result.message?.text,
-                        },
-                        outcomes: {
-                            Failed: true,
-                        },
-                    },
-                };
-            }
-            return this.createResult({
-                commandKey,
-                success: true,
-                output: result.data,
-                executedAt: new Date().toISOString(),
-            }, 'Done');
-        }
-        catch (err) {
-            console.error('[ExecuteCommand] Error executing command:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Unknown error',
-                },
-                data: {
-                    output: {
-                        commandKey,
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Unknown error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var executeCommand_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ExecuteCommand: ExecuteCommand
-});
-
-/**
- * Execute Query Activity - Executes a query through Query Bus.
- *
- * Usage:
- * ```typescript
- * const executeQuery = new ExecuteQuery();
- * await executeQuery.execute({
- *   queryKey: 'UserManagement.GetUsers',
- *   input: { page: 1, pageSize: 10 }
- * });
- * ```
- */
-class ExecuteQuery extends Activity {
-    constructor() {
-        super('workflow-activity:execute-query', 'Execute Query');
-        this.queryService = inject(AXPQueryService);
-    }
-    async execute(input) {
-        const { queryKey, input: queryInput = {} } = input;
-        try {
-            // Check if query exists
-            if (!this.queryService.exists(queryKey)) {
-                console.warn(`[ExecuteQuery] Query '${queryKey}' is not registered. Simulating execution.`);
-                // Simulate query execution for unregistered queries
-                const result = {
-                    queryKey,
-                    success: true,
-                    data: [],
-                    totalCount: 0,
-                    executedAt: new Date().toISOString(),
-                    simulated: true
-                };
-                return this.createResult(result, 'Done');
-            }
-            // Execute query through Query Bus
-            const result = await this.queryService.fetch(queryKey, queryInput);
-            return this.createResult({
-                queryKey,
-                success: true,
-                data: result,
-                totalCount: Array.isArray(result) ? result.length : (result?.totalCount || 0),
-                executedAt: new Date().toISOString()
-            }, 'Done');
-        }
-        catch (err) {
-            console.error('[ExecuteQuery] Error executing query:', err);
-            return {
-                success: false,
-                message: {
-                    text: err instanceof Error ? err.message : 'Unknown error',
-                },
-                data: {
-                    output: {
-                        queryKey,
-                        success: false,
-                        error: err instanceof Error ? err.message : 'Unknown error',
-                    },
-                    outcomes: {
-                        Failed: true,
-                    },
-                },
-            };
-        }
-    }
-}
-
-var executeQuery_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ExecuteQuery: ExecuteQuery
-});
-
-/**
- * Start Activity - Marks the start point of a workflow.
- *
- * This is a visual marker activity that doesn't perform any actual work.
- * It's used in workflow designers to clearly indicate where a workflow begins.
- *
- * Usage:
- * ```typescript
- * const start = new StartActivity();
- * await start.execute({});
- * ```
- */
-class StartActivity extends Activity {
-    constructor() {
-        super('StartActivity');
-    }
-    async execute(input) {
-        // This activity is a visual marker only
-        // It immediately completes and allows workflow to proceed
-        console.log('[StartActivity] Workflow started');
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var startActivity_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    StartActivity: StartActivity
-});
-
-/**
- * End Activity - Marks the end point of a workflow.
- *
- * This is a visual marker activity that terminates the workflow execution.
- * When this activity is reached, the workflow completes successfully.
- *
- * Usage:
- * ```typescript
- * const end = new EndActivity();
- * await end.execute({});
- * ```
- */
-class EndActivity extends Activity {
-    constructor() {
-        super('EndActivity');
-    }
-    async execute(input) {
-        // This activity marks the end of workflow execution
-        console.log('[EndActivity] Workflow completed');
-        return this.createResult(undefined, 'Done');
-    }
-}
-
-var endActivity_activity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    EndActivity: EndActivity
-});
-
-/**
- * Command setups for all built-in workflow activities.
- * Registers activities as AXPCommand instances.
- */
-const provideWorkflowActivityCommands = () => provideCommandSetups([
-    // Workflow Markers
-    {
-        key: 'workflow-activity:start',
-        command: () => Promise.resolve().then(function () { return startActivity_activity; }).then(m => m.StartActivity),
-    },
-    {
-        key: 'workflow-activity:end',
-        command: () => Promise.resolve().then(function () { return endActivity_activity; }).then(m => m.EndActivity),
-    },
-    // Console Activities
-    {
-        key: 'workflow-activity:write-line',
-        command: () => Promise.resolve().then(function () { return writeLine_activity; }).then(m => m.WriteLine),
-    },
-    // Control Flow Activities
-    {
-        key: 'workflow-activity:sequence',
-        command: () => Promise.resolve().then(function () { return sequence_activity; }).then(m => m.Sequence),
-    },
-    {
-        key: 'workflow-activity:if',
-        command: () => Promise.resolve().then(function () { return if_activity; }).then(m => m.If),
-    },
-    {
-        key: 'workflow-activity:while',
-        command: () => Promise.resolve().then(function () { return while_activity; }).then(m => m.While),
-    },
-    {
-        key: 'workflow-activity:for-each',
-        command: () => Promise.resolve().then(function () { return forEach_activity; }).then(m => m.ForEach),
-    },
-    // Dialog Activities
-    {
-        key: 'workflow-activity:show-confirm-dialog',
-        command: () => Promise.resolve().then(function () { return showConfirmDialog_activity; }).then(m => m.ShowConfirmDialog),
-    },
-    {
-        key: 'workflow-activity:show-alert-dialog',
-        command: () => Promise.resolve().then(function () { return showAlertDialog_activity; }).then(m => m.ShowAlertDialog),
-    },
-    // Notification Activities
-    {
-        key: 'workflow-activity:show-toast',
-        command: () => Promise.resolve().then(function () { return showToast_activity; }).then(m => m.ShowToast),
-    },
-    // Event Activities
-    {
-        key: 'workflow-activity:dispatch-event',
-        command: () => Promise.resolve().then(function () { return dispatchEvent_activity; }).then(m => m.DispatchEvent),
-    },
-    // Variable Activities
-    {
-        key: 'workflow-activity:set-variable',
-        command: () => Promise.resolve().then(function () { return setVariable_activity; }).then(m => m.SetVariable),
-    },
-    // Command & Query Activities
-    {
-        key: 'workflow-activity:execute-command',
-        command: () => Promise.resolve().then(function () { return executeCommand_activity; }).then(m => m.ExecuteCommand),
-    },
-    {
-        key: 'workflow-activity:execute-query',
-        command: () => Promise.resolve().then(function () { return executeQuery_activity; }).then(m => m.ExecuteQuery),
-    },
-    // Navigation Activities
-    {
-        key: 'workflow-activity:navigate',
-        command: () => Promise.resolve().then(function () { return navigate_activity; }).then(m => m.Navigate),
-    },
-]);
-
-// Built-in Activities
-
 // Workflow Definition Types (Storage/Database)
 
-class AXPWorkflowModule {
-    static forRoot(config) {
-        return {
-            ngModule: AXPWorkflowModule,
-            providers: [
-                provideWorkflowActivityCommands(),
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? { AXPStartWorkflowAction }),
-                ...Object.values(config?.functions ?? {}),
-            ],
-        };
-    }
-    static forChild(config) {
-        return {
-            ngModule: AXPWorkflowModule,
-            providers: [
-                // Built-in activities are already registered in forRoot via @NgModule providers
-                // No need to register again in forChild
-                {
-                    provide: 'AXPWorkflowModuleFactory',
-                    useFactory: (registry) => () => {
-                        registry.registerAction('start-workflow', AXPStartWorkflowAction);
-                        registry.registerAction('decide', AXPWorkflowDecideAction);
-                        //
-                        if (config?.functions) {
-                            for (const [key, type] of Object.entries(config.functions)) {
-                                registry.registerFunction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.actions) {
-                            for (const [key, type] of Object.entries(config.actions)) {
-                                registry.registerAction(key, type);
-                            }
-                        }
-                        //
-                        if (config?.workflows) {
-                            for (const [key, type] of Object.entries(config.workflows)) {
-                                registry.registerWorkflow(key, type);
-                            }
-                        }
-                    },
-                    deps: [AXPWorkflowRegistryService],
-                    multi: true,
-                },
-                ...Object.values(config?.actions ?? {}),
-                ...Object.values(config?.functions ?? {}),
-            ],
-        };
-    }
-    /**
-     * @ignore
-     */
-    constructor(instances) {
-        // Inject AXP_COMMAND_SETUP to trigger command registration factory
-        this._commandSetup = inject(AXP_COMMAND_SETUP, { optional: true });
-        instances?.forEach((f) => {
-            f();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, providers: [
-            provideWorkflowActivityCommands(),
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: AXPWorkflowModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        provideWorkflowActivityCommands(),
-                    ],
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: ['AXPWorkflowModuleFactory']
-                }] }] });
-
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityCategoryProviderService, AXPActivityProviderService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, Activity, ActivityRegistry, DispatchEvent, EndActivity, ExecuteCommand, ExecuteQuery, ForEach, If, Navigate, Sequence, SetVariable, ShowAlertDialog, ShowConfirmDialog, ShowDialogLayoutBuilder, ShowToast, StartActivity, While, WorkflowCoordinator, WriteLine, createWorkFlowEvent, ofType, provideWorkflowActivityCommands };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionRegistryService, AXPWorkflowDefinitionResolver, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowExecutionService, AXPWorkflowFunction, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_DEFINITION_LOADER, WorkflowCoordinator, createWorkFlowEvent, ofType };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map