@wavemaker-ai/react-runtime 1.0.0-rc.647502 → 1.0.0-rc.647565

package/components/data/form/form-controller/validation-contrustor.js

@@ -1,207 +1,112 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createValidationRules = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
-var _lodashEs = require("lodash-es");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-// Helper function to resolve error message (string or function)
-var resolveErrorMessage = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(errorMessage, value, fieldName, form) {
-    var result;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (!(0, _lodashEs.isFunction)(errorMessage)) {
-            _context.next = 12;
-            break;
-          }
-          _context.prev = 1;
-          _context.next = 4;
-          return errorMessage({
-            value: value
-          }, form);
-        case 4:
-          result = _context.sent;
-          return _context.abrupt("return", result || "Validation failed");
-        case 8:
-          _context.prev = 8;
-          _context.t0 = _context["catch"](1);
-          console.warn("Error message function threw an error:", _context.t0);
-          return _context.abrupt("return", "Validation error occurred");
-        case 12:
-          return _context.abrupt("return", errorMessage);
-        case 13:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[1, 8]]);
-  }));
-  return function resolveErrorMessage(_x, _x2, _x3, _x4) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-// function to parse time string into minutes
-var parseTime = function parseTime(time) {
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import moment from "moment-timezone";
+import {
+  reduce,
+  isString,
+  isBoolean,
+  isNumber,
+  isRegExp,
+  isArray,
+  isDate,
+  isFunction
+} from "lodash-es";
+const resolveErrorMessage = async (errorMessage, value, fieldName, form) => {
+  if (isFunction(errorMessage)) {
+    try {
+      const result = await errorMessage({ value }, form);
+      return result || "Validation failed";
+    } catch (error) {
+      console.warn("Error message function threw an error:", error);
+      return "Validation error occurred";
+    }
+  }
+  return errorMessage;
+};
+const parseTime = (time) => {
   if (!time || typeof time !== "string") return null;
-  var timeFormats = ["HH:mm:ss", "HH:mm", "H:mm:ss", "H:mm", "hh:mm:ss a", "hh:mm a", "h:mm:ss a", "h:mm a"];
-  var parsedMoment = (0, _momentTimezone["default"])(time, timeFormats, true);
+  const timeFormats = [
+    "HH:mm:ss",
+    "HH:mm",
+    "H:mm:ss",
+    "H:mm",
+    "hh:mm:ss a",
+    "hh:mm a",
+    "h:mm:ss a",
+    "h:mm a"
+  ];
+  const parsedMoment = moment(time, timeFormats, true);
   if (parsedMoment.isValid()) {
     return parsedMoment.hours() * 60 + parsedMoment.minutes();
   }
   return null;
 };
-var validationHandlers = {
-  required: function required(config, rules, form, fieldName) {
+const validationHandlers = {
+  required: (config, rules, form, fieldName) => {
     if (config.validator) {
-      var isConditionalRequired = (0, _lodashEs.isFunction)(config.validator);
+      const isConditionalRequired = isFunction(config.validator);
       if (isConditionalRequired) {
-        rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-          required: function () {
-            var _required = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(value) {
-              var isRequired, field;
-              return _regenerator["default"].wrap(function _callee2$(_context2) {
-                while (1) switch (_context2.prev = _context2.next) {
-                  case 0:
-                    try {
-                      field = {
-                        value: value,
-                        formKey: fieldName
-                      }; // @ts-expect-error this is a valid function / method
-                      isRequired = config.validator(field, form);
-                    } catch (error) {
-                      console.warn("Error calling required validator function:", error);
-                      isRequired = false;
-                    }
-                    if (isRequired) {
-                      _context2.next = 3;
-                      break;
-                    }
-                    return _context2.abrupt("return", true);
-                  case 3:
-                    if (!(value != null && value !== "" && (typeof value !== "string" || value.trim() !== ""))) {
-                      _context2.next = 5;
-                      break;
-                    }
-                    return _context2.abrupt("return", true);
-                  case 5:
-                    _context2.next = 7;
-                    return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                  case 7:
-                    return _context2.abrupt("return", _context2.sent);
-                  case 8:
-                  case "end":
-                    return _context2.stop();
-                }
-              }, _callee2);
-            }));
-            function required(_x5) {
-              return _required.apply(this, arguments);
+        rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+          required: async (value) => {
+            let isRequired;
+            try {
+              const field = { value, formKey: fieldName };
+              isRequired = config.validator(field, form);
+            } catch (error) {
+              console.warn("Error calling required validator function:", error);
+              isRequired = false;
             }
-            return required;
-          }()
+            if (!isRequired) return true;
+            if (value != null && value !== "" && (typeof value !== "string" || value.trim() !== ""))
+              return true;
+            return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+          }
         });
-      } else if ((0, _lodashEs.isFunction)(config.errorMessage)) {
-        rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-          required: function () {
-            var _required2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(value) {
-              return _regenerator["default"].wrap(function _callee3$(_context3) {
-                while (1) switch (_context3.prev = _context3.next) {
-                  case 0:
-                    if (!(value != null && value !== "")) {
-                      _context3.next = 2;
-                      break;
-                    }
-                    return _context3.abrupt("return", true);
-                  case 2:
-                    _context3.next = 4;
-                    return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                  case 4:
-                    return _context3.abrupt("return", _context3.sent);
-                  case 5:
-                  case "end":
-                    return _context3.stop();
-                }
-              }, _callee3);
-            }));
-            function required(_x6) {
-              return _required2.apply(this, arguments);
-            }
-            return required;
-          }()
+      } else if (isFunction(config.errorMessage)) {
+        rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+          required: async (value) => {
+            if (value != null && value !== "") return true;
+            return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+          }
         });
       } else {
         rules.required = config.errorMessage;
       }
     }
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      noWhitespaces: function () {
-        var _noWhitespaces = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(value) {
-          return _regenerator["default"].wrap(function _callee4$(_context4) {
-            while (1) switch (_context4.prev = _context4.next) {
-              case 0:
-                if (!(typeof value === "string" && value.length > 0 && value.trim() === "")) {
-                  _context4.next = 4;
-                  break;
-                }
-                _context4.next = 3;
-                return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-              case 3:
-                return _context4.abrupt("return", _context4.sent);
-              case 4:
-                return _context4.abrupt("return", true);
-              case 5:
-              case "end":
-                return _context4.stop();
-            }
-          }, _callee4);
-        }));
-        function noWhitespaces(_x7) {
-          return _noWhitespaces.apply(this, arguments);
+    rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+      noWhitespaces: async (value) => {
+        if (typeof value === "string" && value.length > 0 && value.trim() === "") {
+          return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
         }
-        return noWhitespaces;
-      }()
+        return true;
+      }
     });
     return rules;
   },
-  maxchars: function maxchars(config, rules, form, fieldName) {
-    if ((0, _lodashEs.isFunction)(config.errorMessage)) {
-      rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-        maxLength: function () {
-          var _maxLength = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(value) {
-            return _regenerator["default"].wrap(function _callee5$(_context5) {
-              while (1) switch (_context5.prev = _context5.next) {
-                case 0:
-                  if (!(value == null || value.length <= config.validator)) {
-                    _context5.next = 2;
-                    break;
-                  }
-                  return _context5.abrupt("return", true);
-                case 2:
-                  _context5.next = 4;
-                  return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                case 4:
-                  return _context5.abrupt("return", _context5.sent);
-                case 5:
-                case "end":
-                  return _context5.stop();
-              }
-            }, _callee5);
-          }));
-          function maxLength(_x8) {
-            return _maxLength.apply(this, arguments);
-          }
-          return maxLength;
-        }()
+  maxchars: (config, rules, form, fieldName) => {
+    if (isFunction(config.errorMessage)) {
+      rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+        maxLength: async (value) => {
+          if (value == null || value.length <= config.validator) return true;
+          return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+        }
       });
     } else {
       rules.maxLength = {
@@ -211,35 +116,13 @@ var validationHandlers = {
     }
     return rules;
   },
-  minvalue: function minvalue(config, rules, form, fieldName) {
-    if ((0, _lodashEs.isFunction)(config.errorMessage)) {
-      rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-        minValue: function () {
-          var _minValue = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(value) {
-            return _regenerator["default"].wrap(function _callee6$(_context6) {
-              while (1) switch (_context6.prev = _context6.next) {
-                case 0:
-                  if (!(value == null || Number(value) >= config.validator)) {
-                    _context6.next = 2;
-                    break;
-                  }
-                  return _context6.abrupt("return", true);
-                case 2:
-                  _context6.next = 4;
-                  return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                case 4:
-                  return _context6.abrupt("return", _context6.sent);
-                case 5:
-                case "end":
-                  return _context6.stop();
-              }
-            }, _callee6);
-          }));
-          function minValue(_x9) {
-            return _minValue.apply(this, arguments);
-          }
-          return minValue;
-        }()
+  minvalue: (config, rules, form, fieldName) => {
+    if (isFunction(config.errorMessage)) {
+      rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+        minValue: async (value) => {
+          if (value == null || Number(value) >= config.validator) return true;
+          return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+        }
       });
     } else {
       rules.min = {
@@ -249,35 +132,13 @@ var validationHandlers = {
     }
     return rules;
   },
-  maxvalue: function maxvalue(config, rules, form, fieldName) {
-    if ((0, _lodashEs.isFunction)(config.errorMessage)) {
-      rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-        maxValue: function () {
-          var _maxValue = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7(value) {
-            return _regenerator["default"].wrap(function _callee7$(_context7) {
-              while (1) switch (_context7.prev = _context7.next) {
-                case 0:
-                  if (!(value == null || Number(value) <= config.validator)) {
-                    _context7.next = 2;
-                    break;
-                  }
-                  return _context7.abrupt("return", true);
-                case 2:
-                  _context7.next = 4;
-                  return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                case 4:
-                  return _context7.abrupt("return", _context7.sent);
-                case 5:
-                case "end":
-                  return _context7.stop();
-              }
-            }, _callee7);
-          }));
-          function maxValue(_x0) {
-            return _maxValue.apply(this, arguments);
-          }
-          return maxValue;
-        }()
+  maxvalue: (config, rules, form, fieldName) => {
+    if (isFunction(config.errorMessage)) {
+      rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+        maxValue: async (value) => {
+          if (value == null || Number(value) <= config.validator) return true;
+          return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+        }
       });
     } else {
       rules.max = {
@@ -287,42 +148,20 @@ var validationHandlers = {
     }
     return rules;
   },
-  regexp: function regexp(config, rules, form, fieldName) {
-    var pattern;
+  regexp: (config, rules, form, fieldName) => {
+    let pattern;
     try {
-      pattern = (0, _lodashEs.isString)(config.validator) ? new RegExp(config.validator.replace(/^\/|\/$/g, "")) : config.validator;
+      pattern = isString(config.validator) ? new RegExp(config.validator.replace(/^\/|\/$/g, "")) : config.validator;
     } catch (e) {
       console.warn("Invalid regexp string:", config.validator);
       return rules;
     }
-    if ((0, _lodashEs.isFunction)(config.errorMessage)) {
-      rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-        regexp: function () {
-          var _regexp = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(value) {
-            return _regenerator["default"].wrap(function _callee8$(_context8) {
-              while (1) switch (_context8.prev = _context8.next) {
-                case 0:
-                  if (!(value == null || pattern.test(value))) {
-                    _context8.next = 2;
-                    break;
-                  }
-                  return _context8.abrupt("return", true);
-                case 2:
-                  _context8.next = 4;
-                  return resolveErrorMessage(config.errorMessage, value, fieldName, form);
-                case 4:
-                  return _context8.abrupt("return", _context8.sent);
-                case 5:
-                case "end":
-                  return _context8.stop();
-              }
-            }, _callee8);
-          }));
-          function regexp(_x1) {
-            return _regexp.apply(this, arguments);
-          }
-          return regexp;
-        }()
+    if (isFunction(config.errorMessage)) {
+      rules.validate = __spreadProps(__spreadValues({}, rules.validate), {
+        regexp: async (value) => {
+          if (value == null || pattern.test(value)) return true;
+          return await resolveErrorMessage(config.errorMessage, value, fieldName, form);
+        }
       });
     } else {
       rules.pattern = {
@@ -333,144 +172,121 @@ var validationHandlers = {
     return rules;
   }
 };
-
-// Type guard functions using lodash
-var isValidatorConfig = function isValidatorConfig(config) {
-  return config && (0, _typeof2["default"])(config) === "object" && !Array.isArray(config) && typeof config !== "function" && (0, _lodashEs.isString)(config.type) && ((0, _lodashEs.isString)(config.errorMessage) || (0, _lodashEs.isFunction)(config.errorMessage)) && config.validator !== undefined;
+const isValidatorConfig = (config) => {
+  return config && typeof config === "object" && !Array.isArray(config) && typeof config !== "function" && isString(config.type) && (isString(config.errorMessage) || isFunction(config.errorMessage)) && config.validator !== void 0;
 };
-var isFunctionValidator = function isFunctionValidator(config) {
+const isFunctionValidator = (config) => {
   return typeof config === "function";
 };
-var validateValidatorConfig = function validateValidatorConfig(config) {
-  var type = config.type,
-    validator = config.validator;
+const validateValidatorConfig = (config) => {
+  const { type, validator } = config;
   if (typeof validator === "function") {
     return true;
   }
   switch (type) {
     case "required":
-      if ((0, _lodashEs.isBoolean)(validator)) {
+      if (isBoolean(validator)) {
         return true;
       }
-      if ((0, _lodashEs.isString)(validator)) {
-        var str = validator;
+      if (isString(validator)) {
+        const str = validator;
         return str.toLowerCase() === "true" || str === "1";
       }
       return false;
     case "maxchars":
     case "minvalue":
     case "maxvalue":
-      // Accept number or numeric string
-      if ((0, _lodashEs.isNumber)(validator)) {
+      if (isNumber(validator)) {
         return !isNaN(validator) && isFinite(validator);
       }
-      if ((0, _lodashEs.isString)(validator)) {
-        var numValue = Number(validator);
+      if (isString(validator)) {
+        const numValue = Number(validator);
         return !isNaN(numValue) && isFinite(numValue);
       }
       return false;
     case "regexp":
-      // Handle RegExp object, string patterns, and edge cases
-      if ((0, _lodashEs.isRegExp)(validator)) {
+      if (isRegExp(validator)) {
         return true;
       }
-      if ((0, _lodashEs.isString)(validator)) {
-        // Empty string is valid (matches everything)
+      if (isString(validator)) {
         if (validator === "") {
           return true;
         }
         try {
-          // Try to create RegExp, handling patterns with or without slashes
-          var pattern = validator.replace(/^\/|\/$/g, "");
+          const pattern = validator.replace(/^\/|\/$/g, "");
           new RegExp(pattern);
           return true;
-        } catch (_unused) {
+        } catch (e) {
           return false;
         }
       }
       return false;
     case "mindate":
     case "maxdate":
-      // Accept string or Date object
-      if ((0, _lodashEs.isString)(validator)) {
-        // Validate that it's a parseable date
-        var date = new Date(validator);
+      if (isString(validator)) {
+        const date = new Date(validator);
         return !isNaN(date.getTime());
       }
-      if ((0, _lodashEs.isDate)(validator)) {
+      if (isDate(validator)) {
         return !isNaN(validator.getTime());
       }
       return false;
     case "mintime":
     case "maxtime":
-      // Accept time strings in various formats
-      if (!(0, _lodashEs.isString)(validator)) {
+      if (!isString(validator)) {
         return false;
       }
-      // Support multiple time formats: HH:mm, HH:mm:ss, H:mm, etc.
-      var timeFormats = [/^\d{1,2}:\d{2}$/,
-      // H:mm or HH:mm
-      /^\d{1,2}:\d{2}:\d{2}$/,
-      // H:mm:ss or HH:mm:ss
-      /^\d{1,2}:\d{2}\s*(AM|PM|am|pm)$/i,
-      // h:mm AM/PM
-      /^\d{1,2}:\d{2}:\d{2}\s*(AM|PM|am|pm)$/i // h:mm:ss AM/PM
+      const timeFormats = [
+        /^\d{1,2}:\d{2}$/,
+        // H:mm or HH:mm
+        /^\d{1,2}:\d{2}:\d{2}$/,
+        // H:mm:ss or HH:mm:ss
+        /^\d{1,2}:\d{2}\s*(AM|PM|am|pm)$/i,
+        // h:mm AM/PM
+        /^\d{1,2}:\d{2}:\d{2}\s*(AM|PM|am|pm)$/i
+        // h:mm:ss AM/PM
       ];
-      return timeFormats.some(function (format) {
-        return format.test(validator.trim());
-      });
+      return timeFormats.some((format) => format.test(validator.trim()));
     case "excludedates":
-      // Accept array of strings/Dates or comma-separated string
-      if ((0, _lodashEs.isArray)(validator)) {
-        return validator.every(function (v) {
-          if ((0, _lodashEs.isString)(v)) {
-            var _date = new Date(v);
-            return !isNaN(_date.getTime());
+      if (isArray(validator)) {
+        return validator.every((v) => {
+          if (isString(v)) {
+            const date = new Date(v);
+            return !isNaN(date.getTime());
           }
-          if ((0, _lodashEs.isDate)(v)) {
+          if (isDate(v)) {
             return !isNaN(v.getTime());
           }
           return false;
         });
       }
-      if ((0, _lodashEs.isString)(validator)) {
-        // Handle comma-separated string
-        var validatorStr = validator;
-        var dates = validatorStr.split(",").map(function (d) {
-          return d.trim();
-        }).filter(function (d) {
-          return d.length > 0;
-        });
-        return dates.every(function (dateStr) {
-          var date = new Date(dateStr);
+      if (isString(validator)) {
+        const validatorStr = validator;
+        const dates = validatorStr.split(",").map((d) => d.trim()).filter((d) => d.length > 0);
+        return dates.every((dateStr) => {
+          const date = new Date(dateStr);
           return !isNaN(date.getTime());
         });
       }
       return false;
     case "excludedays":
-      // Accept array of numbers or comma-separated string of numbers (0-6)
-      if ((0, _lodashEs.isArray)(validator)) {
-        return validator.every(function (v) {
-          if ((0, _lodashEs.isNumber)(v)) {
+      if (isArray(validator)) {
+        return validator.every((v) => {
+          if (isNumber(v)) {
             return v >= 0 && v <= 6 && Number.isInteger(v);
           }
-          if ((0, _lodashEs.isString)(v)) {
-            var num = Number(v);
+          if (isString(v)) {
+            const num = Number(v);
             return !isNaN(num) && num >= 0 && num <= 6 && Number.isInteger(num);
           }
           return false;
         });
       }
-      if ((0, _lodashEs.isString)(validator)) {
-        // Handle comma-separated string
-        var _validatorStr = validator;
-        var days = _validatorStr.split(",").map(function (d) {
-          return d.trim();
-        }).filter(function (d) {
-          return d.length > 0;
-        });
-        return days.every(function (dayStr) {
-          var num = Number(dayStr);
+      if (isString(validator)) {
+        const validatorStr = validator;
+        const days = validatorStr.split(",").map((d) => d.trim()).filter((d) => d.length > 0);
+        return days.every((dayStr) => {
+          const num = Number(dayStr);
           return !isNaN(num) && num >= 0 && num <= 6 && Number.isInteger(num);
         });
       }
@@ -479,95 +295,56 @@ var validateValidatorConfig = function validateValidatorConfig(config) {
       return false;
   }
 };
-var createValidationRules = exports.createValidationRules = function createValidationRules(validators) {
-  var form = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var fieldName = arguments.length > 2 ? arguments[2] : undefined;
-  var functionValidators = validators.filter(isFunctionValidator);
-  var configValidators = validators.filter(isValidatorConfig);
-  var unrecognized = validators.filter(function (v) {
-    return !isFunctionValidator(v) && !isValidatorConfig(v);
-  });
+const createValidationRules = (validators, form = {}, fieldName) => {
+  const functionValidators = validators.filter(isFunctionValidator);
+  const configValidators = validators.filter(isValidatorConfig);
+  const unrecognized = validators.filter((v) => !isFunctionValidator(v) && !isValidatorConfig(v));
   if (unrecognized.length > 0) {
     console.warn("Unrecognized validator configurations:", unrecognized);
   }
-  var validConfigs = configValidators.filter(function (config) {
+  const validConfigs = configValidators.filter((config) => {
     if (!validateValidatorConfig(config)) {
       console.warn("Invalid validator values for type:", config.type, config);
       return false;
     }
     return true;
   });
-  var rules = (0, _lodashEs.reduce)(validConfigs, function (acc, config) {
-    var handler = validationHandlers[config.type];
-    if (handler) return handler(config, acc, form, fieldName);
-    console.warn("No handler found for validator type: ".concat(config.type));
-    return acc;
-  }, {});
+  const rules = reduce(
+    validConfigs,
+    (acc, config) => {
+      const handler = validationHandlers[config.type];
+      if (handler) return handler(config, acc, form, fieldName);
+      console.warn(`No handler found for validator type: ${config.type}`);
+      return acc;
+    },
+    {}
+  );
   if (functionValidators.length > 0) {
-    var functionValidateRules = (0, _lodashEs.reduce)(functionValidators, function (acc, validator, index) {
-      acc["customValidator".concat(index)] = /*#__PURE__*/function () {
-        var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9(value) {
-          var result;
-          return _regenerator["default"].wrap(function _callee9$(_context9) {
-            while (1) switch (_context9.prev = _context9.next) {
-              case 0:
-                _context9.prev = 0;
-                _context9.next = 3;
-                return validator({
-                  value: value,
-                  fieldName: fieldName
-                }, form);
-              case 3:
-                result = _context9.sent;
-                if (!(typeof result === "string")) {
-                  _context9.next = 6;
-                  break;
-                }
-                return _context9.abrupt("return", result);
-              case 6:
-                if (!(typeof result === "boolean")) {
-                  _context9.next = 8;
-                  break;
-                }
-                return _context9.abrupt("return", result || "Validation failed");
-              case 8:
-                if (!(result !== null && result !== void 0 && result.errorMessage)) {
-                  _context9.next = 10;
-                  break;
-                }
-                return _context9.abrupt("return", result.errorMessage);
-              case 10:
-                return _context9.abrupt("return", true);
-              case 13:
-                _context9.prev = 13;
-                _context9.t0 = _context9["catch"](0);
-                if (!(_context9.t0 !== null && _context9.t0 !== void 0 && _context9.t0.errorMessage)) {
-                  _context9.next = 17;
-                  break;
-                }
-                return _context9.abrupt("return", _context9.t0.errorMessage);
-              case 17:
-                if (!(typeof _context9.t0 === "string")) {
-                  _context9.next = 19;
-                  break;
-                }
-                return _context9.abrupt("return", _context9.t0);
-              case 19:
-                console.warn("Function validator threw an error:", _context9.t0);
-                return _context9.abrupt("return", "Validation error occurred");
-              case 21:
-              case "end":
-                return _context9.stop();
-            }
-          }, _callee9, null, [[0, 13]]);
-        }));
-        return function (_x10) {
-          return _ref2.apply(this, arguments);
+    const functionValidateRules = reduce(
+      functionValidators,
+      (acc, validator, index) => {
+        acc[`customValidator${index}`] = async (value) => {
+          try {
+            const result = await validator({ value, fieldName }, form);
+            if (typeof result === "string") return result;
+            if (typeof result === "boolean") return result || "Validation failed";
+            if (result == null ? void 0 : result.errorMessage) return result.errorMessage;
+            return true;
+          } catch (error) {
+            if (error == null ? void 0 : error.errorMessage) return error.errorMessage;
+            if (typeof error === "string") return error;
+            console.warn("Function validator threw an error:", error);
+            return "Validation error occurred";
+          }
         };
-      }();
-      return acc;
-    }, {});
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), functionValidateRules);
+        return acc;
+      },
+      {}
+    );
+    rules.validate = __spreadValues(__spreadValues({}, rules.validate), functionValidateRules);
   }
   return rules;
-};
+};
+export {
+  createValidationRules
+};