@wavemaker-ai/react-runtime 1.0.0-rc.309

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

@@ -0,0 +1,573 @@
+"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) {
+  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, form, fieldName) {
+    if (config.validator) {
+      var isConditionalRequired = (0, _lodashEs.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);
+            }
+            return required;
+          }()
+        });
+      } 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 {
+        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);
+        }
+        return noWhitespaces;
+      }()
+    });
+    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;
+        }()
+      });
+    } else {
+      rules.maxLength = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
+    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;
+        }()
+      });
+    } else {
+      rules.min = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
+    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;
+        }()
+      });
+    } else {
+      rules.max = {
+        value: config.validator,
+        message: config.errorMessage
+      };
+    }
+    return 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;
+    } 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;
+        }()
+      });
+    } 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) || (0, _lodashEs.isFunction)(config.errorMessage)) && config.validator !== undefined;
+};
+var isFunctionValidator = function isFunctionValidator(config) {
+  return typeof config === "function";
+};
+var validateValidatorConfig = function validateValidatorConfig(config) {
+  var type = config.type,
+    validator = config.validator;
+  if (typeof validator === "function") {
+    return true;
+  }
+  switch (type) {
+    case "required":
+      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":
+      // 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":
+      // 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 {
+          // Try to create RegExp, handling patterns with or without slashes
+          var pattern = validator.replace(/^\/|\/$/g, "");
+          new RegExp(pattern);
+          return true;
+        } catch (_unused) {
+          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);
+        return !isNaN(date.getTime());
+      }
+      if ((0, _lodashEs.isDate)(validator)) {
+        return !isNaN(validator.getTime());
+      }
+      return false;
+    case "mintime":
+    case "maxtime":
+      // 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":
+      // 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;
+  }
+};
+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);
+  });
+  if (unrecognized.length > 0) {
+    console.warn("Unrecognized validator configurations:", unrecognized);
+  }
+  var validConfigs = configValidators.filter(function (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;
+  }, {});
+  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);
+        };
+      }();
+      return acc;
+    }, {});
+    rules.validate = _objectSpread(_objectSpread({}, rules.validate), functionValidateRules);
+  }
+  return rules;
+};

package/components/data/form/form-controller/withFormController.d.ts

@@ -0,0 +1,3 @@
+import { WithFormControllerProps } from "../form-controller/props";
+declare const withFormController: <P extends object>(WrappedComponent: React.ComponentType<P>) => import("react").NamedExoticComponent<WithFormControllerProps & P>;
+export default withFormController;