@wavemaker/react-runtime 11.14.3-rc.6401 → 11.15.0-2.247

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

@@ -6,50 +6,241 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createValidationRules = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 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) {
+  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);
+  if (parsedMoment.isValid()) {
+    return parsedMoment.hours() * 60 + parsedMoment.minutes();
+  }
+  return null;
+};
 var validationHandlers = {
-  required: function required(config, rules) {
+  required: function required(config, rules, form, fieldName) {
     if (config.validator) {
-      rules.required = config.errorMessage;
+      if ((0, _lodashEs.isFunction)(config.errorMessage)) {
+        rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
+          required: function () {
+            var _required = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(value) {
+              return _regenerator["default"].wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    if (!(value != null && value !== "")) {
+                      _context2.next = 2;
+                      break;
+                    }
+                    return _context2.abrupt("return", true);
+                  case 2:
+                    _context2.next = 4;
+                    return resolveErrorMessage(config.errorMessage, value, fieldName, form);
+                  case 4:
+                    return _context2.abrupt("return", _context2.sent);
+                  case 5:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2);
+            }));
+            function required(_x5) {
+              return _required.apply(this, arguments);
+            }
+            return required;
+          }()
+        });
+      } else {
+        rules.required = config.errorMessage;
+      }
     }
     rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      noWhitespaces: function noWhitespaces(value) {
-        if (typeof value === "string" && value.length > 0 && value.trim() === "") {
-          return config.errorMessage;
+      noWhitespaces: function () {
+        var _noWhitespaces = (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 (!(typeof value === "string" && value.length > 0 && value.trim() === "")) {
+                  _context3.next = 4;
+                  break;
+                }
+                _context3.next = 3;
+                return resolveErrorMessage(config.errorMessage, value, fieldName, form);
+              case 3:
+                return _context3.abrupt("return", _context3.sent);
+              case 4:
+                return _context3.abrupt("return", true);
+              case 5:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3);
+        }));
+        function noWhitespaces(_x6) {
+          return _noWhitespaces.apply(this, arguments);
         }
-        return true;
-      }
+        return noWhitespaces;
+      }()
     });
     return rules;
   },
-  maxchars: function maxchars(config, rules) {
-    rules.maxLength = {
-      value: config.validator,
-      message: config.errorMessage
-    };
+  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 _callee4(value) {
+            return _regenerator["default"].wrap(function _callee4$(_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  if (!(value == null || value.length <= config.validator)) {
+                    _context4.next = 2;
+                    break;
+                  }
+                  return _context4.abrupt("return", true);
+                case 2:
+                  _context4.next = 4;
+                  return resolveErrorMessage(config.errorMessage, value, fieldName, form);
+                case 4:
+                  return _context4.abrupt("return", _context4.sent);
+                case 5:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          }));
+          function maxLength(_x7) {
+            return _maxLength.apply(this, arguments);
+          }
+          return maxLength;
+        }()
+      });
+    } else {
+      rules.maxLength = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
     return rules;
   },
-  minvalue: function minvalue(config, rules) {
-    rules.min = {
-      value: config.validator,
-      message: config.errorMessage
-    };
+  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 _callee5(value) {
+            return _regenerator["default"].wrap(function _callee5$(_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  if (!(value == null || Number(value) >= 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 minValue(_x8) {
+            return _minValue.apply(this, arguments);
+          }
+          return minValue;
+        }()
+      });
+    } else {
+      rules.min = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
     return rules;
   },
-  maxvalue: function maxvalue(config, rules) {
-    rules.max = {
-      value: config.validator,
-      message: config.errorMessage
-    };
+  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 _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 maxValue(_x9) {
+            return _maxValue.apply(this, arguments);
+          }
+          return maxValue;
+        }()
+      });
+    } else {
+      rules.max = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
     return rules;
   },
-  regexp: function regexp(config, rules) {
+  regexp: function regexp(config, rules, form, fieldName) {
     var pattern;
     try {
       pattern = (0, _lodashEs.isString)(config.validator) ? new RegExp(config.validator.replace(/^\/|\/$/g, "")) : config.validator;
@@ -57,121 +248,48 @@ var validationHandlers = {
       console.warn("Invalid regexp string:", config.validator);
       return rules;
     }
-    rules.pattern = {
-      value: pattern,
-      message: config.errorMessage
-    };
-    return rules;
-  },
-  mindate: function mindate(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      minDate: function minDate(value) {
-        if (!value) return true;
-        var inputDate = new Date(value);
-        var minDate = new Date(config.validator);
-        if (isNaN(inputDate.getTime()) || isNaN(minDate.getTime())) {
-          return "Invalid date format";
-        }
-        return inputDate >= minDate || config.errorMessage;
-      }
-    });
-    return rules;
-  },
-  maxdate: function maxdate(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      maxDate: function maxDate(value) {
-        if (!value) return true;
-        var inputDate = new Date(value);
-        var maxDate = new Date(config.validator);
-        if (isNaN(inputDate.getTime()) || isNaN(maxDate.getTime())) {
-          return "Invalid date format";
-        }
-        return inputDate <= maxDate || config.errorMessage;
-      }
-    });
-    return rules;
-  },
-  mintime: function mintime(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      minTime: function minTime(value) {
-        if (!value) return true;
-        var parseTime = function parseTime(time) {
-          var _time$split$map = time.split(":").map(Number),
-            _time$split$map2 = (0, _slicedToArray2["default"])(_time$split$map, 2),
-            hours = _time$split$map2[0],
-            minutes = _time$split$map2[1];
-          return hours * 60 + minutes;
-        };
-        try {
-          var inputMinutes = parseTime(value);
-          var minMinutes = parseTime(config.validator);
-          return inputMinutes >= minMinutes || config.errorMessage;
-        } catch (_unused) {
-          return "Invalid time format";
-        }
-      }
-    });
-    return rules;
-  },
-  maxtime: function maxtime(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      maxTime: function maxTime(value) {
-        if (!value) return true;
-        var parseTime = function parseTime(time) {
-          var _time$split$map3 = time.split(":").map(Number),
-            _time$split$map4 = (0, _slicedToArray2["default"])(_time$split$map3, 2),
-            hours = _time$split$map4[0],
-            minutes = _time$split$map4[1];
-          return hours * 60 + minutes;
-        };
-        try {
-          var inputMinutes = parseTime(value);
-          var maxMinutes = parseTime(config.validator);
-          return inputMinutes <= maxMinutes || config.errorMessage;
-        } catch (_unused2) {
-          return "Invalid time format";
-        }
-      }
-    });
-    return rules;
-  },
-  excludedates: function excludedates(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      excludeDates: function excludeDates(value) {
-        if (!value) return true;
-        var inputDate = new Date(value);
-        if (isNaN(inputDate.getTime())) return "Invalid date format";
-        var formatDate = function formatDate(date) {
-          var d = (0, _lodashEs.isDate)(date) ? date : new Date(date);
-          return d.toISOString().split("T")[0];
-        };
-        var inputDateStr = formatDate(value);
-        var isExcluded = config.validator.some(function (excludedDate) {
-          return formatDate(excludedDate) === inputDateStr;
-        });
-        return !isExcluded || config.errorMessage;
-      }
-    });
-    return rules;
-  },
-  excludedays: function excludedays(config, rules) {
-    rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
-      excludeDays: function excludeDays(value) {
-        if (!value) return true;
-        var inputDate = new Date(value);
-        if (isNaN(inputDate.getTime())) return "Invalid date format";
-        var dayOfWeek = inputDate.getDay();
-        var isExcluded = config.validator.includes(dayOfWeek);
-        return !isExcluded || config.errorMessage;
-      }
-    });
+    if ((0, _lodashEs.isFunction)(config.errorMessage)) {
+      rules.validate = _objectSpread(_objectSpread({}, rules.validate), {}, {
+        regexp: function () {
+          var _regexp = (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 || pattern.test(value))) {
+                    _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 regexp(_x0) {
+            return _regexp.apply(this, arguments);
+          }
+          return regexp;
+        }()
+      });
+    } else {
+      rules.pattern = {
+        value: pattern,
+        message: config.errorMessage
+      };
+    }
     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) && config.validator !== undefined;
+  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;
 };
 var isFunctionValidator = function isFunctionValidator(config) {
   return typeof config === "function";
@@ -179,36 +297,137 @@ var isFunctionValidator = function isFunctionValidator(config) {
 var validateValidatorConfig = function validateValidatorConfig(config) {
   var type = config.type,
     validator = config.validator;
+  if (typeof validator === "function") {
+    return true;
+  }
   switch (type) {
     case "required":
-      return (0, _lodashEs.isBoolean)(validator);
+      if ((0, _lodashEs.isBoolean)(validator)) {
+        return true;
+      }
+      if ((0, _lodashEs.isString)(validator)) {
+        var str = validator;
+        return str.toLowerCase() === "true" || str === "1";
+      }
+      return false;
     case "maxchars":
     case "minvalue":
     case "maxvalue":
-      return (0, _lodashEs.isNumber)(validator);
+      // Accept number or numeric string
+      if ((0, _lodashEs.isNumber)(validator)) {
+        return !isNaN(validator) && isFinite(validator);
+      }
+      if ((0, _lodashEs.isString)(validator)) {
+        var numValue = Number(validator);
+        return !isNaN(numValue) && isFinite(numValue);
+      }
+      return false;
     case "regexp":
-      return (0, _lodashEs.isRegExp)(validator) || (0, _lodashEs.isString)(validator) && function () {
+      // Handle RegExp object, string patterns, and edge cases
+      if ((0, _lodashEs.isRegExp)(validator)) {
+        return true;
+      }
+      if ((0, _lodashEs.isString)(validator)) {
+        // Empty string is valid (matches everything)
+        if (validator === "") {
+          return true;
+        }
         try {
-          new RegExp(validator.replace(/^\/|\/$/g, ""));
+          // Try to create RegExp, handling patterns with or without slashes
+          var pattern = validator.replace(/^\/|\/$/g, "");
+          new RegExp(pattern);
           return true;
-        } catch (_unused3) {
+        } catch (_unused) {
           return false;
         }
-      }();
+      }
+      return false;
     case "mindate":
     case "maxdate":
-      return (0, _lodashEs.isString)(validator) || (0, _lodashEs.isDate)(validator);
+      // Accept string or Date object
+      if ((0, _lodashEs.isString)(validator)) {
+        // Validate that it's a parseable date
+        var date = new Date(validator);
+        return !isNaN(date.getTime());
+      }
+      if ((0, _lodashEs.isDate)(validator)) {
+        return !isNaN(validator.getTime());
+      }
+      return false;
     case "mintime":
     case "maxtime":
-      return (0, _lodashEs.isString)(validator) && /^\d{2}:\d{2}$/.test(validator);
-    case "excludedates":
-      return (0, _lodashEs.isArray)(validator) && validator.every(function (v) {
-        return (0, _lodashEs.isString)(v) || (0, _lodashEs.isDate)(v);
+      // Accept time strings in various formats
+      if (!(0, _lodashEs.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
+      ];
+      return timeFormats.some(function (format) {
+        return 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 ((0, _lodashEs.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);
+          return !isNaN(date.getTime());
+        });
+      }
+      return false;
     case "excludedays":
-      return (0, _lodashEs.isArray)(validator) && validator.every(function (v) {
-        return (0, _lodashEs.isNumber)(v) && v >= 0 && v <= 6;
-      });
+      // 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)) {
+            return v >= 0 && v <= 6 && Number.isInteger(v);
+          }
+          if ((0, _lodashEs.isString)(v)) {
+            var 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);
+          return !isNaN(num) && num >= 0 && num <= 6 && Number.isInteger(num);
+        });
+      }
+      return false;
     default:
       return false;
   }
@@ -233,76 +452,70 @@ var createValidationRules = exports.createValidationRules = function createValid
   });
   var rules = (0, _lodashEs.reduce)(validConfigs, function (acc, config) {
     var handler = validationHandlers[config.type];
-    if (handler) return handler(config, acc);
+    if (handler) return handler(config, acc, form, fieldName);
     console.warn("No handler found for validator type: ".concat(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 _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(value) {
+        var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(value) {
           var result;
-          return _regenerator["default"].wrap(function _callee$(_context) {
-            while (1) switch (_context.prev = _context.next) {
+          return _regenerator["default"].wrap(function _callee8$(_context8) {
+            while (1) switch (_context8.prev = _context8.next) {
               case 0:
-                _context.prev = 0;
-                if (value) {
-                  _context.next = 3;
-                  break;
-                }
-                return _context.abrupt("return", true);
-              case 3:
-                _context.next = 5;
+                _context8.prev = 0;
+                _context8.next = 3;
                 return validator({
                   value: value,
                   fieldName: fieldName
                 }, form);
-              case 5:
-                result = _context.sent;
+              case 3:
+                result = _context8.sent;
                 if (!(typeof result === "string")) {
-                  _context.next = 8;
+                  _context8.next = 6;
                   break;
                 }
-                return _context.abrupt("return", result);
-              case 8:
+                return _context8.abrupt("return", result);
+              case 6:
                 if (!(typeof result === "boolean")) {
-                  _context.next = 10;
+                  _context8.next = 8;
                   break;
                 }
-                return _context.abrupt("return", result || "Validation failed");
-              case 10:
+                return _context8.abrupt("return", result || "Validation failed");
+              case 8:
                 if (!(result !== null && result !== void 0 && result.errorMessage)) {
-                  _context.next = 12;
+                  _context8.next = 10;
                   break;
                 }
-                return _context.abrupt("return", result.errorMessage);
-              case 12:
-                return _context.abrupt("return", true);
-              case 15:
-                _context.prev = 15;
-                _context.t0 = _context["catch"](0);
-                if (!(_context.t0 !== null && _context.t0 !== void 0 && _context.t0.errorMessage)) {
-                  _context.next = 19;
+                return _context8.abrupt("return", result.errorMessage);
+              case 10:
+                return _context8.abrupt("return", true);
+              case 13:
+                _context8.prev = 13;
+                _context8.t0 = _context8["catch"](0);
+                if (!(_context8.t0 !== null && _context8.t0 !== void 0 && _context8.t0.errorMessage)) {
+                  _context8.next = 17;
                   break;
                 }
-                return _context.abrupt("return", _context.t0.errorMessage);
-              case 19:
-                if (!(typeof _context.t0 === "string")) {
-                  _context.next = 21;
+                return _context8.abrupt("return", _context8.t0.errorMessage);
+              case 17:
+                if (!(typeof _context8.t0 === "string")) {
+                  _context8.next = 19;
                   break;
                 }
-                return _context.abrupt("return", _context.t0);
+                return _context8.abrupt("return", _context8.t0);
+              case 19:
+                console.warn("Function validator threw an error:", _context8.t0);
+                return _context8.abrupt("return", "Validation error occurred");
               case 21:
-                console.warn("Function validator threw an error:", _context.t0);
-                return _context.abrupt("return", "Validation error occurred");
-              case 23:
               case "end":
-                return _context.stop();
+                return _context8.stop();
             }
-          }, _callee, null, [[0, 15]]);
+          }, _callee8, null, [[0, 13]]);
         }));
-        return function (_x) {
-          return _ref.apply(this, arguments);
+        return function (_x1) {
+          return _ref2.apply(this, arguments);
         };
       }();
       return acc;