@syncfusion/ej2-form-renderer 34.2.2

package/src/common/expressions/expression-engine.js

@@ -0,0 +1,514 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { ExpressionParser } from './expression-parser';
+import { DependencyTracker } from './dependency-tracker';
+import { Internationalization } from '@syncfusion/ej2-base';
+/**
+ * ExpressionEngine - Core evaluation engine
+ *
+ * Safely evaluates user-defined expressions against form state
+ * Supports field references, math operations, functions, and conditionals
+ * @private
+ */
+var ExpressionEngine = /** @class */ (function () {
+    function ExpressionEngine() {
+        this.evaluationCache = new Map();
+        this.compiledFunctions = new Map();
+        this.parser = new ExpressionParser();
+        this.dependencyTracker = new DependencyTracker();
+    }
+    /**
+     * Evaluate expression against form values
+     */
+    ExpressionEngine.prototype.evaluate = function (expression, formValues, options, isCustomValidation) {
+        if (options === void 0) { options = {}; }
+        if (isCustomValidation === void 0) { isCustomValidation = false; }
+        try {
+            if (!expression || expression.trim() === '') {
+                return null;
+            }
+            var _a = options.timeout, timeout = _a === void 0 ? 5000 : _a, _b = options.maxDepth, maxDepth = _b === void 0 ? 10 : _b, _c = options.locale, locale = _c === void 0 ? 'en-US' : _c, _d = options.throwOnError, throwOnError = _d === void 0 ? false : _d;
+            // Check cache
+            var cacheKey = this.getCacheKey(expression, formValues);
+            if (!isCustomValidation && this.evaluationCache.has(cacheKey)) {
+                return this.evaluationCache.get(cacheKey);
+            }
+            // Get or compile function
+            var fn = this.compiledFunctions.get(expression);
+            if (!fn) {
+                fn = this.parser.compile(expression, {
+                    timeout: timeout,
+                    maxDepth: maxDepth,
+                    locale: locale,
+                    isCustomValidation: isCustomValidation
+                });
+                this.compiledFunctions.set(expression, fn);
+            }
+            // Execute with context
+            var context = this.buildContext(formValues);
+            var startTime = Date.now();
+            var result = fn(context);
+            // Validate timeout
+            if (Date.now() - startTime > timeout) {
+                var error = new Error("Expression evaluation exceeded timeout of " + timeout + "ms");
+                if (throwOnError)
+                    throw error;
+                return null;
+            }
+            // Cache result
+            this.evaluationCache.set(cacheKey, result);
+            return result;
+        }
+        catch (error) {
+            if (options.throwOnError) {
+                throw error;
+            }
+            return null;
+        }
+    };
+    /**
+     * Extract field names referenced in expression
+     */
+    ExpressionEngine.prototype.extractDependencies = function (expression) {
+        if (!expression)
+            return [];
+        return this.dependencyTracker.extractFieldReferences(expression);
+    };
+    /**
+     * Build dependency graph for all expressions
+     */
+    ExpressionEngine.prototype.buildDependencyGraph = function (components) {
+        var _this = this;
+        var graph = {};
+        components.forEach(function (comp) {
+            if (comp.expressionValue) {
+                var deps = _this.extractDependencies(comp.expressionValue);
+                graph[comp.name] = deps;
+            }
+        });
+        return graph;
+    };
+    /**
+     * Detect circular dependencies
+     */
+    ExpressionEngine.prototype.detectCircularDependencies = function (graph) {
+        var visited = new Set();
+        var recursionStack = new Set();
+        var cycles = [];
+        var visit = function (node, path) {
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            var deps = graph[node] || [];
+            for (var _i = 0, deps_1 = deps; _i < deps_1.length; _i++) {
+                var dep = deps_1[_i];
+                if (!visited.has(dep)) {
+                    visit(dep, path.slice());
+                }
+                else if (recursionStack.has(dep)) {
+                    var cycleStart = path.indexOf(dep);
+                    cycles.push(path.slice(cycleStart).concat([dep]));
+                }
+            }
+            recursionStack.delete(node);
+        };
+        for (var _i = 0, _a = Object.keys(graph); _i < _a.length; _i++) {
+            var node = _a[_i];
+            if (!visited.has(node)) {
+                visit(node, []);
+            }
+        }
+        return cycles;
+    };
+    /**
+     * Get topological order for evaluation
+     */
+    ExpressionEngine.prototype.getTopologicalOrder = function (graph) {
+        var visited = new Set();
+        var order = [];
+        var visit = function (node) {
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            var deps = graph[node] || [];
+            for (var _i = 0, deps_2 = deps; _i < deps_2.length; _i++) {
+                var dep = deps_2[_i];
+                visit(dep);
+            }
+            order.push(node);
+        };
+        for (var _i = 0, _a = Object.keys(graph); _i < _a.length; _i++) {
+            var node = _a[_i];
+            visit(node);
+        }
+        return order;
+    };
+    /**
+     * Clear internal caches
+     */
+    ExpressionEngine.prototype.clearCache = function () {
+        this.evaluationCache.clear();
+        this.compiledFunctions.clear();
+    };
+    // Private helper methods
+    ExpressionEngine.prototype.getCacheKey = function (expression, formValues) {
+        // Simple cache key (in production, use better hashing)
+        return expression + ":" + JSON.stringify(formValues);
+    };
+    ExpressionEngine.prototype.buildContext = function (formValues) {
+        var intl = new Internationalization();
+        var dFormatter = intl.getDateFormat({
+            format: 'MM/dd/yyyy',
+            type: 'date'
+        });
+        return __assign({}, formValues, { 
+            // Constants
+            PI: Math.PI, TRUE: true, FALSE: false, NULL: null, UNDEFINED: undefined, Math: Math, 
+            // Aggregate Functions
+            SUM: function (values) { return Array.isArray(values) ? values.reduce(function (a, b) { return Number(a) + Number(b); }, 0) : 0; }, AVG: function (values) {
+                if (!Array.isArray(values) || values.length === 0)
+                    return 0;
+                var sum = values.reduce(function (a, b) { return Number(a) + Number(b); }, 0);
+                return sum / values.length;
+            }, MIN: function (values) { return Array.isArray(values) && values.length > 0 ? Math.min.apply(Math, values.map(Number)) : 0; }, MAX: function (values) { return Array.isArray(values) && values.length > 0 ? Math.max.apply(Math, values.map(Number)) : 0; }, COUNT: function (values) { return Array.isArray(values) ? values.length : 0; }, 
+            // Math Functions
+            ROUND: function (value, decimals) {
+                if (decimals === void 0) { decimals = 0; }
+                return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+            }, FLOOR: Math.floor, CEIL: Math.ceil, ABS: Math.abs, SQRT: Math.sqrt, 
+            // String Functions
+            UPPER: function (text) { return String(text).toUpperCase(); }, LOWER: function (text) { return String(text).toLowerCase(); }, CONCAT: function () {
+                var strings = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    strings[_i] = arguments[_i];
+                }
+                return strings.map(String).join('');
+            }, LENGTH: function (text) { return String(text).length; }, TRIM: function (text) { return String(text).trim(); }, SUBSTRING: function (text, start, length) {
+                return length !== undefined
+                    ? String(text).substr(start, length)
+                    : String(text).substr(start);
+            }, 
+            // Date Functions
+            TODAY: function () {
+                var value = dFormatter(new Date());
+                return value;
+            }, AGE: function (birthDate) {
+                var birth = typeof birthDate === 'string' ? new Date(birthDate) : birthDate;
+                var today = new Date();
+                var age = today.getFullYear() - birth.getFullYear();
+                var monthDiff = today.getMonth() - birth.getMonth();
+                if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birth.getDate())) {
+                    age--;
+                }
+                return age;
+            }, DATEFORMAT: function (date, format) {
+                var d = typeof date === 'string' ? new Date(date) : date;
+                var formatter = intl.getDateFormat({
+                    format: format,
+                    type: 'date'
+                });
+                // Simple date format implementation
+                return formatter(d);
+            }, DATEDIFF: function (date1, date2) {
+                var d1 = typeof date1 === 'string' ? new Date(date1) : date1;
+                var d2 = typeof date2 === 'string' ? new Date(date2) : date2;
+                return Math.floor((d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24));
+            }, 
+            // Add days to a date (for date arithmetic like {date} + 5)
+            ADDDAYS: function (date, days) {
+                var d = typeof date === 'string' ? new Date(date) : new Date(date);
+                d.setDate(d.getDate() + Number(days));
+                return dFormatter(d);
+            }, 
+            // Add days to a date (for date arithmetic like {date} + 5)
+            SUBDAYS: function (date, days) {
+                var d = typeof date === 'string' ? new Date(date) : new Date(date);
+                d.setDate(d.getDate() - Number(days));
+                return dFormatter(d);
+            } });
+    };
+    return ExpressionEngine;
+}());
+export { ExpressionEngine };
+/**
+ * ExpressionValidator - Validates expressions before runtime
+ *
+ * Checks syntax, validates field references, and detects circular dependencies
+ * @private
+ */
+var ExpressionValidator = /** @class */ (function () {
+    function ExpressionValidator() {
+        this.supportedFunctions = [
+            'SUM', 'AVG', 'MIN', 'MAX', 'COUNT',
+            'ROUND', 'FLOOR', 'CEIL', 'ABS', 'SQRT',
+            'UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'TRIM', 'SUBSTRING',
+            'TODAY', 'AGE', 'DATEFORMAT', 'DATEDIFF', 'ADDDAYS', 'SUBDAYS'
+        ];
+        this.keywords = ['PI', 'TRUE', 'FALSE', 'NULL', 'UNDEFINED', 'and', 'or', 'in'];
+    }
+    /**
+     * Validate expression against available fields
+     */
+    ExpressionValidator.prototype.validate = function (expression, availableFields) {
+        var errors = [];
+        if (!expression || expression.trim() === '') {
+            return errors; // Empty expression is valid
+        }
+        // Check syntax
+        var syntaxErrors = this.validateSyntax(expression);
+        errors.push.apply(errors, syntaxErrors);
+        // Check field references
+        var fieldErrors = this.validateFieldReferences(expression, availableFields);
+        errors.push.apply(errors, fieldErrors);
+        // Check function calls
+        var funcErrors = this.validateFunctionCalls(expression);
+        errors.push.apply(errors, funcErrors);
+        // Check field operations based on types
+        var opErrors = this.validateFieldOperations(expression, availableFields);
+        errors.push.apply(errors, opErrors);
+        return errors;
+    };
+    /**
+     * Validate field operations - check for invalid operators on string/date types
+     */
+    ExpressionValidator.prototype.validateFieldOperations = function (expression, availableFields) {
+        var errors = [];
+        // Skip if not field objects with type info
+        if (!Array.isArray(availableFields) || availableFields.length === 0) {
+            return errors;
+        }
+        var firstField = availableFields[0];
+        if (typeof firstField === 'string') {
+            return errors; // No type information available
+        }
+        // Build field map from objects
+        var fieldMap = new Map();
+        availableFields.forEach(function (field) {
+            if (field && typeof field === 'object' && field.name) {
+                fieldMap.set(field.name, field);
+            }
+        });
+        if (fieldMap.size === 0)
+            return errors;
+        // Track reported operator positions to avoid duplicates
+        var reportedOperators = new Set();
+        // Check each field reference for invalid operations
+        var fieldRefPattern = /(\{[^}]+\})/g;
+        var match;
+        // Invalid operators for string fields (allow only + for concatenation)
+        var stringInvalidOps = ['-', '*', '/', '%', '^'];
+        // Operators invalid for date fields (allow + for date arithmetic with numbers)
+        var dateInvalidOps = ['-', '*', '/', '%', '^', '+'];
+        while ((match = fieldRefPattern.exec(expression)) !== null) {
+            var fieldRef = match[0];
+            var fieldName = fieldRef.slice(1, -1); // Remove { }
+            var field = fieldMap.get(fieldName);
+            if (!field)
+                continue;
+            var fieldIndex = match.index;
+            var fieldEndIndex = fieldIndex + fieldRef.length;
+            // Get context around field reference (including spaces)
+            var textBefore = expression.substring(Math.max(0, fieldIndex - 10), fieldIndex);
+            var textAfter = expression.substring(fieldEndIndex, Math.min(expression.length, fieldEndIndex + 10));
+            // Extract the operator if present (skip spaces)
+            var operatorBefore = textBefore.replace(/\s+$/, '').slice(-1);
+            var operatorAfter = textAfter.replace(/^\s+/, '').charAt(0);
+            // Calculate actual position of operators in the original expression
+            var textBeforeTrimmed = textBefore.replace(/\s+$/, '');
+            var textAfterTrimmed = textAfter.replace(/^\s+/, '');
+            var operatorBeforePos = fieldIndex - (textBefore.length - textBeforeTrimmed.length) - 1;
+            var operatorAfterPos = fieldEndIndex + (textAfter.length - textAfterTrimmed.length);
+            // For STRING fields (without format)
+            if (field.type === 'string' && !field.format) {
+                if (operatorBefore && stringInvalidOps.indexOf(operatorBefore) !== -1) {
+                    var key = operatorBeforePos + ":" + operatorBefore;
+                    if (!reportedOperators.has(key)) {
+                        errors.push({
+                            type: 'InvalidOperation',
+                            message: "Cannot perform '" + operatorBefore + "' operation on string field '{" + fieldName + "}'"
+                        });
+                        reportedOperators.add(key);
+                    }
+                }
+                if (operatorAfter && stringInvalidOps.indexOf(operatorAfter) !== -1) {
+                    var key = operatorAfterPos + ":" + operatorAfter;
+                    if (!reportedOperators.has(key)) {
+                        errors.push({
+                            type: 'InvalidOperation',
+                            message: "Cannot perform '" + operatorAfter + "' operation on string field '{" + fieldName + "}'"
+                        });
+                        reportedOperators.add(key);
+                    }
+                }
+            }
+            // For DATE fields - allow + with numbers, reject other operators
+            if (field.format === 'date' || field.format === 'date-time' || field.format === 'time') {
+                if (operatorBefore && dateInvalidOps.indexOf(operatorBefore) !== -1) {
+                    var key = operatorBeforePos + ":" + operatorBefore;
+                    if (!reportedOperators.has(key)) {
+                        errors.push({
+                            type: 'InvalidOperation',
+                            message: "Cannot perform '" + operatorBefore + "' operation on date field '{" + fieldName + "}'"
+                        });
+                        reportedOperators.add(key);
+                    }
+                }
+                if (operatorAfter && dateInvalidOps.indexOf(operatorAfter) !== -1) {
+                    var key = operatorAfterPos + ":" + operatorAfter;
+                    if (!reportedOperators.has(key)) {
+                        errors.push({
+                            type: 'InvalidOperation',
+                            message: "Cannot perform '" + operatorAfter + "' operation on date field '{" + fieldName + "}'"
+                        });
+                        reportedOperators.add(key);
+                    }
+                }
+                // Allow + only when combined with numbers or number fields
+                if (operatorAfter === '+') {
+                    var operandAfter = textAfter.replace(/^\s+/, '').substring(1).trim();
+                    var isNumberField = /^\{[^}]+\}/.test(operandAfter) && fieldMap.get(operandAfter.slice(1, -1)) && fieldMap.get(operandAfter.slice(1, -1)).type === 'number';
+                    var isNumberLiteral = /^\d+/.test(operandAfter);
+                    if (!isNumberField && !isNumberLiteral) {
+                        var key = operatorAfterPos + ":" + operatorAfter;
+                        if (!reportedOperators.has(key)) {
+                            errors.push({
+                                type: 'InvalidOperation',
+                                message: "Date field '{" + fieldName + "}' can only be used with +number or +{numberField}, not '" + operatorAfter + operandAfter.substring(0, 10) + "'"
+                            });
+                            reportedOperators.add(key);
+                        }
+                    }
+                }
+                if (operatorBefore === '+') {
+                    var trimmedBefore = textBefore.replace(/\s+$/, '');
+                    var operandBefore = trimmedBefore.substring(0, trimmedBefore.length - 1).trim();
+                    var isNumberField = /\{[^}]+\}$/.test(operandBefore) && fieldMap.get(operandBefore.slice(operandBefore.lastIndexOf('{') + 1, -1)) && fieldMap.get(operandBefore.slice(operandBefore.lastIndexOf('{') + 1, -1)).type === 'number';
+                    var isNumberLiteral = /\d+$/.test(operandBefore);
+                    if (!isNumberField && !isNumberLiteral) {
+                        var key = operatorBeforePos + ":" + operatorBefore;
+                        if (!reportedOperators.has(key)) {
+                            errors.push({
+                                type: 'InvalidOperation',
+                                message: "Date field '{" + fieldName + "}' can only be used with +number or +{numberField}"
+                            });
+                            reportedOperators.add(key);
+                        }
+                    }
+                }
+            }
+        }
+        return errors;
+    };
+    ExpressionValidator.prototype.validateSyntax = function (expression) {
+        var errors = [];
+        // Check balanced braces
+        var openBraces = (expression.match(/\{/g) || []).length;
+        var closeBraces = (expression.match(/\}/g) || []).length;
+        if (openBraces !== closeBraces) {
+            errors.push({
+                type: 'SyntaxError',
+                message: 'Unbalanced braces in expression'
+            });
+        }
+        // Check balanced parentheses
+        var openParens = (expression.match(/\(/g) || []).length;
+        var closeParens = (expression.match(/\)/g) || []).length;
+        if (openParens !== closeParens) {
+            errors.push({
+                type: 'SyntaxError',
+                message: 'Unbalanced parentheses in expression'
+            });
+        }
+        // Check balanced $ brackets
+        var openDollar = (expression.match(/\$\{/g) || []).length;
+        var closeDollar = (expression.match(/\}/g) || []).length;
+        if (openDollar > closeDollar) {
+            errors.push({
+                type: 'SyntaxError',
+                message: 'Unbalanced ${ } in expression'
+            });
+        }
+        return errors;
+    };
+    /**
+     * @private
+     */
+    ExpressionValidator.prototype.validateFieldReferences = function (expression, availableFields) {
+        var errors = [];
+        // Skip field validation if availableFields is not properly populated
+        // This allows expressions to work at runtime even if we can't validate field names at editor time
+        if (!availableFields || availableFields.length === 0) {
+            return errors;
+        }
+        var fieldRefPattern = /\{([^{}]+)\}/g;
+        var match;
+        // Handle both string[] and AvailableField[] formats
+        var availableFieldsSet;
+        if (typeof availableFields[0] === 'string') {
+            availableFieldsSet = new Set(availableFields);
+        }
+        else {
+            availableFieldsSet = new Set(availableFields.map(function (f) { return f.name; }));
+        }
+        while ((match = fieldRefPattern.exec(expression)) !== null) {
+            var ref = match[1].trim();
+            // Skip if it's a function call
+            if (this.isFunctionCall(ref))
+                continue;
+            // Skip if it's a math expression (contains operators or numbers)
+            // This distinguishes between {fieldName} and ${5 + 3}
+            if (this.isMathExpression(ref))
+                continue;
+            // Extract field name from nested paths (e.g., "customer.name" -> "customer")
+            var fieldName = ref.split(/[.\[\]]/)[0].trim();
+            // Check if field exists
+            if (fieldName && this.keywords.indexOf(fieldName.toUpperCase()) === -1) {
+                if (!availableFieldsSet.has(fieldName)) {
+                    errors.push({
+                        type: 'UndefinedField',
+                        message: "Field '" + fieldName + "' is not defined in the form",
+                        field: fieldName
+                    });
+                }
+            }
+        }
+        return errors;
+    };
+    ExpressionValidator.prototype.validateFunctionCalls = function (expression) {
+        var errors = [];
+        var funcPattern = /(\w+)\s*\(/g;
+        var match;
+        while ((match = funcPattern.exec(expression)) !== null) {
+            var funcName = match[1];
+            // Only validate uppercase functions (user-defined lowercase functions might be allowed)
+            if (funcName === funcName.toUpperCase() && this.supportedFunctions.indexOf(funcName) === -1) {
+                errors.push({
+                    type: 'InvalidFunction',
+                    message: "Unknown function: '" + funcName + "'. Supported functions: " + this.supportedFunctions.join(', ')
+                });
+            }
+        }
+        return errors;
+    };
+    ExpressionValidator.prototype.isFunctionCall = function (ref) {
+        return /^\w+\s*\(/.test(ref);
+    };
+    ExpressionValidator.prototype.isMathExpression = function (ref) {
+        // Check if the expression contains math operators, numbers, or other non-field-name patterns
+        // Math expressions like: "5 + 3", "qty * 2", "age > 18", "sum([1,2,3])"
+        // should be skipped, while field references like "fieldName" or "customer.name" should be validated
+        var mathOperatorPattern = /[\+\-\*\/\%\=\<\>\!\&\|\^\~\s\d]/;
+        return mathOperatorPattern.test(ref);
+    };
+    return ExpressionValidator;
+}());
+export { ExpressionValidator };

package/src/common/expressions/expression-parser.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Field type information for validation
+ * @private
+ */
+export interface AvailableField {
+    name: string;
+    type: string;
+    format?: string;
+}
+/**
+ * ExpressionParser - Parse and compile expressions
+ *
+ * Converts string expressions into safe, compiled functions
+ * Supports field references, operators, functions, and conditionals
+ * @private
+ */
+export declare class ExpressionParser {
+    private supportedFunctions;
+    private availableFields;
+    /**
+     * Initialize parser with available fields for type validation
+     */
+    setAvailableFields(fields: AvailableField[]): void;
+    private validateFieldOperations;
+    /**
+     * Validate expression syntax
+     */
+    validate(expression: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Compile expression to executable function
+     */
+    compile(expression: string, options?: any): any;
+    private compileMatrixExpressions;
+    private compileBareFunctionCalls;
+    private compileFieldReferences;
+    private compileInputReferences;
+}