@acorex/platform 19.2.9 → 19.2.10

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/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' }); }
 }