@syncfusion/ej2-form-renderer 34.2.2

package/src/common/parser.js

@@ -0,0 +1,788 @@
+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 { sanitizeId, VALIDATION_REGEX } from './utils';
+/**
+ * @private
+ */
+var DEFAULT_CONFIG = {
+    strict: false,
+    maxInputSize: 5 * 1024 * 1024,
+    defaultTextType: 'textbox',
+    inferTypeFromValue: true,
+    generateIds: true,
+    includeMetadata: true,
+    customTypeMap: {},
+    validateUnknownFields: false
+};
+/**
+ * @private
+ */
+var UniversalJsonParser = /** @class */ (function () {
+    function UniversalJsonParser(customConfig) {
+        this.config = __assign({}, DEFAULT_CONFIG, customConfig);
+    }
+    UniversalJsonParser.prototype.parse = function (input) {
+        var errors = [];
+        var warnings = [];
+        // Handle string input
+        if (typeof input === 'string') {
+            if (input.length > this.config.maxInputSize) {
+                return this.formatError(errors, warnings, "Input exceeds maximum size of " + this.config.maxInputSize + " bytes");
+            }
+            var jsonValidation = validateJSON(input);
+            if (!jsonValidation.valid) {
+                return this.formatError(errors, warnings, (jsonValidation.errors && jsonValidation.errors[0]) || 'Invalid JSON');
+            }
+            try {
+                input = JSON.parse(input);
+            }
+            catch (error) {
+                return this.formatError(errors, warnings, "Failed to parse JSON: " + error.message);
+            }
+        }
+        // Detect format
+        var detection = this.detectFormat(input);
+        // Add warnings for ambiguous format detection
+        if (detection.ambiguousFormats && detection.ambiguousFormats.length > 0) {
+            warnings.push("Ambiguous format detected.");
+            warnings.push("Using " + detection.format + " format (" + (detection.format === 'json-schema' ? 'properties priority' : 'pages priority') + ")");
+        }
+        // Parse based on format
+        var components = [];
+        switch (detection.format) {
+            case 'configured-schema':
+                // Already in our standard format, just use directly
+                components = input.properties || [];
+                break;
+            case 'json-schema': {
+                var jsonSchemaResult = this.parseJsonSchema(input);
+                components = jsonSchemaResult.components;
+                if (jsonSchemaResult.warnings) {
+                    warnings.push.apply(warnings, jsonSchemaResult.warnings);
+                }
+                break;
+            }
+            case 'surveyjs':
+                components = this.parseSurveyJS(input);
+                break;
+            case 'openapi':
+                components = this.parseOpenAPI(input);
+                break;
+            case 'data-inference':
+                components = this.parseDataInference(input);
+                // Only warn about inferred types if components were actually created
+                if (components.length > 0) {
+                    warnings.push('Field types inferred from data; please verify');
+                }
+                break;
+            default:
+                errors.push('Could not determine input format');
+        }
+        if (components.length === 0) {
+            errors.push('No form fields could be extracted from input');
+        }
+        // Add default submit button if not already present
+        var hasSubmitButton = components.some(function (comp) { return comp.type === 'button' && comp.buttonType === 'submit'; });
+        if (!hasSubmitButton && components.length > 0) {
+            components.push({
+                id: this.generateComponentId('button'),
+                type: 'button',
+                label: 'Submit',
+                style: 'primary',
+                buttonType: 'submit',
+            });
+        }
+        var schema = {
+            version: input.version || "0.1.0",
+            components: components
+        };
+        var schemaValidation = validateFormSchema(schema);
+        if (!schemaValidation.valid && schemaValidation.errors) {
+            errors.push.apply(errors, schemaValidation.errors);
+        }
+        if (schemaValidation.warnings) {
+            warnings.push.apply(warnings, schemaValidation.warnings);
+        }
+        if (this.config.strict && warnings.length > 0) {
+            errors.push.apply(errors, warnings);
+            warnings.length = 0;
+        }
+        var sanitized = sanitizeFormSchema(schema);
+        return {
+            success: errors.length === 0,
+            schema: sanitized,
+            errors: errors,
+            warnings: warnings,
+            metadata: {
+                detectedFormat: detection.format,
+                confidence: detection.confidence,
+                sourceHints: detection.hints
+            }
+        };
+    };
+    UniversalJsonParser.prototype.formatError = function (errors, warnings, message) {
+        errors.push(message);
+        return {
+            success: false,
+            schema: null,
+            errors: errors,
+            warnings: warnings,
+            metadata: {
+                detectedFormat: 'unknown',
+                confidence: 'low',
+                sourceHints: []
+            }
+        };
+    };
+    UniversalJsonParser.prototype.detectFormat = function (input) {
+        var hints = [];
+        var ambiguousFormats = [];
+        if (!input || typeof input !== 'object') {
+            return {
+                format: 'unknown',
+                confidence: 'low',
+                hints: ['Input is not a valid object']
+            };
+        }
+        // Check for JSON Schema indicators
+        if (input.$schema && typeof input.$schema === 'string' && input.$schema.includes('json-schema')) {
+            hints.push('$schema property detected');
+            return { format: 'json-schema', confidence: 'high', hints: hints };
+        }
+        // Detect ambiguous formats (Test Case 8)
+        var hasProperties = input.properties && typeof input.properties === 'object';
+        var hasPages = input.pages && Array.isArray(input.pages);
+        var hasElements = input.elements && Array.isArray(input.elements);
+        if (hasProperties && hasPages) {
+            hints.push('Multiple format patterns detected');
+            hints.push('Selected based on priority rules');
+            ambiguousFormats.push('properties format', 'pages format');
+            // JSON Schema has priority
+            return {
+                format: 'json-schema',
+                confidence: 'medium',
+                hints: hints,
+                ambiguousFormats: ambiguousFormats
+            };
+        }
+        // Check for SurveyJS with pages
+        if (hasPages) {
+            hints.push('pages array detected');
+            if (input.pages[0] && input.pages[0].elements)
+                hints.push('elements structure matched');
+            return { format: 'surveyjs', confidence: 'high', hints: hints };
+        }
+        // Check for SurveyJS with elements at root
+        if (hasElements && !hasProperties) {
+            hints.push('elements array at root level');
+            return { format: 'surveyjs', confidence: 'medium', hints: hints };
+        }
+        // Check for JSON Schema with properties
+        if (hasProperties) {
+            hints.push('properties object detected');
+            if (input.type === 'object')
+                hints.push('type: object matched');
+            if (input.required && Array.isArray(input.required))
+                hints.push('required array found');
+            // Check for API schema indicators (example fields pattern)
+            if (this.hasExampleFields(input.properties)) {
+                hints.push('example fields detected (API schema pattern)');
+                return { format: 'openapi', confidence: 'high', hints: hints };
+            }
+            return { format: 'json-schema', confidence: 'high', hints: hints };
+        }
+        // Check for Data Inference
+        if (this.isDataInferenceCandidate(input)) {
+            hints.push('Simple object with primitive values');
+            hints.push('No schema indicators found');
+            return { format: 'data-inference', confidence: 'medium', hints: hints };
+        }
+        return {
+            format: 'unknown',
+            confidence: 'low',
+            hints: ['Could not identify format']
+        };
+    };
+    UniversalJsonParser.prototype.hasExampleFields = function (properties) {
+        if (!properties || typeof properties !== 'object')
+            return false;
+        var keys = Object.keys(properties);
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            var prop = properties[key];
+            if (prop && 'example' in prop) {
+                return true;
+            }
+        }
+        return false;
+    };
+    UniversalJsonParser.prototype.isDataInferenceCandidate = function (input) {
+        if (!input || typeof input !== 'object')
+            return false;
+        if (input.$schema || input.properties || input.pages || input.elements)
+            return false;
+        var inputKeys = Object.keys(input);
+        return inputKeys.every(function (k) {
+            var val = input[k];
+            if (val === null || val === undefined)
+                return true;
+            if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean')
+                return true;
+            if (Array.isArray(val)) {
+                return val.every(function (item) {
+                    return typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean';
+                });
+            }
+            return false;
+        });
+    };
+    UniversalJsonParser.prototype.inferComponentType = function (fieldName, value) {
+        var valueType = this.inferTypeFromValue(fieldName, value);
+        if (valueType.type) {
+            return __assign({}, valueType, { confidence: 'high', method: 'value-type' });
+        }
+        var patternMatch = this.matchFieldNamePattern(fieldName);
+        if (patternMatch.type) {
+            return __assign({}, patternMatch, { confidence: 'high', method: 'name-pattern' });
+        }
+        return {
+            type: this.config.defaultTextType,
+            confidence: 'low',
+            method: 'fallback'
+        };
+    };
+    UniversalJsonParser.prototype.inferTypeFromValue = function (fieldName, value) {
+        if (!this.config.inferTypeFromValue)
+            return { type: 'textbox' };
+        if (value === null || value === undefined) {
+            // Even with null/undefined values, check field name patterns
+            return this.matchFieldNamePattern(fieldName);
+        }
+        if (typeof value === 'string') {
+            // Check value-based patterns first (highest confidence)
+            if (value.includes('@') && value.includes('.')) {
+                return { type: 'textbox', textboxType: 'email' };
+            }
+            // eslint-disable-next-line security/detect-unsafe-regex
+            if (/^(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}/.test(value)) {
+                return { type: 'textbox', textboxType: 'url' };
+            }
+            if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+                return { type: 'date' };
+            }
+            // For generic strings, check field name patterns
+            var fieldNameMatch = this.matchFieldNamePattern(fieldName);
+            if (fieldNameMatch.type !== 'textbox' || fieldNameMatch.textboxType) {
+                return fieldNameMatch;
+            }
+            return { type: this.config.defaultTextType };
+        }
+        if (typeof value === 'number') {
+            return { type: 'number' };
+        }
+        if (typeof value === 'boolean') {
+            return { type: 'checkbox' };
+        }
+        if (Array.isArray(value)) {
+            return { type: 'multiselect' };
+        }
+        return { type: 'textbox' };
+    };
+    UniversalJsonParser.prototype.matchFieldNamePattern = function (fieldName) {
+        if (this.config.customTypeMap) {
+            var customType = this.config.customTypeMap[fieldName.toLowerCase()];
+            if (customType)
+                return { type: customType };
+        }
+        var lower = fieldName.toLowerCase();
+        var normalized = lower.replace(/[_\-\s]+/g, ' ');
+        if (/email|mail|e-?mail/.test(normalized))
+            return { type: 'textbox', textboxType: 'email' };
+        if (/date|birth|birthday|dob|created|updated/.test(normalized))
+            return { type: 'date' };
+        if (/phone|tel|mobile|cell|cellphone|msisdn/.test(normalized))
+            return { type: 'textbox', textboxType: 'number' };
+        if (/url|link|uri|website/.test(normalized))
+            return { type: 'textbox', textboxType: 'url' };
+        if (/password|pwd|pass|security|secret|key|token/.test(normalized))
+            return { type: 'textbox', textboxType: 'password' };
+        if (/\b(?:age|count|qty|quantity|amount|price|cost|salary|fee|rate|number|num)\b/.test(normalized))
+            return { type: 'number' };
+        if (/active|enabled|visible|deleted|archived|approved|confirmed/.test(normalized))
+            return { type: 'checkbox' };
+        if (/select|choice|option|type|status|category|kind/.test(normalized))
+            return { type: 'dropdown' };
+        if (/description|comment|note|bio|biography|about|message|content|summary|details/.test(normalized))
+            return { type: 'textarea' };
+        return { type: 'textbox' };
+    };
+    UniversalJsonParser.prototype.parseJsonSchema = function (schema) {
+        var components = [];
+        var warnings = [];
+        if (!schema.properties || typeof schema.properties !== 'object')
+            return { components: components, warnings: warnings };
+        var flattenedProperties = this.flattenNestedProperties(schema.properties, '', warnings);
+        var flatKeys = Object.keys(flattenedProperties);
+        for (var _i = 0, flatKeys_1 = flatKeys; _i < flatKeys_1.length; _i++) {
+            var key = flatKeys_1[_i];
+            var propDef = flattenedProperties[key];
+            var typeInfo = this.mapJsonSchemaType(propDef);
+            var requiredArr = schema.required || [];
+            var isRequired = requiredArr.indexOf(key) !== -1;
+            components.push(this.createComponent(key, propDef, typeInfo, { required: isRequired }));
+        }
+        return { components: components, warnings: warnings };
+    };
+    UniversalJsonParser.prototype.flattenNestedProperties = function (properties, prefix, warnings) {
+        var flattened = {};
+        var hasNested = false;
+        var propKeys = Object.keys(properties);
+        for (var _i = 0, propKeys_1 = propKeys; _i < propKeys_1.length; _i++) {
+            var key = propKeys_1[_i];
+            var propDef = properties[key];
+            var fullKey = prefix ? prefix + "_" + key : key;
+            // Check if this is a nested object (Test Case 9)
+            if (propDef.type === 'object' && propDef.properties && typeof propDef.properties === 'object') {
+                hasNested = true;
+                var nestedFlattened = this.flattenNestedProperties(propDef.properties, fullKey, warnings);
+                Object.assign(flattened, nestedFlattened);
+            }
+            else {
+                flattened[fullKey] = propDef;
+            }
+        }
+        // Add warnings for nested objects
+        if (hasNested && !prefix) {
+            warnings.push('NESTED_OBJECTS_FLATTENED: Nested objects converted to flat structure');
+            var outerKeys = Object.keys(properties);
+            for (var _a = 0, outerKeys_1 = outerKeys; _a < outerKeys_1.length; _a++) {
+                var key = outerKeys_1[_a];
+                var propDef = properties[key];
+                if (propDef.type === 'object' && propDef.properties) {
+                    this.collectFlattenedFieldNames(propDef.properties, key, warnings);
+                }
+            }
+        }
+        return flattened;
+    };
+    UniversalJsonParser.prototype.collectFlattenedFieldNames = function (properties, prefix, warnings) {
+        var collKeys = Object.keys(properties);
+        for (var _i = 0, collKeys_1 = collKeys; _i < collKeys_1.length; _i++) {
+            var key = collKeys_1[_i];
+            var propDef = properties[key];
+            var fullKey = prefix + "_" + key;
+            warnings.push("Field '" + prefix + "." + key + "' flattened to '" + fullKey + "'");
+            if (propDef.type === 'object' && propDef.properties) {
+                this.collectFlattenedFieldNames(propDef.properties, fullKey, warnings);
+            }
+        }
+    };
+    UniversalJsonParser.prototype.parseSurveyJS = function (schema) {
+        var _this = this;
+        var components = [];
+        if (schema.pages && Array.isArray(schema.pages)) {
+            schema.pages.forEach(function (page) {
+                if (page.elements && Array.isArray(page.elements)) {
+                    page.elements.forEach(function (element) {
+                        components.push(_this.createComponentFromSurveyJS(element));
+                    });
+                }
+            });
+        }
+        if (!components.length && schema.elements && Array.isArray(schema.elements)) {
+            schema.elements.forEach(function (element) {
+                components.push(_this.createComponentFromSurveyJS(element));
+            });
+        }
+        return components;
+    };
+    UniversalJsonParser.prototype.createComponentFromSurveyJS = function (element) {
+        var type = this.mapSurveyJSType(element.type || 'text');
+        var validation = {};
+        // Only add required if explicitly true
+        if (element.isRequired === true) {
+            validation.required = true;
+        }
+        if (element.validators && Array.isArray(element.validators)) {
+            element.validators.forEach(function (validator) {
+                if (validator.type === 'numeric') {
+                    if (validator.minValue !== undefined)
+                        validation.minValue = validator.minValue;
+                    if (validator.maxValue !== undefined)
+                        validation.maxValue = validator.maxValue;
+                }
+                if (validator.type === 'text') {
+                    if (validator.minLength !== undefined)
+                        validation.minLength = validator.minLength;
+                    if (validator.maxLength !== undefined)
+                        validation.maxLength = validator.maxLength;
+                }
+            });
+        }
+        var component = __assign({ id: this.generateComponentId(type), type: type, label: element.title || element.label || this.humanizeFieldName(element.name), defaultValue: element.defaultValue, expressionValue: element.expressionValue }, Object.keys(validation).length > 0 ? validation : undefined);
+        if (type === 'dropdown' || type === 'multiselect' || type === 'radio' || type === 'splitButton') {
+            if (element.choices && Array.isArray(element.choices)) {
+                component.options = element.choices;
+            }
+        }
+        return component;
+    };
+    UniversalJsonParser.prototype.mapSurveyJSType = function (surveyType) {
+        var typeMap = {
+            text: 'textbox',
+            email: 'email',
+            number: 'number',
+            checkbox: 'checkbox',
+            radiogroup: 'radio',
+            dropdown: 'dropdown',
+            tagbox: 'multiselect',
+            multiselect: 'multiselect',
+            rating: 'number',
+            comment: 'textarea',
+            date: 'date'
+        };
+        return typeMap[surveyType] || 'textbox';
+    };
+    UniversalJsonParser.prototype.parseOpenAPI = function (schema) {
+        var components = [];
+        if (!schema.properties || typeof schema.properties !== 'object')
+            return components;
+        var openAPIKeys = Object.keys(schema.properties);
+        var requiredArr = schema.required || [];
+        for (var _i = 0, openAPIKeys_1 = openAPIKeys; _i < openAPIKeys_1.length; _i++) {
+            var key = openAPIKeys_1[_i];
+            var propDef = schema.properties[key];
+            var typeInfo = this.mapJsonSchemaType(propDef);
+            var isRequired = requiredArr.indexOf(key) !== -1;
+            components.push(this.createComponent(key, propDef, typeInfo, { required: isRequired }));
+        }
+        return components;
+    };
+    UniversalJsonParser.prototype.parseDataInference = function (data) {
+        var components = [];
+        var dataKeys = Object.keys(data);
+        for (var _i = 0, dataKeys_1 = dataKeys; _i < dataKeys_1.length; _i++) {
+            var key = dataKeys_1[_i];
+            var value = data[key];
+            var typeInference = this.inferComponentType(key, value);
+            var component = {
+                id: this.generateComponentId(typeInference.type),
+                type: typeInference.type,
+                label: this.humanizeFieldName(key),
+                defaultValue: value,
+                expressionValue: undefined
+            };
+            if (typeInference.textboxType) {
+                component.textboxType = typeInference.textboxType;
+                // Add default regex patterns for email and url
+                if (typeInference.textboxType === 'email') {
+                    component.regex = VALIDATION_REGEX['EMAIL'];
+                }
+                else if (typeInference.textboxType === 'url') {
+                    component.regex = VALIDATION_REGEX['URL'];
+                }
+            }
+            if (typeInference.type === 'date' && component.defaultValue !== undefined && component.defaultValue !== null) {
+                var formatted = this.formatDateTimeValue(component.defaultValue);
+                if (formatted)
+                    component.defaultValue = formatted;
+            }
+            if (Array.isArray(value) && value.length > 0) {
+                component.options = value;
+            }
+            components.push(component);
+        }
+        return components;
+    };
+    UniversalJsonParser.prototype.createComponent = function (fieldName, propDef, typeInfo, context) {
+        var validation = {};
+        // Only add required if explicitly true
+        var isRequired = propDef.required !== undefined ? propDef.required : context.required;
+        if (isRequired === true) {
+            validation.required = true;
+        }
+        if (propDef.minLength)
+            validation.minLength = propDef.minLength;
+        if (propDef.maxLength)
+            validation.maxLength = propDef.maxLength;
+        if (propDef.minDate)
+            validation.minDate = propDef.minDate;
+        if (propDef.maxDate)
+            validation.maxDate = propDef.maxDate;
+        if (propDef.minTime)
+            validation.minTime = propDef.minTime;
+        if (propDef.minValue)
+            validation.minValue = propDef.minValue;
+        if (propDef.maxValue)
+            validation.maxValue = propDef.maxValue;
+        if (propDef.pattern) {
+            validation.pattern = propDef.pattern;
+        }
+        var rawId = propDef.id || this.generateComponentId(typeInfo.type);
+        var safeGeneratedId = sanitizeId(rawId, this.generateComponentId(typeInfo.type));
+        var component = __assign({ id: safeGeneratedId, name: propDef.name, type: typeInfo.type, label: propDef.title || propDef.label || this.humanizeFieldName(fieldName), defaultValue: propDef.default || propDef.defaultValue || undefined, expressionValue: propDef.expressionValue || undefined, content: propDef.content, buttonType: propDef.buttonType, textboxType: propDef.textboxType }, Object.keys(validation).length > 0 ? validation : undefined);
+        if (typeInfo.textboxType) {
+            component.textboxType = typeInfo.textboxType;
+            // Add default regex patterns for email and url
+            if (typeInfo.textboxType === 'email') {
+                if (!validation.pattern) {
+                    validation.regex = '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$'; // Standard email regex
+                    validation.validationMessage = 'Please enter a valid email address';
+                }
+            }
+            else if (typeInfo.textboxType === 'url') {
+                if (!validation.pattern) {
+                    validation.regex = '^(https?:\\/\\/)?(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)$';
+                    validation.validationMessage = 'Please enter a valid URL';
+                }
+            }
+        }
+        if (typeInfo.type === 'date' && component.defaultValue !== undefined && component.defaultValue !== null) {
+            var formatted = this.formatDateTimeValue(component.defaultValue);
+            if (formatted)
+                component.defaultValue = formatted;
+        }
+        if ((typeInfo.type === 'splitButton' || typeInfo.type === 'dropdown' || typeInfo.type === 'multiselect' || typeInfo.type === 'radio') && (propDef.enum || propDef.options)) {
+            component.options = propDef.enum || propDef.options;
+        }
+        return component;
+    };
+    UniversalJsonParser.prototype.parseDateFromValue = function (value) {
+        if (value == null)
+            return null;
+        // numeric timestamps
+        if (typeof value === 'number') {
+            // assume seconds if small
+            if (value < 1e12)
+                return new Date(value * 1000);
+            return new Date(value);
+        }
+        if (typeof value === 'string') {
+            var s = value.trim();
+            // Try ISO / RFC parse
+            var dIso = new Date(s);
+            if (!isNaN(dIso.getTime()))
+                return dIso;
+            // yyyy-mm-dd[ T hh:mm(:ss)]
+            // eslint-disable-next-line security/detect-unsafe-regex
+            var m = s.match(/^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2}))?)?/);
+            if (m)
+                return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4] || 0), Number(m[5] || 0), Number(m[6] || 0));
+            // mm/dd/yyyy or m/d/yyyy
+            // eslint-disable-next-line security/detect-unsafe-regex
+            var m2 = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})(?:[ T](\d{1,2}):(\d{2})(?:[:](\d{2}))?)?/);
+            if (m2)
+                return new Date(Number(m2[3]), Number(m2[1]) - 1, Number(m2[2]), Number(m2[4] || 0), Number(m2[5] || 0), Number(m2[6] || 0));
+        }
+        return null;
+    };
+    UniversalJsonParser.prototype.formatDate = function (d) {
+        var monthNum = d.getMonth() + 1;
+        var dayNum = d.getDate();
+        var mm = monthNum < 10 ? '0' + monthNum : String(monthNum);
+        var dd = dayNum < 10 ? '0' + dayNum : String(dayNum);
+        var yyyy = d.getFullYear();
+        return mm + "/" + dd + "/" + yyyy;
+    };
+    // private formatTime(d: Date): string {
+    //   let hours = d.getHours();
+    //   const minutes = d.getMinutes().toString().padStart(2, '0');
+    //   const ampm = hours >= 12 ? 'PM' : 'AM';
+    //   hours = hours % 12;
+    //   if (hours === 0) hours = 12;
+    //   return `${hours.toString().padStart(2, '0')}:${minutes} ${ampm}`;
+    // }
+    UniversalJsonParser.prototype.formatDateTimeValue = function (value) {
+        var d = this.parseDateFromValue(value);
+        if (!d)
+            return undefined;
+        var datePart = this.formatDate(d);
+        var hasTime = d.getHours() !== 0 || d.getMinutes() !== 0 || /\dT\d{2}:\d{2}/.test(String(value));
+        if (hasTime)
+            return "" + datePart;
+        return datePart;
+    };
+    UniversalJsonParser.prototype.mapJsonSchemaType = function (propDef) {
+        var schemaType = propDef.type;
+        if (schemaType === 'string') {
+            var fmt = (propDef.format || '').toString().toLowerCase();
+            var text = ((propDef.title || propDef.label || '') + ' ' + (propDef.description || '')).toLowerCase();
+            if (/email|mail|e-?mail/.test(fmt) || /email|mail|e-?mail/.test(text))
+                return { type: 'textbox', textboxType: 'email' };
+            if (/uri|url|link|website/.test(fmt) || /uri|url|link|website/.test(text))
+                return { type: 'textbox', textboxType: 'url' };
+            if (/phone|tel|mobile|cell|msisdn/.test(fmt) || /phone|tel|mobile|cell|msisdn/.test(text))
+                return { type: 'textbox', textboxType: 'number' };
+            if (/password|pwd|pass|security|secret|key/.test(fmt) || /password|pwd|pass|security|secret|key/.test(text))
+                return { type: 'textbox', textboxType: 'password' };
+            if (fmt === 'date' || fmt === 'date-time' || /date|birthday|dob/.test(text))
+                return { type: 'date' };
+            if (propDef.enum)
+                return { type: 'dropdown' };
+            if (propDef.options)
+                return { type: 'dropdown' };
+            return { type: this.config.defaultTextType };
+        }
+        if (schemaType === 'number' || schemaType === 'integer')
+            return { type: 'number' };
+        if (schemaType === 'boolean')
+            return { type: 'checkbox' };
+        if (schemaType === 'array')
+            return { type: 'multiselect' };
+        // Presentation / custom widget types
+        if (schemaType === 'message')
+            return { type: 'message' };
+        if (schemaType === 'button')
+            return { type: 'button' };
+        if (schemaType === 'signature' || schemaType === 'sign')
+            return { type: 'signature' };
+        if (schemaType === 'image' || schemaType === 'imageEditor')
+            return { type: 'imageEditor' };
+        if (schemaType === 'file' || schemaType === 'fileUpload')
+            return { type: 'fileUpload' };
+        if (schemaType === 'color' || schemaType === 'colorPicker')
+            return { type: 'colorPicker' };
+        if (schemaType === 'splitButton')
+            return { type: 'splitButton' };
+        return { type: this.config.defaultTextType };
+    };
+    UniversalJsonParser.prototype.generateComponentId = function (type) {
+        if (!this.config.generateIds)
+            return '';
+        var timestamp = Date.now();
+        var random = Math.floor(Math.random() * 1000);
+        return type + "_" + timestamp + "_" + random;
+    };
+    UniversalJsonParser.prototype.humanizeFieldName = function (fieldName) {
+        var result = fieldName.replace(/_/g, ' ');
+        result = result.replace(/([a-z])([A-Z])/g, '$1 $2');
+        return result;
+    };
+    return UniversalJsonParser;
+}());
+export { UniversalJsonParser };
+/**
+ * @private
+ */
+export var validateJSON = function (jsonString) {
+    try {
+        JSON.parse(jsonString);
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: ["Invalid JSON syntax: " + error.message]
+        };
+    }
+};
+/**
+ * @private
+ */
+export var validateFormSchema = function (schema) {
+    var errors = [];
+    var warnings = [];
+    if (!schema.components) {
+        errors.push('Missing required property: components');
+    }
+    else if (!Array.isArray(schema.components)) {
+        errors.push('Property "components" must be an array');
+    }
+    // Validate component structure
+    if (Array.isArray(schema.components)) {
+        var componentIds_1 = new Set();
+        var validateComponent_1 = function (comp, path) {
+            if (path === void 0) { path = 'root'; }
+            if (!comp.id) {
+                errors.push("Component at " + path + " is missing \"id\" property");
+            }
+            else {
+                if (componentIds_1.has(comp.id)) {
+                    errors.push("Duplicate component ID found: " + comp.id);
+                }
+                componentIds_1.add(comp.id);
+            }
+            if (!comp.type) {
+                errors.push("Component \"" + (comp.id || 'unknown') + "\" is missing \"type\" property");
+            }
+            if (comp.children && Array.isArray(comp.children)) {
+                comp.children.forEach(function (child, index) {
+                    validateComponent_1(child, path + ".children[" + index + "]");
+                });
+            }
+            if (comp.tabItems && Array.isArray(comp.tabItems)) {
+                comp.tabItems.forEach(function (tab, tabIndex) {
+                    if (tab.content && Array.isArray(tab.content)) {
+                        tab.content.forEach(function (child, index) {
+                            validateComponent_1(child, path + ".tabItems[" + tabIndex + "].content[" + index + "]");
+                        });
+                    }
+                });
+            }
+            if (comp.tableCells && Array.isArray(comp.tableCells)) {
+                comp.tableCells.forEach(function (row, rowIndex) {
+                    if (Array.isArray(row)) {
+                        row.forEach(function (cell, colIndex) {
+                            if (Array.isArray(cell)) {
+                                cell.forEach(function (child, index) {
+                                    validateComponent_1(child, path + ".tableCells[" + rowIndex + "][" + colIndex + "][" + index + "]");
+                                });
+                            }
+                        });
+                    }
+                });
+            }
+        };
+        schema.components.forEach(function (comp, index) {
+            validateComponent_1(comp, "components[" + index + "]");
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors: errors.length > 0 ? errors : undefined,
+        warnings: warnings.length > 0 ? warnings : undefined
+    };
+};
+/**
+ * @private
+ */
+export var sanitizeFormSchema = function (schema) {
+    var sanitized = {
+        version: schema.version || "0.1.0",
+        components: schema.components || []
+    };
+    var sanitizeComponent = function (comp) {
+        var sanitizedComp = __assign({}, comp, { _configured: true });
+        if (comp.children && Array.isArray(comp.children)) {
+            sanitizedComp.children = comp.children.map(sanitizeComponent);
+        }
+        if (comp.tabItems && Array.isArray(comp.tabItems)) {
+            sanitizedComp.tabItems = comp.tabItems.map(function (tab) { return (__assign({}, tab, { content: tab.content ? tab.content.map(sanitizeComponent) : [] })); });
+        }
+        if (comp.tableCells && Array.isArray(comp.tableCells)) {
+            sanitizedComp.tableCells = comp.tableCells.map(function (row) {
+                return row.map(function (cell) {
+                    return Array.isArray(cell) ? cell.map(sanitizeComponent) : [];
+                });
+            });
+        }
+        return sanitizedComp;
+    };
+    sanitized.components = sanitized.components.map(sanitizeComponent);
+    return sanitized;
+};
+/**
+ * @private
+ */
+export var exportFormSchema = function (schema) {
+    return JSON.stringify(schema, null, 2);
+};