@masterteam/components 0.0.93 → 0.0.94

package/fesm2022/masterteam-components-formula.mjs

@@ -2097,14 +2097,62 @@ const CONDITION_FUNCTION_CATEGORIES = [
     },
 ];
 const CONDITION_OPERATORS = [
-    { symbol: '==', name: 'Equal', type: 'comparison', description: 'Equal to', precedence: 3 },
-    { symbol: '!=', name: 'Not Equal', type: 'comparison', description: 'Not equal to', precedence: 3 },
-    { symbol: '>', name: 'Greater Than', type: 'comparison', description: 'Greater than', precedence: 4 },
-    { symbol: '<', name: 'Less Than', type: 'comparison', description: 'Less than', precedence: 4 },
-    { symbol: '>=', name: 'Greater or Equal', type: 'comparison', description: 'Greater than or equal', precedence: 4 },
-    { symbol: '<=', name: 'Less or Equal', type: 'comparison', description: 'Less than or equal', precedence: 4 },
-    { symbol: '&&', name: 'And', type: 'logical', description: 'Logical AND', precedence: 2 },
-    { symbol: '||', name: 'Or', type: 'logical', description: 'Logical OR', precedence: 1 },
+    {
+        symbol: '==',
+        name: 'Equal',
+        type: 'comparison',
+        description: 'Equal to',
+        precedence: 3,
+    },
+    {
+        symbol: '!=',
+        name: 'Not Equal',
+        type: 'comparison',
+        description: 'Not equal to',
+        precedence: 3,
+    },
+    {
+        symbol: '>',
+        name: 'Greater Than',
+        type: 'comparison',
+        description: 'Greater than',
+        precedence: 4,
+    },
+    {
+        symbol: '<',
+        name: 'Less Than',
+        type: 'comparison',
+        description: 'Less than',
+        precedence: 4,
+    },
+    {
+        symbol: '>=',
+        name: 'Greater or Equal',
+        type: 'comparison',
+        description: 'Greater than or equal',
+        precedence: 4,
+    },
+    {
+        symbol: '<=',
+        name: 'Less or Equal',
+        type: 'comparison',
+        description: 'Less than or equal',
+        precedence: 4,
+    },
+    {
+        symbol: '&&',
+        name: 'And',
+        type: 'logical',
+        description: 'Logical AND',
+        precedence: 2,
+    },
+    {
+        symbol: '||',
+        name: 'Or',
+        type: 'logical',
+        description: 'Logical OR',
+        precedence: 1,
+    },
 ];
 const VALIDATION_FUNCTION_CATEGORIES = [
     {
@@ -2323,18 +2371,90 @@ const VALIDATION_FUNCTION_CATEGORIES = [
     },
 ];
 const VALIDATION_OPERATORS = [
-    { symbol: '+', name: 'Add', type: 'arithmetic', description: 'Addition', precedence: 4 },
-    { symbol: '-', name: 'Subtract', type: 'arithmetic', description: 'Subtraction', precedence: 4 },
-    { symbol: '*', name: 'Multiply', type: 'arithmetic', description: 'Multiplication', precedence: 5 },
-    { symbol: '/', name: 'Divide', type: 'arithmetic', description: 'Division', precedence: 5 },
-    { symbol: '==', name: 'Equal', type: 'comparison', description: 'Equal to', precedence: 3 },
-    { symbol: '!=', name: 'Not Equal', type: 'comparison', description: 'Not equal to', precedence: 3 },
-    { symbol: '>', name: 'Greater Than', type: 'comparison', description: 'Greater than', precedence: 3 },
-    { symbol: '<', name: 'Less Than', type: 'comparison', description: 'Less than', precedence: 3 },
-    { symbol: '>=', name: 'Greater or Equal', type: 'comparison', description: 'Greater than or equal', precedence: 3 },
-    { symbol: '<=', name: 'Less or Equal', type: 'comparison', description: 'Less than or equal', precedence: 3 },
-    { symbol: '&&', name: 'And', type: 'logical', description: 'Logical AND', precedence: 2 },
-    { symbol: '||', name: 'Or', type: 'logical', description: 'Logical OR', precedence: 1 },
+    {
+        symbol: '+',
+        name: 'Add',
+        type: 'arithmetic',
+        description: 'Addition',
+        precedence: 4,
+    },
+    {
+        symbol: '-',
+        name: 'Subtract',
+        type: 'arithmetic',
+        description: 'Subtraction',
+        precedence: 4,
+    },
+    {
+        symbol: '*',
+        name: 'Multiply',
+        type: 'arithmetic',
+        description: 'Multiplication',
+        precedence: 5,
+    },
+    {
+        symbol: '/',
+        name: 'Divide',
+        type: 'arithmetic',
+        description: 'Division',
+        precedence: 5,
+    },
+    {
+        symbol: '==',
+        name: 'Equal',
+        type: 'comparison',
+        description: 'Equal to',
+        precedence: 3,
+    },
+    {
+        symbol: '!=',
+        name: 'Not Equal',
+        type: 'comparison',
+        description: 'Not equal to',
+        precedence: 3,
+    },
+    {
+        symbol: '>',
+        name: 'Greater Than',
+        type: 'comparison',
+        description: 'Greater than',
+        precedence: 3,
+    },
+    {
+        symbol: '<',
+        name: 'Less Than',
+        type: 'comparison',
+        description: 'Less than',
+        precedence: 3,
+    },
+    {
+        symbol: '>=',
+        name: 'Greater or Equal',
+        type: 'comparison',
+        description: 'Greater than or equal',
+        precedence: 3,
+    },
+    {
+        symbol: '<=',
+        name: 'Less or Equal',
+        type: 'comparison',
+        description: 'Less than or equal',
+        precedence: 3,
+    },
+    {
+        symbol: '&&',
+        name: 'And',
+        type: 'logical',
+        description: 'Logical AND',
+        precedence: 2,
+    },
+    {
+        symbol: '||',
+        name: 'Or',
+        type: 'logical',
+        description: 'Logical OR',
+        precedence: 1,
+    },
 ];
 const CONDITION_RUNTIME_CATALOG = {
     domain: 'condition',
@@ -2524,53 +2644,73 @@ class FormulaRuntimeEngine {
         };
     }
     evaluateCondition(config, context) {
+        let compiled;
         try {
-            const compiled = this.getCompiledFormula(config.formulaTokens);
-            const rawValue = this.evaluateAst(compiled.ast, context.values);
-            const action = this.resolveConditionAction(config.mode, compiled);
-            const conditionValue = toBoolean(rawValue);
-            switch (action) {
-                case 'show':
-                    return {
-                        hidden: !conditionValue,
-                        dependencies: compiled.dependencies,
-                        errors: [],
-                    };
-                case 'hide':
-                    return {
-                        hidden: conditionValue,
-                        dependencies: compiled.dependencies,
-                        errors: [],
-                    };
-                case 'enable':
-                    return {
-                        disabled: !conditionValue,
-                        dependencies: compiled.dependencies,
-                        errors: [],
-                    };
-                case 'disable':
-                    return {
-                        disabled: conditionValue,
-                        dependencies: compiled.dependencies,
-                        errors: [],
-                    };
-                default:
-                    return {
-                        dependencies: compiled.dependencies,
-                        errors: [],
-                    };
-            }
+            compiled = this.getCompiledFormula(config.formulaTokens);
         }
         catch (error) {
             return {
                 dependencies: [],
-                errors: [toErrorMessage(error)],
+                errors: [createRuntimeError('FORMULA_PARSE_ERROR', error)],
             };
         }
+        let rawValue;
+        try {
+            rawValue = this.evaluateAst(compiled.ast, context.values);
+        }
+        catch (error) {
+            return {
+                dependencies: compiled.dependencies,
+                errors: [createRuntimeError('FORMULA_EVALUATION_ERROR', error)],
+            };
+        }
+        const action = this.resolveConditionAction(config.mode, compiled);
+        const conditionValue = toBoolean(rawValue);
+        switch (action) {
+            case 'show':
+                return {
+                    hidden: !conditionValue,
+                    dependencies: compiled.dependencies,
+                    errors: [],
+                };
+            case 'hide':
+                return {
+                    hidden: conditionValue,
+                    dependencies: compiled.dependencies,
+                    errors: [],
+                };
+            case 'enable':
+                return {
+                    disabled: !conditionValue,
+                    dependencies: compiled.dependencies,
+                    errors: [],
+                };
+            case 'disable':
+                return {
+                    disabled: conditionValue,
+                    dependencies: compiled.dependencies,
+                    errors: [],
+                };
+            default:
+                return {
+                    dependencies: compiled.dependencies,
+                    errors: [],
+                };
+        }
     }
     evaluateValidation(rule, context) {
+        let compiled;
+        try {
+            compiled = this.getCompiledFormula(rule.formulaTokens);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                dependencies: [],
+                errors: [createRuntimeError('FORMULA_PARSE_ERROR', error)],
+            };
+        }
         try {
-            const compiled = this.getCompiledFormula(rule.formulaTokens);
             const value = this.evaluateAst(compiled.ast, context.values);
             return {
                 valid: toBoolean(value),
@@ -2581,11 +2721,53 @@ class FormulaRuntimeEngine {
         catch (error) {
             return {
                 valid: false,
-                dependencies: [],
-                errors: [toErrorMessage(error)],
+                dependencies: compiled.dependencies,
+                errors: [createRuntimeError('FORMULA_EVALUATION_ERROR', error)],
             };
         }
     }
+    evaluateValidationRules(rules, context, options) {
+        const errors = [];
+        const warnings = [];
+        const isDependencyActive = options?.isDependencyActive ?? (() => true);
+        rules.forEach((rule) => {
+            if (!rule.enabled)
+                return;
+            const result = this.evaluateValidation(rule, context);
+            const hasInactiveDependency = result.dependencies.some((dependency) => !isDependencyActive(dependency));
+            if (hasInactiveDependency)
+                return;
+            if (result.errors.length > 0) {
+                const firstError = result.errors[0];
+                const message = {
+                    code: firstError.code,
+                    severity: rule.severity,
+                    message: firstError.message,
+                    formulaText: rule.formulaText,
+                    ruleId: rule.id,
+                };
+                if (rule.severity === 'error')
+                    errors.push(message);
+                else
+                    warnings.push(message);
+                return;
+            }
+            if (!result.valid) {
+                const message = {
+                    code: 'FORMULA_FALSE',
+                    severity: rule.severity,
+                    message: rule.message || 'Validation rule failed',
+                    formulaText: rule.formulaText,
+                    ruleId: rule.id,
+                };
+                if (rule.severity === 'error')
+                    errors.push(message);
+                else
+                    warnings.push(message);
+            }
+        });
+        return { errors, warnings };
+    }
     extractDependencies(formulaTokens) {
         try {
             return this.getCompiledFormula(formulaTokens).dependencies;
@@ -2903,6 +3085,12 @@ function toErrorMessage(error) {
         return error.message;
     return 'Formula evaluation failed';
 }
+function createRuntimeError(code, error) {
+    return {
+        code,
+        message: toErrorMessage(error),
+    };
+}
 
 // Formula components public API