@acorex/platform 20.3.0-next.0 → 20.3.0-next.1

package/fesm2022/acorex-platform-core.mjs

@@ -1,7 +1,7 @@
 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 { get, isPlainObject, set, isArray, merge, isNil, isObjectLike, transform, isEmpty, cloneDeep, isEqual, 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 { computed, InjectionToken, inject, Injectable, input, effect, Directive, EventEmitter, HostListener, Output, ViewContainerRef, ElementRef, provideAppInitializer, signal, Pipe } from '@angular/core';
 import { Subject, interval } from 'rxjs';
 import { AXCalendarService } from '@acorex/core/date-time';
 import { startWith, map } from 'rxjs/operators';
@@ -107,6 +107,7 @@ function extractValue(value, key = 'id') {
     if (isNil(value)) {
         return null;
     }
+    ;
     return isObjectLike(value) ? get(value, key) : value;
 }
 function cleanDeep(obj) {
@@ -125,114 +126,6 @@ function cleanDeep(obj) {
         }
     });
 }
-function getDeepChanges(obj1, obj2) {
-    const changes = [];
-    function walk(o1, o2, currentPath = []) {
-        // If both values are deeply equal, skip
-        if (isEqual(o1, o2))
-            return;
-        const isObj1Nil = o1 === null || o1 === undefined;
-        const isObj2Nil = o2 === null || o2 === undefined;
-        // If obj1 is null/undefined and obj2 is not, treat entire obj2 as added
-        if (isObj1Nil && !isObj2Nil) {
-            if (isPlainObject(o2)) {
-                for (const key of Object.keys(o2)) {
-                    walk(undefined, o2[key], [...currentPath, key]);
-                }
-            }
-            else if (Array.isArray(o2)) {
-                changes.push({
-                    path: currentPath.join('.'),
-                    oldValue: undefined,
-                    newValue: o2,
-                    arrayDiff: {
-                        added: o2,
-                        removed: [],
-                    },
-                });
-            }
-            else {
-                changes.push({
-                    path: currentPath.join('.'),
-                    oldValue: undefined,
-                    newValue: o2,
-                });
-            }
-            return;
-        }
-        // If obj2 is null/undefined and obj1 is not, treat entire obj1 as removed
-        if (!isObj1Nil && isObj2Nil) {
-            if (isPlainObject(o1)) {
-                for (const key of Object.keys(o1)) {
-                    walk(o1[key], undefined, [...currentPath, key]);
-                }
-            }
-            else if (Array.isArray(o1)) {
-                changes.push({
-                    path: currentPath.join('.'),
-                    oldValue: o1,
-                    newValue: undefined,
-                    arrayDiff: {
-                        added: [],
-                        removed: o1,
-                    },
-                });
-            }
-            else {
-                changes.push({
-                    path: currentPath.join('.'),
-                    oldValue: o1,
-                    newValue: undefined,
-                });
-            }
-            return;
-        }
-        // If both are arrays, compare items
-        if (Array.isArray(o1) && Array.isArray(o2)) {
-            if (!isEqual(o1, o2)) {
-                const added = differenceWith(o2, o1, isEqual);
-                const removed = differenceWith(o1, o2, isEqual);
-                changes.push({
-                    path: currentPath.join('.'),
-                    oldValue: o1,
-                    newValue: o2,
-                    arrayDiff: {
-                        added,
-                        removed,
-                    },
-                });
-            }
-            return;
-        }
-        // If both are plain objects, walk each key
-        if (isPlainObject(o1) && isPlainObject(o2)) {
-            const allKeys = union(Object.keys(o1), Object.keys(o2));
-            for (const key of allKeys) {
-                walk(o1[key], o2[key], [...currentPath, key]);
-            }
-            return;
-        }
-        // Primitive values or mismatched types
-        changes.push({
-            path: currentPath.join('.'),
-            oldValue: o1,
-            newValue: o2,
-        });
-    }
-    walk(obj1, obj2);
-    return changes;
-}
-// Method 1: Returns only changed paths
-function getChangedPaths(obj1, obj2) {
-    return getDeepChanges(obj1, obj2).map((change) => change.path);
-}
-// Method 2: Returns full change entries
-function getDetailedChanges(obj1, obj2) {
-    return getDeepChanges(obj1, obj2);
-}
-function getEnumValues(enumType) {
-    return Object.entries(enumType).map(([key, value]) => ({ id: value, title: key }));
-}
 
 class AXPContextChangeEvent {
 }
@@ -699,6 +592,11 @@ class AXPContentCheckerDirective {
         this.elementRef = inject((ElementRef));
         this.isEmpty = computed(() => this.viewContainerRef.length === 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : []));
     }
+    ngAfterViewInit() {
+        setTimeout(() => {
+            console.log(this.elementRef.nativeElement.childNodes);
+        }, 1000);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPContentCheckerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.6", type: AXPContentCheckerDirective, isStandalone: true, selector: "[axp-content-checker]", exportAs: ["checker"], ngImport: i0 }); }
 }
@@ -716,11 +614,10 @@ class AXPBroadcastEventService {
         this.eventSubjects = new Map();
         this.pendingRequests = new Map();
         this.multiTabEventHistory = new Set(); // Prevent duplicate processing of the same event
-        this.instanceId = AXPDataGenerator.uuid();
         this.channel = new BroadcastChannel('platform_global_events');
         // Handle incoming messages
         this.channel.onmessage = (event) => {
-            const { type, payload, requestId, response, sourceId } = event.data;
+            const { type, payload, requestId, response } = event.data;
             // Prevent processing the same event multiple times (multi-tab synchronization)
             if (requestId && this.multiTabEventHistory.has(requestId)) {
                 return;
@@ -736,10 +633,6 @@ class AXPBroadcastEventService {
                 return;
             }
             // Handle normal broadcast events
-            // Ignore events originating from this same instance to avoid double-delivery
-            if (sourceId && sourceId === this.instanceId) {
-                return;
-            }
             if (type && this.eventSubjects.has(type)) {
                 this.eventSubjects.get(type).next({ data: payload, requestId });
             }
@@ -749,11 +642,7 @@ class AXPBroadcastEventService {
      * Publish an event without expecting a response
      */
     publish(type, payload) {
-        this.channel.postMessage({ type, payload, sourceId: this.instanceId });
-        // Local echo so same-tab listeners receive the event as well
-        if (this.eventSubjects.has(type)) {
-            this.eventSubjects.get(type).next({ data: payload });
-        }
+        this.channel.postMessage({ type, payload });
     }
     /**
      * Subscribe to an event
@@ -776,11 +665,7 @@ class AXPBroadcastEventService {
     /**
      * Send a message and wait for a response with retry logic
      */
-    async sendAndWaitForResponse(type, payload, options = {
-        timeout: 60 * 60 * 1000,
-        retries: 3,
-        retryDelay: 1000,
-    }) {
+    async sendAndWaitForResponse(type, payload, options = { timeout: 60 * 60 * 1000, retries: 3, retryDelay: 1000 }) {
         const requestId = AXPDataGenerator.uuid();
         const attemptRequest = (attempt) => {
             return new Promise((resolve, reject) => {
@@ -834,7 +719,7 @@ class AXPBroadcastEventService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPBroadcastEventService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root',
+                    providedIn: 'root'
                 }]
         }], ctorParameters: () => [] });
 
@@ -1528,46 +1413,38 @@ function applyCondition(item, condition) {
     if (!conditionType) {
         return true;
     }
-    const op = String(conditionType);
-    switch (op) {
+    switch (conditionType) {
         case 'equal':
-        case 'eq':
             result = isEqual(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Equal check result:', result);
             }
             break;
         case 'notEqual':
-        case 'ne':
-        case 'neq':
             result = !isEqual(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Not equal check result:', result);
             }
             break;
         case 'greaterThan':
-        case 'gt':
             result = gt(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Greater than check result:', result);
             }
             break;
         case 'lessThan':
-        case 'lt':
             result = lt(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Less than check result:', result);
             }
             break;
         case 'greaterThanOrEqual':
-        case 'gte':
             result = gte(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Greater than or equal check result:', result);
             }
             break;
         case 'lessThanOrEqual':
-        case 'lte':
             result = lte(valueToCompare, conditionValue);
             if (loggingEnabled) {
                 console.log('Less than or equal check result:', result);
@@ -1664,9 +1541,7 @@ function applyCondition(item, condition) {
                 console.log('Default case, returning true');
             }
     }
-    // Apply negative flag if present on operator (invert the result)
-    const isNegative = !!condition?.operator?.negative;
-    return isNegative ? !result : result;
+    return result;
 }
 function applyFilterArray(dataArray, filters, logic = 'and') {
     if (filters && filters.length) {
@@ -1863,7 +1738,6 @@ 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 */
@@ -1882,7 +1756,7 @@ class AXPDistributedEventListenerService {
         // Execute all listeners in parallel
         const promises = listeners.map(listener => {
             try {
-                return Promise.resolve(runInInjectionContext(this.injector, () => listener.execute(data)));
+                return Promise.resolve(listener.execute(data));
             }
             catch (error) {
                 console.error(`Error executing listener for event key '${key}':`, error);
@@ -1946,9 +1820,157 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                 }]
         }] });
 
+//import { AXPEntityDefinitionRegistryService } from '@acorex/platform/layout/entity';
+/**
+ * Entity Event Dispatcher - A wrapper for entity-specific events
+ * Handles pattern-based dispatching for entity operations with wildcard support
+ */
+class AXPEntityEventDispatcherService {
+    constructor() {
+        this.eventService = inject(AXPDistributedEventListenerService);
+    }
+    //private readonly entityRegistry = inject(AXPEntityDefinitionRegistryService);
+    /**
+     * Dispatch entity events with pattern matching support for wildcard listeners
+     * @param operation The operation type (inserted, updated, deleted)
+     * @param entityName The full entity name (e.g., 'PlatformManagement.Category')
+     * @param data The event data
+     */
+    async dispatchEntityEvent(operation, entityName, data) {
+        console.log('dispatchEntityEvent', operation, entityName, data);
+        const enhancedData = {
+            ...data,
+            entityName,
+            operation,
+            timestamp: new Date(),
+            source: 'entity-dispatcher'
+        };
+        // Get all possible event keys that could match this entity operation
+        const eventKeysToDispatch = await this.getAllMatchingEventKeys(operation, entityName);
+        console.log('eventKeysToDispatch', eventKeysToDispatch);
+        // Dispatch to all matching patterns simultaneously
+        const dispatchPromises = eventKeysToDispatch.map(key => this.eventService.dispatch(key, enhancedData));
+        await Promise.all(dispatchPromises);
+    }
+    /**
+     * Get all event keys that should be dispatched for this entity operation
+     * including wildcard pattern matches
+     */
+    async getAllMatchingEventKeys(operation, entityName) {
+        const eventKeys = new Set();
+        // 1. Add exact patterns for this specific entity
+        const exactKeys = this.generateEventKeys(operation, entityName);
+        exactKeys.forEach(key => eventKeys.add(key));
+        // 2. Find and add wildcard listeners that match this entity
+        const wildcardKeys = await this.findMatchingWildcardKeys(operation, entityName);
+        wildcardKeys.forEach(key => eventKeys.add(key));
+        return Array.from(eventKeys);
+    }
+    /**
+     * Find wildcard listener keys that match this entity operation
+     */
+    async findMatchingWildcardKeys(operation, entityName) {
+        const matchingKeys = [];
+        // Get all registered listeners
+        const allListenerKeys = await this.eventService.getRegisteredKeys();
+        // Generate the event key that would be dispatched
+        const actualEventKey = `entity.${operation}.${entityName}`;
+        // Check each listener key for wildcard patterns
+        for (const listenerKey of allListenerKeys) {
+            if (listenerKey.includes('*') && this.matchesEntityPattern(actualEventKey, listenerKey)) {
+                matchingKeys.push(listenerKey);
+            }
+        }
+        return matchingKeys;
+    }
+    /**
+     * Check if an entity event key matches a wildcard pattern
+     * Only supports entity patterns (entity.*)
+     */
+    matchesEntityPattern(eventKey, pattern) {
+        // Only process entity patterns
+        if (!pattern.startsWith('entity.') || !pattern.includes('*')) {
+            return false;
+        }
+        // Convert pattern to regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.') // Escape dots
+            .replace(/\*/g, '.*'); // Convert * to regex wildcard
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(eventKey);
+    }
+    /**
+     * Generate all possible event keys for an entity operation
+     * @param operation The operation type
+     * @param entityName The entity name (e.g., 'PlatformManagement.Category')
+     */
+    generateEventKeys(operation, entityName) {
+        const keys = [];
+        // 1. Base pattern: entity.inserted
+        keys.push(`entity.${operation}`);
+        // 2. Specific entity pattern: entity.inserted.PlatformManagement.Category
+        keys.push(`entity.${operation}.${entityName}`);
+        // 3. Module-level pattern: entity.inserted.PlatformManagement
+        const entityParts = entityName.split('.');
+        if (entityParts.length > 1) {
+            const moduleName = entityParts[0];
+            keys.push(`entity.${operation}.${moduleName}`);
+        }
+        return keys;
+    }
+    /**
+     * Convenience methods for specific operations
+     */
+    async dispatchInserted(entityName, data) {
+        await this.dispatchEntityEvent('inserted', entityName, data);
+    }
+    async dispatchUpdated(entityName, data) {
+        await this.dispatchEntityEvent('updated', entityName, data);
+    }
+    async dispatchDeleted(entityName, data) {
+        await this.dispatchEntityEvent('deleted', entityName, data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityEventDispatcherService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityEventDispatcherService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityEventDispatcherService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Example implementation of a distributed event listener provider.
+ * This is just a sample to show how to implement the interface.
+ */
+class ExampleEventListenerProvider {
+    constructor() {
+        this.key = 'example.event';
+    }
+    async execute(data) {
+        console.log('Example event received:', data);
+        // Your implementation here
+        // For example:
+        // - Log the event
+        // - Update cache
+        // - Send notifications
+        // - Call external APIs
+        // - Update UI state
+        // Simulate async work
+        await new Promise(resolve => setTimeout(resolve, 100));
+        console.log('Example event processed successfully');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: ExampleEventListenerProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: ExampleEventListenerProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: ExampleEventListenerProvider, decorators: [{
+            type: Injectable
+        }] });
+
 /**
  * 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, 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, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDistributedEventListenerService, AXPElementDataDirective, AXPEntityEventDispatcherService, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPGridLayoutDirective, AXPImageUrlLogoConfig, AXPPlatformScope, AXPSystemActionType, AXPSystemActions, AXP_ACTIVITY_LOG_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, ExampleEventListenerProvider, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
 //# sourceMappingURL=acorex-platform-core.mjs.map