@acorex/platform 19.2.9 → 19.2.11

package/common/lib/app/application.types.d.ts

@@ -1,6 +1,6 @@
 import { AXDataSourceOperator, AXStyleColorType } from '@acorex/components/common';
 import { AXPopupSizeType } from '@acorex/components/popup';
-import { AXPValidationRules } from '@acorex/platform/core';
+import { AXPMetaData, AXPValidationRules } from '@acorex/platform/core';
 import { AXPWidgetTypesMap, AXPWidgetValueTransformFunctions } from '@acorex/platform/layout/builder';
 import { AXPGridLayoutOptions } from '../layout';
 export interface AXEntityPropertyWidget {
@@ -138,7 +138,7 @@ export interface AXPCommandActionLook {
 export type AXPCommandActionPriority = 'primary' | 'secondary';
 export type AXPCommandActionCallback = string | {
     name: string;
-    options: {
+    options?: {
         decoration?: {
             header?: {
                 title?: string;
@@ -153,6 +153,7 @@ export type AXPCommandActionCallback = string | {
         };
         [name: string]: any;
     };
+    metadata?: AXPMetaData;
 };
 export interface AXPCommandAction extends Partial<AXPCommandActionLook> {
     name?: string;

package/common/lib/settings/settings.service.d.ts

@@ -32,5 +32,6 @@ declare class ScopedSettingService {
     defaultValues(): Promise<Record<string, unknown>>;
     set<T = any>(key: string, value: T): Promise<void>;
     set<T = any>(values: Record<string, T>): Promise<void>;
+    update<T = any>(key: string, updateFn: (currentValue: T) => T): Promise<void>;
 }
 export {};

package/common/lib/utils/expression-evaluator.service.d.ts

@@ -4,8 +4,10 @@ export type AXPExpressionEvaluatorScope = {
         [name: string]: Function;
     };
 };
+export type AXPExpression = string;
 export declare class AXPExpressionEvaluatorService {
-    evaluateExpression(obj: any, templateExpression: string, scope: AXPExpressionEvaluatorScope): Promise<any>;
+    evaluateExpression(obj: any, templateExpression: any, scope: AXPExpressionEvaluatorScope): Promise<any>;
+    private evaluateStringExpression;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPExpressionEvaluatorService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPExpressionEvaluatorService>;
 }

package/fesm2022/acorex-platform-common.mjs

@@ -628,25 +628,39 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImpor
 class AXPExpressionEvaluatorService {
     async evaluateExpression(obj, templateExpression, scope) {
         try {
-            // Check cache first, but cache the function for evaluation, not the evaluated value
-            const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
-            if (!expressionMatch) {
-                throw Error(`No valid expression found in "${templateExpression}"`);
+            if (typeof templateExpression === 'string' && templateExpression.includes('{{')) {
+                return await this.evaluateStringExpression(templateExpression, scope);
+            }
+            else if (typeof templateExpression === 'object') {
+                const evaluatedObject = {};
+                for (const key in templateExpression) {
+                    if (templateExpression.hasOwnProperty(key)) {
+                        evaluatedObject[key] = await this.evaluateExpression(obj, templateExpression[key], scope);
+                    }
+                }
+                return evaluatedObject;
+            }
+            else {
+                return templateExpression;
             }
-            const expression = expressionMatch[1];
-            // Cache the evaluation function instead of the result.
-            const evaluationFunction = async () => {
-                const sandbox = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
-                // Call the sandbox passing in the current global scope and the object.
-                return await sandbox(scope);
-            };
-            return await evaluationFunction();
         }
         catch (error) {
             console.error('Error evaluating expression:', error);
             return false;
         }
     }
+    async evaluateStringExpression(templateExpression, scope) {
+        const expressionMatch = templateExpression.match(/\{\{\s*(.*?)\s*\}\}/);
+        if (!expressionMatch) {
+            throw Error(`No valid expression found in "${templateExpression}"`);
+        }
+        const expression = expressionMatch[1];
+        const evaluationFunction = async () => {
+            const sandbox = new Function('scope', `with (scope) { return (async function() { return ${expression}; })(); }`);
+            return await sandbox(scope);
+        };
+        return await evaluationFunction();
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPExpressionEvaluatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXPExpressionEvaluatorService, providedIn: 'root' }); }
 }
@@ -2273,7 +2287,12 @@ class AXPSettingService {
         this.onChanged = new Subject();
         this.broadcastChannel = new BroadcastChannel('AXPSettingChannel'); // BroadcastChannel for sync
         // Initialize scoped caches for dynamic scopes
-        const staticScopes = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User];
+        const staticScopes = [
+            AXPSettingScope.Environment,
+            AXPSettingScope.Global,
+            AXPSettingScope.Tenant,
+            AXPSettingScope.User,
+        ];
         staticScopes.forEach((scope) => {
             if (!this.scopedSettingsCache.has(scope)) {
                 this.scopedSettingsCache.set(scope, new Map());
@@ -2310,7 +2329,12 @@ class AXPSettingService {
         if (this.scopedSettingsCache.size === 0) {
             await this.load();
         }
-        const scopeOrder = [AXPSettingScope.User, AXPSettingScope.Tenant, AXPSettingScope.Global, AXPSettingScope.Environment];
+        const scopeOrder = [
+            AXPSettingScope.User,
+            AXPSettingScope.Tenant,
+            AXPSettingScope.Global,
+            AXPSettingScope.Environment,
+        ];
         for (const scope of scopeOrder) {
             const scopeCache = this.scopedSettingsCache.get(scope);
             if (scopeCache && scopeCache.has(key)) {
@@ -2325,7 +2349,12 @@ class AXPSettingService {
         return get(defaults, key); // Fallback if no value is found
     }
     async defaultValues(scope) {
-        let scopeOrder = [AXPSettingScope.Environment, AXPSettingScope.Global, AXPSettingScope.Tenant, AXPSettingScope.User].reverse();
+        let scopeOrder = [
+            AXPSettingScope.Environment,
+            AXPSettingScope.Global,
+            AXPSettingScope.Tenant,
+            AXPSettingScope.User,
+        ].reverse();
         const scopeIndex = scopeOrder.indexOf(scope);
         if (scopeIndex === -1) {
             throw new Error(`Invalid scope: ${scope}`);
@@ -2412,6 +2441,11 @@ class ScopedSettingService {
             });
         }
     }
+    async update(key, updateFn) {
+        const currentValue = await this.get(key);
+        const newValue = updateFn(currentValue);
+        await this.set(key, newValue);
+    }
 }
 
 //TODO Loading, Redirect, Drawer, Show toast