@bolttech/form-engine-core 0.0.1-beta.25 → 0.0.1-beta.27

package/index.esm.js

@@ -1933,7 +1933,7 @@ const conditions = (value, validations) => {
  * Validates if a date string matches a specific date format.
  * The function accepts strings with '/' or '-' separators and removes them before validating the format.
  *
- * @param {string} string - The date string to be validated. It can contain '/' or '-' separators.
+ * @param {string} value - The date string to be validated. It can contain '/' or '-' separators.
  * @param {string} format - The expected date format. It can be one of the following:
  *                          'DDMMYYYY', 'YYYYMMDD', 'YYYYDDMM', 'MMDDYYYY',
  *                          'DMYYYY', 'YYYYMD', 'YYYYDM', 'MDYYYY'.
@@ -2096,18 +2096,17 @@ const date = (value, validations) => {
   }
   const originValue = validations.date.origin.value || value;
   const mappedValue = dateRearrangeMapper[(_e = validations.date) === null || _e === void 0 ? void 0 : _e.origin.format](originValue).toString();
-  if (invalidStringDate(mappedValue, (_f = validations.date) === null || _f === void 0 ? void 0 : _f.origin.format)) return false;
   let originDate = new Date(mappedValue);
   let targetDate = new Date();
   let target = new Date();
-  if ((_h = (_g = validations.date) === null || _g === void 0 ? void 0 : _g.target) === null || _h === void 0 ? void 0 : _h.format) {
-    target = new Date(dateRearrangeMapper[(_k = (_j = validations.date) === null || _j === void 0 ? void 0 : _j.target) === null || _k === void 0 ? void 0 : _k.format](validations.date.target.value).toString());
+  if ((_g = (_f = validations.date) === null || _f === void 0 ? void 0 : _f.target) === null || _g === void 0 ? void 0 : _g.format) {
+    target = new Date(dateRearrangeMapper[(_j = (_h = validations.date) === null || _h === void 0 ? void 0 : _h.target) === null || _j === void 0 ? void 0 : _j.format](validations.date.target.value).toString());
     targetDate = target;
   }
   if (validations.date.origin.intervals) {
     targetDate = getIntervalsDate(originDate, validations.date.origin.intervals);
     const date = new Date();
-    if (((_l = validations.date.target) === null || _l === void 0 ? void 0 : _l.value) && target) {
+    if (((_k = validations.date.target) === null || _k === void 0 ? void 0 : _k.value) && target) {
       date.setDate(target.getDate());
       date.setMonth(target.getMonth());
     }
@@ -2116,6 +2115,9 @@ const date = (value, validations) => {
   if (validations.date.onlyValidDate && (!(targetDate instanceof Date && isFinite(targetDate)) || !(targetDate instanceof Date && isFinite(originDate)) || originValue.length < 8)) {
     return true;
   }
+  if (invalidStringDate(mappedValue, (_l = validations.date) === null || _l === void 0 ? void 0 : _l.origin.format)) {
+    return false;
+  }
   const originTimestamp = originDate.getTime();
   const targetTimestamp = targetDate.getTime();
   const operationsMapper = {
@@ -2126,7 +2128,7 @@ const date = (value, validations) => {
     '===': originTimestamp === targetTimestamp,
     '!==': originTimestamp !== targetTimestamp
   };
-  return !operationsMapper[(_m = validations.date) === null || _m === void 0 ? void 0 : _m.operator];
+  return operationsMapper[(_m = validations.date) === null || _m === void 0 ? void 0 : _m.operator];
 };
 /**
  * @function validDate
@@ -2155,11 +2157,17 @@ const validDate = (value, validations) => {
   const month = parseInt(dateParts[0], 10) - 1; // Month is zero-based
   const day = parseInt(dateParts[1], 10);
   const date = new Date(year, month, day);
-  /* This line is here because we need to guarantee that the field will not be valid while typing,
-  * that is, imagine the scenario where the user wants to type 1995, when typing 19 or 199,
-  * the function returns valid, as there is a year 19 or 199.
-  */
-  if (date.getFullYear() < 1900) {
+  /*
+   * Motivation: due to the scenario in which a date field may be 'typeable',
+   * we need to ensure that dates less than a thousand and such years are valid.
+   * E.g.: user types 13-07-199 (without this condition, it becomes a valid date, as 199 is a valid year)
+   *
+   * Ps: 150 is a valid value for now, as we still cannot live more than that, from the
+   * the moment we start to live longer, we can rethink this.
+   */
+  const today = new Date();
+  today.setFullYear(today.getFullYear() - 150);
+  if (date.getFullYear() < today.getFullYear()) {
     return true;
   }
   // Check if the date is valid
@@ -3321,6 +3329,21 @@ class FormCore {
       }
     });
   }
+  /**
+   * @internal
+   * Update field visibility accordingly.
+   *
+   * @param {string} field - Field name to be updated.
+   * @param {boolean} hasError - Condition to be used as visibility.
+   * @param {boolean|undefined} showOnlyIfTrue - Flag to be considered when update field visibility. If it's true, then considered error, if it's false, always considered the opposite.
+   */
+  setFieldVisibility(field, hasError, showOnlyIfTrue) {
+    if (!this.fields.has(field)) {
+      console.warn(`failed to update visibility onto field ${field}`);
+    } else {
+      this.fields.get(field).visibility = showOnlyIfTrue ? hasError : !hasError;
+    }
+  }
   /**
    * Validates visibility conditions for a given event and updates field visibility accordingly.
    *
@@ -3334,17 +3357,19 @@ class FormCore {
   }) {
     const field = this.fields.get(key);
     const structVisibility = field === null || field === void 0 ? void 0 : field.visibilityConditions;
-    if (!structVisibility || !(structVisibility === null || structVisibility === void 0 ? void 0 : structVisibility.some(config => config.events.includes(event)))) return;
+    if (!structVisibility || !(structVisibility === null || structVisibility === void 0 ? void 0 : structVisibility.some(config => config.events.includes(event)))) {
+      return;
+    }
     structVisibility.forEach(structElement => {
       if (!structElement.events.includes(event)) return;
       Object.keys(structElement.validations).forEach(validationKey => {
         const error = handleValidation(field.value, structElement.validations, validations, validationKey);
         if (Array.isArray(structElement.fields)) {
           structElement.fields.forEach(fieldKey => {
-            if (!this.fields.has(fieldKey)) console.warn(`failed to update visibility onto field ${fieldKey}`);else this.fields.get(fieldKey).visibility = structElement.showOnlyIfTrue ? error : !error;
+            this.setFieldVisibility(fieldKey, error, !!(field.value && structElement.showOnlyIfTrue));
           });
         } else if (structElement.fields) {
-          if (!this.fields.has(structElement.fields)) console.warn(`failed to update visibility onto field ${structElement.fields}`);else this.fields.get(structElement.fields).visibility = structElement.showOnlyIfTrue ? error : !error;
+          this.setFieldVisibility(structElement.fields, error, !!(field.value && structElement.showOnlyIfTrue));
         }
       });
     });
@@ -3533,7 +3558,7 @@ class FormCore {
         set(values, val.nameToSubmit || key, val.value);
       }
     });
-    console.log(values);
+    console.table(values);
   }
   /**
    * Gets the current values of all form fields.
@@ -3741,7 +3766,7 @@ class FormGroup {
    * Prints the form group instance to the console.
    */
   printFormGroupInstance() {
-    console.log(this.forms);
+    console.table(this.forms);
   }
   /**
    * Prototype submit function to multiple forms

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolttech/form-engine-core",
-  "version": "0.0.1-beta.25",
+  "version": "0.0.1-beta.27",
   "module": "./index.esm.js",
   "type": "module",
   "main": "./index.esm.js",

package/src/managers/form.d.ts

@@ -139,6 +139,15 @@ declare class FormCore {
      * @private
      */
     private static checkIndexes;
+    /**
+     * @internal
+     * Update field visibility accordingly.
+     *
+     * @param {string} field - Field name to be updated.
+     * @param {boolean} hasError - Condition to be used as visibility.
+     * @param {boolean|undefined} showOnlyIfTrue - Flag to be considered when update field visibility. If it's true, then considered error, if it's false, always considered the opposite.
+     */
+    private setFieldVisibility;
     /**
      * Validates visibility conditions for a given event and updates field visibility accordingly.
      *