@syncfusion/ej2-form-renderer 34.2.2

package/src/common/conditional-rule-engine.js

@@ -0,0 +1,505 @@
+import { Internationalization } from '@syncfusion/ej2-base';
+/**
+ * ConditionalRuleEngine class
+ * @private
+ */
+var ConditionalRuleEngine = /** @class */ (function () {
+    function ConditionalRuleEngine() {
+    }
+    /**
+     * Evaluate a conditional rule against form values
+     *
+     * Handles both simple rules (field operator value) and composite rules (AND/OR).
+     * Returns false for malformed rules.
+     *
+     * @param rule - ConditionalRule or CompositeConditionalRule
+     * @param formValues - Current form field values (key = field name, value = field value)
+     * @returns true if condition met, false otherwise
+     * @private
+     * @example
+     * ```typescript
+     * const rule = { field: 'age', operator: 'greaterThan', value: 18 };
+     * const isAdult = ConditionalRuleEngine.evaluateCondition(rule, { age: 25 });
+     * // isAdult = true
+     * ```
+     */
+    ConditionalRuleEngine.evaluateCondition = function (rule, formValues) {
+        try {
+            // Handle simple rule (field operator value)
+            if ('field' in rule && 'operator' in rule && 'value' in rule) {
+                return this.evaluateSimpleRule(rule, formValues);
+            }
+            // Handle composite rule (AND/OR)
+            if ('condition' in rule && 'rules' in rule) {
+                return this.evaluateCompositeRule(rule, formValues);
+            }
+            return false;
+        }
+        catch (error) {
+            return false; // Safe default on error
+        }
+    };
+    /**
+     * Evaluate simple field comparison rule
+     *
+     * Supports operators: equal, notEqual, greaterThan, lessThan, greaterThanOrEqual,
+     * lessThanOrEqual, in, notIn, contains, notContains.
+     *
+     * Handles both camelCase (greaterThan) and lowercase (greaterthan) operator formats
+     * for compatibility with QueryBuilder output.
+     *
+     * @param rule - Simple conditional rule with field, operator, value
+     * @param formValues - Current form field values
+     * @returns true if comparison is true, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const rule = { field: 'email', operator: 'contains', value: '@' };
+     * const hasAt = evaluateSimpleRule(rule, { email: 'test@example.com' });
+     * // hasAt = true
+     * ```
+     */
+    ConditionalRuleEngine.evaluateSimpleRule = function (rule, formValues) {
+        try {
+            var fieldValue_1 = formValues[rule.field];
+            var operator = rule.operator.toLowerCase();
+            // Allow evaluation for operators that make sense when value is undefined/empty
+            if (fieldValue_1 === undefined) {
+                var allowedForUndefined = ['equal', 'equals', 'notequal', 'notequals', 'isempty', 'isnotempty'];
+                if (allowedForUndefined.indexOf(operator) === -1) {
+                    return false;
+                }
+            }
+            // Check if field value is an array (for multiselect, checkboxGroup)
+            var isFieldArray = Array.isArray(fieldValue_1);
+            var intl = new Internationalization();
+            switch (operator) {
+                case 'equal':
+                case 'equals':
+                    return fieldValue_1 === rule.value;
+                case 'notequal':
+                case 'notequals':
+                    return fieldValue_1 !== rule.value;
+                case 'startswith': return fieldValue_1.startsWith(rule.value);
+                case 'doesnotstartswith': return !fieldValue_1.startsWith(rule.value);
+                case 'greaterthan':
+                case 'lessthan':
+                case 'greaterthanorequal':
+                case 'lessthanorequal': {
+                    var ln = Number(fieldValue_1);
+                    var rn = Number(rule.value);
+                    if (!Number.isNaN(ln) && !Number.isNaN(rn)) {
+                        if (operator === 'greaterthan')
+                            return ln > rn;
+                        if (operator === 'lessthan')
+                            return ln < rn;
+                        if (operator === 'greaterthanorequal')
+                            return ln >= rn;
+                        return ln <= rn;
+                    }
+                    return false;
+                }
+                case 'dategreaterthan':
+                case 'datelessthan': {
+                    // try date comparison first
+                    var leftTs = intl.parseDate(fieldValue_1, { format: 'MM/dd/yyyy' });
+                    var rightTs = intl.parseDate(rule.value, { format: 'MM/dd/yyyy' });
+                    if (leftTs !== null && rightTs !== null) {
+                        if (operator === 'dategreaterthan')
+                            return leftTs > rightTs;
+                        if (operator === 'datelessthan')
+                            return leftTs < rightTs;
+                        return leftTs <= rightTs;
+                    }
+                    return false;
+                }
+                case 'timegreaterthan':
+                case 'timelessthan': {
+                    // Parse time strings (format: hh:mm a)
+                    var leftTime = intl.parseDate(fieldValue_1, { format: 'hh:mm a', type: 'time' });
+                    var rightTime = intl.parseDate(rule.value, { format: 'hh:mm a', type: 'time' });
+                    if (leftTime !== null && rightTime !== null) {
+                        if (operator === 'timegreaterthan')
+                            return leftTime > rightTime;
+                        if (operator === 'timelessthan')
+                            return leftTime < rightTime;
+                    }
+                    return false;
+                }
+                case 'datetimegreaterthan':
+                case 'datetimelessthan': {
+                    // Parse datetime strings (format: MM/dd/yyyy hh:mm a)
+                    var leftDateTime = intl.parseDate(fieldValue_1, { format: 'MM/dd/yyyy hh:mm a', type: 'dateTime' });
+                    var rightDateTime = intl.parseDate(rule.value, { format: 'MM/dd/yyyy hh:mm a', type: 'dateTime' });
+                    if (leftDateTime !== null && rightDateTime !== null) {
+                        if (operator === 'datetimegreaterthan')
+                            return leftDateTime > rightDateTime;
+                        if (operator === 'datetimelessthan')
+                            return leftDateTime < rightDateTime;
+                    }
+                    return false;
+                }
+                case 'contains':
+                    // If field value is array, check if array contains the specific value(s)
+                    if (isFieldArray) {
+                        // Parse comma-separated values in rule.value if it's a string
+                        if (typeof rule.value === 'string' && rule.value.indexOf(',') !== -1) {
+                            var searchValues = rule.value.split(',').map(function (v) { return v.trim(); });
+                            // Check if array contains ANY of the search values
+                            return searchValues.some(function (searchVal) { return fieldValue_1.indexOf(searchVal) !== -1; });
+                        }
+                        return fieldValue_1.indexOf(rule.value) !== -1;
+                    }
+                    // Otherwise, check string contains
+                    return String(fieldValue_1).indexOf(String(rule.value)) !== -1;
+                case 'notcontains':
+                    // If field value is array, check if array does NOT contain the specific value(s)
+                    if (isFieldArray) {
+                        // Parse comma-separated values in rule.value if it's a string
+                        if (typeof rule.value === 'string' && rule.value.indexOf(',') !== -1) {
+                            var searchValues = rule.value.split(',').map(function (v) { return v.trim(); });
+                            // Check if array contains NONE of the search values
+                            return !searchValues.some(function (searchVal) { return fieldValue_1.indexOf(searchVal) !== -1; });
+                        }
+                        return fieldValue_1.indexOf(rule.value) === -1;
+                    }
+                    // Otherwise, check string does not contain
+                    return String(fieldValue_1).indexOf(String(rule.value)) === -1;
+                case 'isempty':
+                    // Check if array is empty
+                    if (isFieldArray) {
+                        return fieldValue_1.length === 0;
+                    }
+                    // For non-arrays, check if falsy or empty string
+                    return !fieldValue_1 || String(fieldValue_1).length === 0;
+                case 'isnotempty':
+                    // Check if array has items
+                    if (isFieldArray) {
+                        return fieldValue_1.length > 0;
+                    }
+                    // For non-arrays, check if truthy and not empty string
+                    return !!fieldValue_1 && String(fieldValue_1).length > 0;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    };
+    /**
+     * Evaluate composite rule with AND/OR logic
+     *
+     * Recursively evaluates nested rules with AND (all must be true) or OR
+     * (at least one must be true) logic.
+     *
+     * @param rule - Composite rule with condition ('and'|'or') and rules array
+     * @param formValues - Current form field values
+     * @returns true if composite condition met, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const rule = {
+     *   condition: 'and',
+     *   rules: [
+     *     { field: 'age', operator: 'greaterThan', value: 18 },
+     *     { field: 'country', operator: 'equal', value: 'US' }
+     *   ]
+     * };
+     * const isEligible = evaluateCompositeRule(rule, { age: 25, country: 'US' });
+     * // isEligible = true
+     * ```
+     */
+    ConditionalRuleEngine.evaluateCompositeRule = function (rule, formValues) {
+        var _this = this;
+        try {
+            if (!Array.isArray(rule.rules) || rule.rules.length === 0) {
+                return false;
+            }
+            var condition = rule.condition.toLowerCase();
+            if (condition === 'and') {
+                // All rules must be true
+                return rule.rules.every(function (childRule) {
+                    return _this.evaluateCondition(childRule, formValues);
+                });
+            }
+            else if (condition === 'or') {
+                // At least one rule must be true
+                return rule.rules.some(function (childRule) {
+                    return _this.evaluateCondition(childRule, formValues);
+                });
+            }
+            else {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    };
+    /**
+     * Check if field should be visible
+     *
+     * Evaluates visibleWhen condition. Defaults to true (visible) if no condition
+     * is defined or on error.
+     *
+     * @param conditions - FormComponentConditions containing visibleWhen rule
+     * @param formValues - Current form field values
+     * @returns true if field should be visible, false if hidden
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   visibleWhen: { field: 'showEmail', operator: 'equal', value: true }
+     * };
+     * const visible = isFieldVisible(conditions, { showEmail: true });
+     * // visible = true
+     * ```
+     */
+    ConditionalRuleEngine.isFieldVisible = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.visibleWhen) {
+                return true; // Default: visible if no condition
+            }
+            return this.evaluateCondition(conditions.visibleWhen, formValues);
+        }
+        catch (error) {
+            return true; // Safe default: visible on error
+        }
+    };
+    /**
+     * Check if field should be read-only
+     *
+     * Evaluates readOnlyWhen condition. Defaults to false (editable) if no
+     * condition is defined or on error.
+     *
+     * @param conditions - FormComponentConditions containing readOnlyWhen rule
+     * @param formValues - Current form field values
+     * @returns true if field should be read-only, false if editable
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   readOnlyWhen: { field: 'isVerified', operator: 'equal', value: true }
+     * };
+     * const readOnly = isFieldReadOnly(conditions, { isVerified: true });
+     * // readOnly = true
+     * ```
+     */
+    ConditionalRuleEngine.isFieldReadOnly = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.readOnlyWhen) {
+                return false; // Default: not read-only if no condition
+            }
+            return this.evaluateCondition(conditions.readOnlyWhen, formValues);
+        }
+        catch (error) {
+            return false; // Safe default: not read-only on error
+        }
+    };
+    /**
+     * Check if field should be disabled
+     *
+     * Evaluates disabledWhen condition. Defaults to false (enabled) if no
+     * condition is defined or on error.
+     *
+     * @param conditions - FormComponentConditions containing disabledWhen rule
+     * @param formValues - Current form field values
+     * @returns true if field should be disabled, false if enabled
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   disabledWhen: { field: 'orderStatus', operator: 'equal', value: 'completed' }
+     * };
+     * const disabled = isFieldDisabled(conditions, { orderStatus: 'completed' });
+     * // disabled = true
+     * ```
+     */
+    ConditionalRuleEngine.isFieldDisabled = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.disabledWhen) {
+                return false; // Default: not disabled if no condition
+            }
+            return this.evaluateCondition(conditions.disabledWhen, formValues);
+        }
+        catch (error) {
+            return false; // Safe default: not disabled on error
+        }
+    };
+    /**
+     * Check if field should be hidden
+     *
+     * Evaluates hideWhen condition. Defaults to false (visible) if no condition
+     * is defined or on error.
+     *
+     * @param conditions - FormComponentConditions containing hideWhen rule
+     * @param formValues - Current form field values
+     * @returns true if field should be hidden, false if visible
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   hideWhen: { field: 'hideEmail', operator: 'equal', value: true }
+     * };
+     * const hidden = isFieldHidden(conditions, { hideEmail: true });
+     * // hidden = true
+     * ```
+     */
+    ConditionalRuleEngine.isFieldHidden = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.hideWhen) {
+                return false; // Default: not hidden if no condition
+            }
+            return this.evaluateCondition(conditions.hideWhen, formValues);
+        }
+        catch (error) {
+            return false; // Safe default: not hidden on error
+        }
+    };
+    /**
+     * Check if field should be required
+     *
+     * Evaluates requiredWhen condition. Defaults to false (not required) if no condition
+     * is defined or on error.
+     *
+     * @param conditions - FormComponentConditions containing requiredWhen rule
+     * @param formValues - Current form field values
+     * @returns true if field should be required, false if optional
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   requiredWhen: { field: 'requireDetails', operator: 'equal', value: true }
+     * };
+     * const required = isFieldRequired(conditions, { requireDetails: true });
+     * // required = true
+     * ```
+     */
+    ConditionalRuleEngine.isFieldRequired = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.requiredWhen) {
+                return false; // Default: not required if no condition
+            }
+            return this.evaluateCondition(conditions.requiredWhen, formValues);
+        }
+        catch (error) {
+            return false; // Safe default: not required on error
+        }
+    };
+    /**
+     * Get value to set for field if condition is met
+     *
+     * Evaluates setValueWhen condition and returns the value to assign if true.
+     * Returns undefined if no condition is defined, condition not met, or on error.
+     *
+     * @param conditions - FormComponentConditions containing setValueWhen rule
+     * @param formValues - Current form field values
+     * @returns The value to set if condition met, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const conditions = {
+     *   setValueWhen: {
+     *     condition: { field: 'country', operator: 'equal', value: 'US' },
+     *     value: 'United States'
+     *   }
+     * };
+     * const value = getConditionalValue(conditions, { country: 'US' });
+     * // value = 'United States'
+     * ```
+     */
+    ConditionalRuleEngine.getConditionalValue = function (conditions, formValues) {
+        try {
+            if (!conditions || !conditions.setValueWhen) {
+                return undefined;
+            }
+            var isMet = this.evaluateCondition(conditions.setValueWhen.condition, formValues);
+            if (isMet) {
+                return conditions.setValueWhen.value;
+            }
+            return undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    };
+    /**
+     * Evaluate conditional data availability
+     * Returns true if any conditional data rule's condition is met
+     *
+     * @param conditionalDataRules - Array of ConditionalDataRule objects
+     * @param formValues - Current form field values
+     * @returns Index of first matching rule, or -1 if none match
+     */
+    ConditionalRuleEngine.evaluateConditionalDataRules = function (conditionalDataRules, formValues) {
+        if (!conditionalDataRules || !Array.isArray(conditionalDataRules)) {
+            return -1;
+        }
+        for (var i = 0; i < conditionalDataRules.length; i++) {
+            var rule = conditionalDataRules[i];
+            if (this.evaluateCondition(rule.condition, formValues)) {
+                return i; // Return index of first matching rule
+            }
+        }
+        return -1;
+    };
+    /**
+   * Get filtered options for a dependent dropdown based on choice-based field rule
+   *
+   * If choiceBasedField rule exists and primary field has a value,
+   * return only the mapped dependent options for that primary value.
+   * Otherwise return all options.
+   *
+   * @param rule - ChoiceBasedFieldRule configuration
+   * @param allDependentOptions - Complete list of dependent field options
+   * @param formValues - Current form values
+   * @param primaryFieldId - ID of primary field
+   * @returns Filtered options array
+   *
+   * @example
+   * ```typescript
+   * const rule = {
+   *   primaryFieldId: 'dept-id',
+   *   choiceMapping: {
+   *     'Marketing': ['Markers', 'Sticky Notes'],
+   *     'Finance': ['Calculator']
+   *   }
+   * };
+   *
+   * const filtered = ConditionalRuleEngine.getChoiceBasedOptions(
+   *   rule,
+   *   ['Markers', 'Sticky Notes', 'Calculator'],
+   *   { 'dept-id': 'Marketing' },
+   *   'dept-id'
+   * );
+   * // Returns: ['Markers', 'Sticky Notes']
+   * ```
+   */
+    ConditionalRuleEngine.getChoiceBasedOptions = function (rule, allDependentOptions, formValues, primaryFieldId) {
+        try {
+            // Get primary field value from form
+            var primaryValue = formValues && formValues[primaryFieldId];
+            if (primaryValue === null || primaryValue === undefined) {
+                // No primary value selected - return all or empty based on rule config
+                return rule.showAllWhenNotMapped ? allDependentOptions : [];
+            }
+            // Ensure primary value is treated as string for comparison
+            var primaryValueStr = String(primaryValue);
+            // Check if this primary value is mapped in the rule
+            if (primaryValueStr in rule.choiceMapping) {
+                var mappedOptions = rule.choiceMapping[primaryValueStr];
+                // Validate mapped options exist in all options (safety check)
+                return mappedOptions.filter(function (opt) { return allDependentOptions.indexOf(opt) !== -1; });
+            }
+            // Primary value not mapped - return all or empty based on rule config
+            return rule.showAllWhenNotMapped ? allDependentOptions : [];
+        }
+        catch (error) {
+            // Safe default - return all options
+            return allDependentOptions;
+        }
+    };
+    return ConditionalRuleEngine;
+}());
+export { ConditionalRuleEngine };

package/src/common/custom-validation-engine.d.ts

@@ -0,0 +1,57 @@
+import { FormValueType } from './expressions/expression-engine';
+/**
+ * Custom Validation Engine
+ *
+ * Evaluates FormIO-style custom validation expressions:
+ * valid = (condition) ? true : 'error message';
+ *
+ * Reuses ExpressionEngine for dependency extraction and expression parsing
+ * @private
+ */
+export declare class CustomValidationEngine {
+    private expressionEngine;
+    constructor();
+    /**
+     * Validate field using custom validation expression
+     *
+     * @param expression - FormIO-style validation expression (generated by UI)
+     * @param fieldValue - Current field value (as 'input')
+     * @param formValues - All form values for cross-field references
+     * @returns true if valid, error message string if invalid
+     */
+    validate(expression: string, fieldValue: any, formValues: Record<string, FormValueType>): true | string;
+    /**
+     * Extract field dependencies from validation expression
+     *
+     * @param expression - Custom validation expression (or just condition)
+     * @returns Array of field names referenced in expression
+     */
+    extractDependencies(expression: string): string[];
+    /**
+     * Validate condition syntax (simplified - no need for "valid =" check)
+     *
+     * @param condition - Validation condition (without "valid =" prefix)
+     * @param availableFields - Available field names for reference validation
+     * @returns Array of validation error messages
+     */
+    validateConditionSyntax(condition: string, availableFields: string[]): string[];
+    /**
+     * Build full FormIO expression from condition and error message
+     *
+     * @param condition - Validation condition (e.g., "(input === {password})")
+     * @param errorMessage - Error message to show when validation fails
+     * @returns Full FormIO expression
+     */
+    buildExpression(condition: string, errorMessage: string): string;
+    /**
+     * Extract condition and error message from full FormIO expression
+     * For editing existing rules
+     *
+     * @param expression - Full FormIO expression
+     * @returns { condition, errorMessage } or null if invalid
+     */
+    parseExpression(expression: string): {
+        condition: string;
+        errorMessage: string;
+    } | null;
+}