mftsccs-browser 1.1.35-beta → 1.1.36-beta

package/dist/main.bundle.js

@@ -7827,8 +7827,8 @@ class LocalSyncData {
                 else {
                     console.warn('Syncing this way has been Depreceted in service worker.');
                     console.info('Only if serive worker is not running');
-                    conceptsArray = this.conceptsSyncArray.slice();
-                    connectionsArray = this.connectionSyncArray.slice();
+                    conceptsArray = this.conceptsSyncArray.slice() || [];
+                    connectionsArray = this.connectionSyncArray.slice() || [];
                     // return []
                 }
                 this.connectionSyncArray = [];
@@ -17864,6 +17864,7 @@ __webpack_require__.r(__webpack_exports__);
  * @returns - An object containing the field's value and constraints (type, maxLength, etc.).
  */
 const createFormFieldData = (fieldName) => {
+    var _a;
     const inputElements = document.getElementsByName(fieldName);
     const inputElement = inputElements[0];
     // Check if the element exists
@@ -17871,13 +17872,16 @@ const createFormFieldData = (fieldName) => {
         console.warn(`Element with NAME "${fieldName}" not found.`);
         return {
             value: null,
+            fieldType: null,
             dataType: null,
+            pattern: null,
             conceptType: null,
             maxLength: null,
             minLength: null,
             minValue: null,
             maxValue: null,
             accept: null,
+            file: null,
             required: false,
             isUnique: true
         };
@@ -17888,13 +17892,16 @@ const createFormFieldData = (fieldName) => {
     // Proceed to gather data if the element exists
     const data = {
         value: inputElement.value,
+        fieldType: inputElement.type,
         dataType: inputElement.getAttribute('data-type'),
+        pattern: inputElement.getAttribute('data-pattern'),
         conceptType: inputElement.getAttribute('concept-type'),
         maxLength: inputElement.getAttribute('data-maxlength') ? parseInt(inputElement.getAttribute('data-maxlength')) : null,
         minLength: inputElement.getAttribute('data-minlength') ? parseInt(inputElement.getAttribute('data-minlength')) : null,
         minValue: inputElement.getAttribute('data-min') ? parseInt(inputElement.getAttribute('data-min')) : null,
         maxValue: inputElement.getAttribute('data-max') ? parseInt(inputElement.getAttribute('data-max')) : null,
         accept: inputElement.getAttribute('accept') || null,
+        file: inputElement.type === 'file' ? ((_a = inputElement.files) === null || _a === void 0 ? void 0 : _a[0]) || null : null,
         required: required,
         isUnique: isUnique
     };
@@ -17968,55 +17975,63 @@ class Validator {
      * @param file - The file input (if any), used for file type validation.
      * @param required - Whether the field is required.
      * @param isUnique - Whether the field value should be unique.
-     * @returns An array of error messages if validation fails, or an empty array if the field is valid.
+     * @returns An object of error messages if validation fails
      */
-    validateField(fieldName_1, dataType_1, value_1, conceptType_1, maxLength_1, minLength_1, minValue_1, maxValue_1, accept_1, file_1, required_1) {
-        return __awaiter(this, arguments, void 0, function* (fieldName, dataType, value, conceptType, maxLength, minLength, minValue, maxValue, accept, file, required, isUnique = false // Optional parameter for uniqueness check
-        ) {
+    validateField(fieldName_1, fieldType_1, dataType_1, value_1, pattern_1, conceptType_1, maxLength_1, minLength_1, minValue_1, maxValue_1, accept_1, file_1, required_1) {
+        return __awaiter(this, arguments, void 0, function* (fieldName, fieldType, dataType, value, pattern, conceptType, maxLength, minLength, minValue, maxValue, accept, file, required, isUnique = false) {
             var _a;
-            const errors = [];
+            const errors = {};
             // 1. Validate required field (must not be empty)
             if (required && (value === null || value === '')) {
-                errors.push(`${fieldName} is required`);
+                errors['required'] = `this is required field`;
             }
             // 2. Validate using regex pattern for the data type
             if (dataType && value) {
-                const pattern = _constant__WEBPACK_IMPORTED_MODULE_1__.DATA_TYPES_RULES[dataType];
+                console.log(`Comment on Data Type ${dataType} and Value ${value}`);
+                let pattern = _constant__WEBPACK_IMPORTED_MODULE_1__.DATA_TYPES_RULES[dataType];
+                console.log("Find Pattern : ", pattern);
                 if (pattern && value !== '' && !pattern.test(value)) {
-                    errors.push(`Invalid format for ${dataType} in ${fieldName}`);
+                    errors['dataType'] = `Invalid format for ${dataType} in ${fieldName}`;
                 }
             }
-            // 3. Validate maxLength
+            // 3. Check if the provided pattern match with the value or not
+            if (pattern && value) {
+                const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+                if (value !== '' && !regex.test(value)) {
+                    errors['pattern'] = `Pattern doesn't match with data`;
+                }
+            }
+            // 4. Validate maxLength
             if (value && maxLength !== null && value.length > maxLength) {
-                errors.push(`${fieldName} exceeds the maximum length of ${maxLength}`);
+                errors['maxLength'] = `length exceeds the maximum length of ${maxLength}`;
             }
-            // 4. Validate minLength
+            // 5. Validate minLength
             if (value && minLength !== null && value.length < minLength) {
-                errors.push(`${fieldName} must be at least ${minLength} characters long`);
+                errors['minLength'] = `length must be at least ${minLength} characters long`;
             }
-            // 5. Validate minValue (only for numeric fields)
+            // 6. Validate minValue (only for numeric fields)
             if (minValue !== null && value && !isNaN(Number(value)) && Number(value) < minValue) {
-                errors.push(`${fieldName} must be greater than or equal to ${minValue}`);
+                errors['minValue'] = `value must be greater than or equal to ${minValue}`;
             }
-            // 6. Validate maxValue (only for numeric fields)
+            // 7. Validate maxValue (only for numeric fields)
             if (maxValue !== null && value && !isNaN(Number(value)) && Number(value) > maxValue) {
-                errors.push(`${fieldName} must be less than or equal to ${maxValue}`);
+                errors['maxValue'] = `value must be less than or equal to ${maxValue}`;
             }
-            // 7. File validation: Check if this is a file input
-            if (dataType === 'file' && file) {
-                if (accept) {
+            // 8. File validation: Check if this is a file input
+            if (file) {
+                if (fieldType && accept) {
                     const acceptedTypes = accept.split(',').map(type => type.trim().toLowerCase());
                     const fileExtension = (_a = file.name.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
                     if (fileExtension && !acceptedTypes.includes(fileExtension)) {
-                        errors.push(`${fieldName} must be a valid file type: ${acceptedTypes.join(', ')}`);
+                        errors['accept'] = `file must be a valid file type: ${acceptedTypes.join(', ')}`;
                     }
                 }
             }
-            // 8. Check if the field needs to be unique and perform uniqueness validation
+            // 9. Check if the field needs to be unique and perform uniqueness validation
             if (conceptType && isUnique && value) {
                 const isUniqueValue = yield this.checkUniqueness(conceptType, value);
                 if (!isUniqueValue) {
-                    errors.push(`${fieldName} is not unique`);
+                    errors['unique'] = `value is not unique`;
                 }
             }
             return errors;
@@ -18037,13 +18052,11 @@ class Validator {
             const validationErrors = {};
             // Iterate through the fields in the form data
             for (const fieldName in formData) {
-                const { value, dataType, conceptType, maxLength = null, minLength = null, minValue = null, maxValue = null, accept = null, file = null, required, isUnique } = formData[fieldName];
+                const { value, fieldType, dataType, pattern, conceptType, maxLength = null, minLength = null, minValue = null, maxValue = null, accept = null, file = null, required, isUnique } = formData[fieldName];
                 // Call the validateField function to validate each field
-                const fieldErrors = yield this.validateField(fieldName, dataType, value, conceptType, maxLength, minLength, minValue, maxValue, accept, file, required, isUnique);
-                // If there are errors, add them to the errors object
-                if (fieldErrors.length > 0) {
+                const fieldErrors = yield this.validateField(fieldName, fieldType, dataType, value, pattern, conceptType, maxLength, minLength, minValue, maxValue, accept, file, required, isUnique);
+                if (Object.keys(fieldErrors).length > 0)
                     validationErrors[fieldName] = fieldErrors;
-                }
             }
             return validationErrors;
         });