@bolttech/form-engine-core 0.0.1-beta.19 → 0.0.1-beta.20

package/index.esm.js

@@ -1929,41 +1929,44 @@ const conditions = (value, validations) => {
 };
 
 /**
- * Validates if a date value falls between two specified dates.
+ * @internal
+ * 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} value - The date value to be validated in string format.
- * @param {TValidationMethods} validations - The validation methods object containing the betweenDates validation rules.
- * @returns {boolean} - Returns `true` if the date value fails the betweenDates validation, otherwise `false`.
+ * @param {string} string - 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'.
+ * @returns {boolean} - Returns `false` if the date string matches the specified format, otherwise `true`.
  *
  * @example
- * ```typescript
- * const validations = {
- *   betweenDates: [
- *     { origin: { value: '2023-01-01', format: 'yyyy-MM-dd' }, operator: '>=' },
- *     { origin: { value: '2023-12-31', format: 'yyyy-MM-dd' }, operator: '<=' }
- *   ]
- * };
+ * // Returns false
+ * invalidStringDate("25/07/1997", "DDMMYYYY");
  *
- * const result1 = betweenDates('2023-06-01', validations);
- * console.log(result1); // false (date is within the range)
+ * @example
+ * // Returns false
+ * invalidStringDate("1997-07-25", "YYYYMMDD");
  *
- * const result2 = betweenDates('2024-01-01', validations);
- * console.log(result2); // true (date is outside the range)
- * ```
+ * @example
+ * // Returns true, as the format does not match
+ * invalidStringDate("1997/25/07", "MMDDYYYY");
  */
-const betweenDates = (value, validations) => {
-  var _a;
-  let fail = false;
-  if (((_a = validations.betweenDates) === null || _a === void 0 ? void 0 : _a.length) != 2) return false;
-  for (const validation of validations.betweenDates) {
-    if (date(value, {
-      date: validation
-    })) {
-      fail = true;
-      break;
-    }
+const invalidStringDate = (value, format) => {
+  if (!value.includes('/') && !value.includes('-') || !format) {
+    return true;
   }
-  return fail;
+  const valueParts = value.replace(/[-/]/g, '');
+  const dateMapper = {
+    DDMMYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    YYYYMMDD: /^(\d{4})(\d{2})(\d{2})$/,
+    YYYYDDMM: /^(\d{4})(\d{2})(\d{2})$/,
+    MMDDYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    DMYYYY: /^(\d{1,2})(\d{1,2})(\d{4})$/,
+    YYYYMD: /^(\d{4})(\d{1,2})(\d{1,2})$/,
+    YYYYDM: /^(\d{4})(\d{1,2})(\d{1,2})$/,
+    MDYYYY: /^(\d{1,2})(\d{1,2})(\d{4})$/
+  };
+  return !dateMapper[format].test(valueParts);
 };
 /**
  * @internal
@@ -2016,6 +2019,44 @@ const dateRearrangeMapper = {
   MMDDYYYY: value => value,
   timestamp: value => new Date(value).toString()
 };
+/**
+ * @function betweenDates
+ * Validates if a date value falls between two specified dates.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the betweenDates validation rules.
+ * @returns {boolean} - Returns `true` if the date value fails the betweenDates validation, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = {
+ *   betweenDates: [
+ *     { origin: { value: '2023-01-01', format: 'yyyy-MM-dd' }, operator: '>=' },
+ *     { origin: { value: '2023-12-31', format: 'yyyy-MM-dd' }, operator: '<=' }
+ *   ]
+ * };
+ *
+ * const result1 = betweenDates('2023-06-01', validations);
+ * console.log(result1); // false (date is within the range)
+ *
+ * const result2 = betweenDates('2024-01-01', validations);
+ * console.log(result2); // true (date is outside the range)
+ * ```
+ */
+const betweenDates = (value, validations) => {
+  var _a;
+  let fail = false;
+  if (((_a = validations.betweenDates) === null || _a === void 0 ? void 0 : _a.length) != 2) return false;
+  for (const validation of validations.betweenDates) {
+    if (date(value, {
+      date: validation
+    })) {
+      fail = true;
+      break;
+    }
+  }
+  return fail;
+};
 /**
  * @function date
  * Validates a date value based on various date conditions and intervals.
@@ -2049,22 +2090,24 @@ const dateRearrangeMapper = {
  * ```
  */
 const date = (value, validations) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
   if (!((_b = (_a = validations.date) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.value) && !((_d = (_c = validations.date) === null || _c === void 0 ? void 0 : _c.origin) === null || _d === void 0 ? void 0 : _d.intervals)) {
     return false;
   }
   const originValue = validations.date.origin.value || value;
-  let originDate = new Date(dateRearrangeMapper[(_e = validations.date) === null || _e === void 0 ? void 0 : _e.origin.format](originValue).toString());
+  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 ((_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());
+  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());
     targetDate = target;
   }
   if (validations.date.origin.intervals) {
     targetDate = getIntervalsDate(originDate, validations.date.origin.intervals);
     const date = new Date();
-    if (((_k = validations.date.target) === null || _k === void 0 ? void 0 : _k.value) && target) {
+    if (((_l = validations.date.target) === null || _l === void 0 ? void 0 : _l.value) && target) {
       date.setDate(target.getDate());
       date.setMonth(target.getMonth());
     }
@@ -2083,7 +2126,7 @@ const date = (value, validations) => {
     '===': originTimestamp === targetTimestamp,
     '!==': originTimestamp !== targetTimestamp
   };
-  return operationsMapper[(_l = validations.date) === null || _l === void 0 ? void 0 : _l.operator];
+  return operationsMapper[(_m = validations.date) === null || _m === void 0 ? void 0 : _m.operator];
 };
 /**
  * @function validDate
@@ -3291,10 +3334,10 @@ class FormCore {
         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 = !error;
+            if (!this.fields.has(fieldKey)) console.warn(`failed to update visibility onto field ${fieldKey}`);else this.fields.get(fieldKey).visibility = structElement.showOnlyIfTrue ? error : !error;
           });
         } 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 = !error;
+          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;
         }
       });
     });

package/package.json

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

package/src/types/schema.d.ts

@@ -618,18 +618,23 @@ type TMasks = {
  * @type TVisibility
  * Represents the visibility conditions for form fields based on validations.
  *
+ * @property {boolean} showOnlyIfTrue - Enables visibility of fields only if any or all validation conditions are positive.
  * @property {TSchemaValidation} validations - The validation methods to determine visibility.
  * @property {string[] | string} fields - The fields to be shown or hidden based on validations.
+ * @property {string[]} events - Events where visibility will occur.
  *
  * @example
  * ```typescript
  * const visibility: TVisibility = {
+ *   showOnlyIfTrue: false,
  *   validations: { required: true },
- *   fields: ['fieldName']
+ *   fields: ['fieldName'],
+ *   events: ['ON_FIELD_CHANGE']
  * };
  * ```
  */
 type TVisibility = {
+    showOnlyIfTrue?: boolean;
     validations: TSchemaValidation;
     fields: string[] | string;
     events: Partial<TEvents>[];

package/src/validations/date.d.ts

@@ -1,5 +1,6 @@
 import { TValidationMethods } from '../types/schema';
 /**
+ * @function betweenDates
  * Validates if a date value falls between two specified dates.
  *
  * @param {string} value - The date value to be validated in string format.