@syncfusion/ej2-form-renderer 34.2.2

package/src/common/custom-validation-engine.js

@@ -0,0 +1,152 @@
+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 { ExpressionEngine } 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
+ */
+var CustomValidationEngine = /** @class */ (function () {
+    function CustomValidationEngine() {
+        this.expressionEngine = new ExpressionEngine();
+    }
+    /**
+     * 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
+     */
+    CustomValidationEngine.prototype.validate = function (expression, fieldValue, formValues) {
+        if (!expression || expression.trim() === '') {
+            return true; // No validation rule = valid
+        }
+        try {
+            // Inject 'input' as current field value
+            var context = __assign({}, formValues, { input: fieldValue, valid: true // Initialize valid variable
+             });
+            // Parse expression - FormIO pattern uses assignment: valid = ...
+            // Pattern: valid = (condition) ? true : 'error message'
+            var validPattern = /valid\s*=\s*(.+?)\s*\?\s*true\s*:\s*['"](.+?)['"]\s*$/;
+            var match = expression.match(validPattern);
+            if (!match) {
+                return 'Invalid validation expression format';
+            }
+            var condition = match[1].trim();
+            var errorMessage = match[2];
+            // Evaluate the condition (should return boolean)
+            var conditionResult = this.expressionEngine.evaluate(condition, context, { throwOnError: false }, true);
+            // If condition is true, validation passes
+            if (conditionResult === true) {
+                return true;
+            }
+            else {
+                // Condition is false, return the error message
+                return errorMessage;
+            }
+        }
+        catch (error) {
+            return 'Validation expression error';
+        }
+    };
+    /**
+     * Extract field dependencies from validation expression
+     *
+     * @param expression - Custom validation expression (or just condition)
+     * @returns Array of field names referenced in expression
+     */
+    CustomValidationEngine.prototype.extractDependencies = function (expression) {
+        if (!expression)
+            return [];
+        // Extract validation logic (right side of = sign if present)
+        var validPattern = /valid\s*=\s*(.+)/;
+        var match = expression.match(validPattern);
+        var validationLogic = match ? match[1] : expression;
+        // Use ExpressionEngine to extract field references
+        var deps = this.expressionEngine.extractDependencies(validationLogic);
+        // Filter out 'input' as it's the current field, not a dependency
+        return deps.filter(function (dep) { return dep !== 'input'; });
+    };
+    /**
+     * 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
+     */
+    CustomValidationEngine.prototype.validateConditionSyntax = function (condition, availableFields) {
+        if (!condition || condition.trim() === '') {
+            return ['Condition cannot be empty'];
+        }
+        var errors = [];
+        // Check for balanced parentheses
+        var openParens = (condition.match(/\(/g) || []).length;
+        var closeParens = (condition.match(/\)/g) || []).length;
+        if (openParens !== closeParens) {
+            errors.push("Unbalanced parentheses (" + openParens + " open, " + closeParens + " close)");
+        }
+        // Check for balanced braces
+        var openBraces = (condition.match(/\{/g) || []).length;
+        var closeBraces = (condition.match(/\}/g) || []).length;
+        if (openBraces !== closeBraces) {
+            errors.push("Unbalanced braces (" + openBraces + " open, " + closeBraces + " close)");
+        }
+        // Validate field references
+        var deps = this.extractDependencies(condition);
+        var invalidFields = deps.filter(function (field) { return availableFields.indexOf(field) === -1; });
+        if (invalidFields.length > 0) {
+            errors.push("Unknown field references: " + invalidFields.join(', '));
+        }
+        return errors;
+    };
+    /**
+     * 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
+     */
+    CustomValidationEngine.prototype.buildExpression = function (condition, errorMessage) {
+        // Remove outer parentheses if present (we'll add them back in ternary)
+        var trimmedCondition = condition.trim();
+        // Escape single quotes in error message
+        var escapedMessage = errorMessage.replace(/'/g, "\\'");
+        // Build FormIO expression
+        return "valid = " + trimmedCondition + " ? true : '" + escapedMessage + "'";
+    };
+    /**
+     * 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
+     */
+    CustomValidationEngine.prototype.parseExpression = function (expression) {
+        // Pattern: valid = (condition) ? true : 'error message'
+        var pattern = /valid\s*=\s*(.+?)\s*\?\s*true\s*:\s*'(.+)'/;
+        var match = expression.match(pattern);
+        if (match) {
+            return {
+                condition: match[1].trim(),
+                errorMessage: match[2].replace(/\\'/g, "'") // Unescape quotes
+            };
+        }
+        return null;
+    };
+    return CustomValidationEngine;
+}());
+export { CustomValidationEngine };

package/src/common/datagrid-component.d.ts

@@ -0,0 +1,156 @@
+import { Grid } from '@syncfusion/ej2-grids';
+/**
+ * @private
+ */
+export interface GridColumn {
+    field: string;
+    headerText?: string;
+    type?: 'string' | 'number' | 'boolean' | 'date' | 'datetime';
+    isPrimaryKey?: boolean;
+    width?: number | string;
+    format?: string;
+    editType?: string;
+    allowEditing?: boolean;
+    expression?: string;
+    validationRules?: any;
+    customValidation?: {
+        expression: string;
+    }[];
+}
+/**
+ * @private
+ */
+export interface GridComponentSchema {
+    id?: string;
+    columns?: GridColumn[];
+    dataSource?: Record<string, any>[];
+    height?: string | number;
+    width?: string | number;
+    locale?: string;
+    cssClass?: string;
+    pageSize?: number;
+    allowPaging?: boolean;
+    allowAdding?: boolean;
+    allowEditing?: boolean;
+    allowDeleting?: boolean;
+    allowFiltering?: boolean;
+}
+/**
+ * @private
+ */
+export interface DataGridRef {
+    getGridData: () => Record<string, any>[];
+    gridRef: {
+        current: Grid | null;
+    };
+}
+/**
+ * @private
+ * Constructor options for `DataGridComponent`.
+ */
+export interface DataGridComponentOptions extends GridComponentSchema {
+    isPreviewMode?: boolean;
+    onDataChange?: (data: Record<string, any>[]) => void;
+    enableRtl?: boolean;
+    target?: HTMLElement;
+    ref?: any;
+}
+/**
+ * @private
+ *
+ * `DataGridComponent` is the Category C native reimplementation of
+ * `Common/DataGridComponent.tsx` using the EJ2 `Grid` (with `Edit`,
+ * `Toolbar`, `Page`, `Resize`, `Sort`, `Filter` inject modules).
+ *
+ * Reproduces:
+ *  - internal current-data state seeded from `dataSource`;
+ *  - calculated/expression columns (disable `allowEditing`, recompute on
+ *    sibling field change via edit `change` params, update UI value by
+ *    column type);
+ *  - per-column custom validation merged into `validationRules`
+ *    (required + custom validator via `CustomValidationEngine`);
+ *  - dynamic toolbar (`Add`/`Edit`/`Delete` conditional + always
+ *    `Update`/`Cancel`);
+ *  - `actionComplete` → sync state + `onDataChange` callback;
+ *  - `getGridData()` equivalent;
+ *  - column mapping (`field, headerText, type, isPrimaryKey, width,
+ *    format (date default 'MM/dd/yyyy'), editType, allowEditing`);
+ *  - `filterSettings.mode='Immediate'`.
+ */
+export declare class DataGridComponent {
+    private id?;
+    private columns;
+    private dataSource;
+    private height;
+    private width;
+    private locale;
+    private cssClass;
+    private pageSize;
+    private allowPaging;
+    private allowAdding;
+    private allowEditing;
+    private allowDeleting;
+    private allowFiltering;
+    private onDataChange;
+    private isPreviewMode;
+    private enableRtl;
+    private ref;
+    private currentData;
+    private grid;
+    private gridExpressions;
+    private validationEngine;
+    private wrapper;
+    constructor(options: DataGridComponentOptions);
+    private readonly calculatedColumns;
+    private readonly hasExpressions;
+    /**
+     * Map React custom validation to a Syncfusion-style custom validator
+     * closure. Mirrors `mapCustomValidationToSyncfusion`.
+     */
+    private mapCustomValidationToSyncfusion;
+    /**
+     * Create edit params attaching a `change` callback for non-calculated
+     * columns that have calc dependents. Mirrors `createEditParams`.
+     */
+    private createEditParams;
+    /**
+     * Sync the working data on `actionComplete`. Mirrors `handleActionComplete`.
+     */
+    private handleActionComplete;
+    /**
+     * Build the dynamic toolbar array. Mirrors `buildToolbar`.
+     */
+    private buildToolbar;
+    /**
+     * Map a GridColumn to the EJ2 Grid column model, merging standard + custom
+     * validation rules and disabling editing on expression / no-edit columns.
+     */
+    private mapColumn;
+    /**
+     * Build the grid element, instantiate `Grid`, inject services and append
+     * to the target/created container. Returns the wrapper element.
+     */
+    render(targetOrHost?: HTMLElement): HTMLElement;
+    /**
+     * @private
+     */
+    getRef(): DataGridRef;
+    /**
+     * Equivalent of `getGridData()`.
+     */
+    getGridData(): Record<string, any>[];
+    /**
+     * Recompute expression-bearing rows from fresh `dataSource` (mirrors the
+     * useEffect on `[dataSource, hasExpressions, columns, ...]`).
+     */
+    setDataSource(dataSource: Record<string, any>[]): void;
+    /**
+     * Re-detect columns; refresh the grid (mirrors the useEffect on columns).
+     */
+    setColumns(columns: GridColumn[]): void;
+    /**
+     * @private
+     */
+    destroy(): void;
+}
+export default DataGridComponent;