@1money/component-ui 0.0.1

package/es/components/Form/hooks/useForm.js

@@ -0,0 +1,541 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import React, { useState, useMemo, useCallback, useEffect, memo, Fragment } from 'react';
+import { useEventCallback, useMemoizedFn, useSafeState } from '@1money/hooks';
+import { useFormCore } from './useFormCore';
+export var useForm = function useForm() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var onValuesChange = options.onValuesChange,
+    _options$validateTrig = options.validateTrigger,
+    validateTrigger = _options$validateTrig === void 0 ? 'onChange' : _options$validateTrig;
+  var formCore = useFormCore({
+    initialValues: initialValues,
+    onValuesChange: onValuesChange,
+    validateTrigger: validateTrigger
+  });
+  var _useSafeState = useSafeState({}),
+    _useSafeState2 = _slicedToArray(_useSafeState, 2),
+    validating = _useSafeState2[0],
+    setValidating = _useSafeState2[1];
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    extraTouched = _useState2[0],
+    setExtraTouched = _useState2[1];
+  var allTouched = useMemo(function () {
+    return Object.assign(Object.assign({}, formCore.touched), extraTouched);
+  }, [formCore.touched, extraTouched]);
+  var validateFieldAsync = useMemoizedFn(function (name, value, rules) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var basicValid, _iterator, _step, rule, result, error, errorMessage, _error, _error2, emailPattern, _error3, _error4;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(!rules || rules.length === 0)) {
+              _context.next = 2;
+              break;
+            }
+            return _context.abrupt("return", {
+              isValid: true,
+              error: null
+            });
+          case 2:
+            setValidating(function (prev) {
+              return Object.assign(Object.assign({}, prev), _defineProperty({}, name, true));
+            });
+            _context.prev = 3;
+            basicValid = formCore.validateField(name, rules, value);
+            if (basicValid) {
+              _context.next = 7;
+              break;
+            }
+            return _context.abrupt("return", {
+              isValid: false,
+              error: formCore.errors[name] || null
+            });
+          case 7:
+            _iterator = _createForOfIteratorHelper(rules);
+            _context.prev = 8;
+            _iterator.s();
+          case 10:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 56;
+              break;
+            }
+            rule = _step.value;
+            if (!(rule.validator && typeof rule.validator === 'function')) {
+              _context.next = 28;
+              break;
+            }
+            _context.prev = 13;
+            _context.next = 16;
+            return Promise.resolve(rule.validator(value, formCore.values));
+          case 16:
+            result = _context.sent;
+            if (!(result !== true && result !== undefined)) {
+              _context.next = 21;
+              break;
+            }
+            error = typeof result === 'string' ? result : 'Validation failed';
+            formCore.setFieldError(name, error);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: error
+            });
+          case 21:
+            _context.next = 28;
+            break;
+          case 23:
+            _context.prev = 23;
+            _context.t0 = _context["catch"](13);
+            errorMessage = _context.t0 instanceof Error ? _context.t0.message : 'Validation error';
+            formCore.setFieldError(name, errorMessage);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: errorMessage
+            });
+          case 28:
+            if (!(rule["enum"] && Array.isArray(rule["enum"]) && value)) {
+              _context.next = 33;
+              break;
+            }
+            if (rule["enum"].includes(value)) {
+              _context.next = 33;
+              break;
+            }
+            _error = rule.message || "".concat(name, " must be one of ").concat(rule["enum"].join(', '));
+            formCore.setFieldError(name, _error);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: _error
+            });
+          case 33:
+            if (!(rule.type === 'number' && value !== undefined && value !== null && value !== '')) {
+              _context.next = 38;
+              break;
+            }
+            if (!(typeof value !== 'number' || isNaN(value))) {
+              _context.next = 38;
+              break;
+            }
+            _error2 = rule.message || "".concat(name, " must be a number");
+            formCore.setFieldError(name, _error2);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: _error2
+            });
+          case 38:
+            if (!(rule.type === 'email' && value)) {
+              _context.next = 44;
+              break;
+            }
+            emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (emailPattern.test(String(value))) {
+              _context.next = 44;
+              break;
+            }
+            _error3 = rule.message || "".concat(name, " must be a valid email");
+            formCore.setFieldError(name, _error3);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: _error3
+            });
+          case 44:
+            if (!(rule.type === 'url' && value)) {
+              _context.next = 54;
+              break;
+            }
+            _context.prev = 45;
+            new URL(String(value));
+            _context.next = 54;
+            break;
+          case 49:
+            _context.prev = 49;
+            _context.t1 = _context["catch"](45);
+            _error4 = rule.message || "".concat(name, " must be a valid URL");
+            formCore.setFieldError(name, _error4);
+            return _context.abrupt("return", {
+              isValid: false,
+              error: _error4
+            });
+          case 54:
+            _context.next = 10;
+            break;
+          case 56:
+            _context.next = 61;
+            break;
+          case 58:
+            _context.prev = 58;
+            _context.t2 = _context["catch"](8);
+            _iterator.e(_context.t2);
+          case 61:
+            _context.prev = 61;
+            _iterator.f();
+            return _context.finish(61);
+          case 64:
+            if (formCore.errors[name]) {
+              formCore.setFieldError(name, null);
+            }
+            return _context.abrupt("return", {
+              isValid: true,
+              error: null
+            });
+          case 66:
+            _context.prev = 66;
+            setValidating(function (prev) {
+              var newValidating = Object.assign({}, prev);
+              delete newValidating[name];
+              return newValidating;
+            });
+            return _context.finish(66);
+          case 69:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[3,, 66, 69], [8, 58, 61, 64], [13, 23], [45, 49]]);
+    }));
+  });
+  var handleFieldBlur = useEventCallback(function (name) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var rules;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            setExtraTouched(function (prev) {
+              return Object.assign(Object.assign({}, prev), _defineProperty({}, name, true));
+            });
+            rules = formCore.fieldRules[name];
+            if (!(rules && validateTrigger === 'onBlur')) {
+              _context2.next = 5;
+              break;
+            }
+            _context2.next = 5;
+            return validateFieldAsync(name, formCore.values[name], rules);
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+  });
+  var validateFieldsAsync = useMemoizedFn(function (nameList) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var fieldsToValidate, hasError, fieldErrors, validationPromises, error;
+      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            fieldsToValidate = nameList || Object.keys(formCore.fieldRules);
+            hasError = false;
+            fieldErrors = {};
+            validationPromises = fieldsToValidate.map(function (name) {
+              return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+                var rules, _yield$validateFieldA, isValid, error;
+                return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                  while (1) switch (_context3.prev = _context3.next) {
+                    case 0:
+                      rules = formCore.fieldRules[name];
+                      if (!rules) {
+                        _context3.next = 8;
+                        break;
+                      }
+                      _context3.next = 4;
+                      return validateFieldAsync(name, formCore.values[name], rules);
+                    case 4:
+                      _yield$validateFieldA = _context3.sent;
+                      isValid = _yield$validateFieldA.isValid;
+                      error = _yield$validateFieldA.error;
+                      if (!isValid && error) {
+                        hasError = true;
+                        fieldErrors[name] = error;
+                      }
+                    case 8:
+                    case "end":
+                      return _context3.stop();
+                  }
+                }, _callee3);
+              }));
+            });
+            _context4.next = 6;
+            return Promise.all(validationPromises);
+          case 6:
+            if (!hasError) {
+              _context4.next = 11;
+              break;
+            }
+            error = new Error('Validation failed');
+            error.values = formCore.values;
+            error.errors = fieldErrors;
+            throw error;
+          case 11:
+            if (!nameList) {
+              _context4.next = 13;
+              break;
+            }
+            return _context4.abrupt("return", nameList.reduce(function (acc, name) {
+              acc[name] = formCore.values[name];
+              return acc;
+            }, {}));
+          case 13:
+            return _context4.abrupt("return", formCore.values);
+          case 14:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }));
+  });
+  var defineField = useCallback(function (name) {
+    var fieldOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _fieldOptions$rules = fieldOptions.rules,
+      rules = _fieldOptions$rules === void 0 ? [] : _fieldOptions$rules;
+    var FieldComponent = /*#__PURE__*/memo(function (_a) {
+      var _b;
+      var children = _a.children,
+        render = _a.render,
+        props = __rest(_a, ["children", "render"]);
+      var fieldValue = (_b = formCore.values[name]) !== null && _b !== void 0 ? _b : '';
+      var fieldError = formCore.errors[name];
+      var fieldTouched = allTouched[name];
+      var fieldValidating = validating[name];
+      useEffect(function () {
+        var existingRules = formCore.getFieldRules(name);
+        if (!existingRules && rules.length > 0) {
+          formCore.registerField(name, rules);
+        }
+        return function () {
+          formCore.unregisterField(name);
+        };
+      }, []); // Only register on mount
+      var handleFieldChange = useEventCallback(function (value) {
+        formCore.setFieldValue(name, value);
+        if (validateTrigger === 'onChange') {
+          formCore.validateField(name, rules, value);
+        }
+      });
+      var handleBlur = useEventCallback(function () {
+        handleFieldBlur(name);
+      });
+      var fieldProps = Object.assign({
+        name: name,
+        value: fieldValue,
+        error: fieldError,
+        touched: fieldTouched,
+        validating: fieldValidating,
+        onChange: handleFieldChange,
+        onBlur: handleBlur
+      }, props);
+      var handleMergeChange = function handleMergeChange(e) {
+        var _a;
+        var value = e && _typeof(e) === 'object' && 'target' in e ? e.target.value : e;
+        handleFieldChange(value);
+        if (/*#__PURE__*/React.isValidElement(children) && ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onChange)) {
+          children.props.onChange(value);
+        }
+      };
+      var handleMergeBlur = function handleMergeBlur() {
+        var _a;
+        handleBlur();
+        if (/*#__PURE__*/React.isValidElement(children) && ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onBlur)) {
+          children.props.onBlur();
+        }
+      };
+      if (render && typeof render === 'function') {
+        return render(fieldProps);
+      }
+      if (typeof children === 'function') {
+        return children(fieldProps);
+      }
+      if (/*#__PURE__*/React.isValidElement(children)) {
+        var mergedProps = Object.assign(Object.assign({}, fieldProps), {
+          onChange: handleMergeChange,
+          onBlur: handleMergeBlur
+        });
+        return /*#__PURE__*/React.cloneElement(children, mergedProps);
+      }
+      if (Array.isArray(children)) {
+        return /*#__PURE__*/React.createElement.apply(React, [Fragment, null].concat(_toConsumableArray(children.map(function (child, index) {
+          if (/*#__PURE__*/React.isValidElement(child)) {
+            var _mergedProps = Object.assign(Object.assign({}, fieldProps), {
+              key: child.key || index,
+              onChange: handleMergeChange,
+              onBlur: handleMergeBlur
+            });
+            return /*#__PURE__*/React.cloneElement(child, _mergedProps);
+          }
+          return child;
+        }))));
+      }
+      return null;
+    });
+    FieldComponent.displayName = "Field(".concat(name, ")");
+    return FieldComponent;
+  }, [formCore, allTouched, validating, validateTrigger, handleFieldBlur]);
+  var formInstance = useMemo(function () {
+    return Object.assign(Object.assign({}, formCore.formInstance), {
+      validateFields: validateFieldsAsync,
+      setFieldValue: formCore.setFieldValue,
+      getFieldError: function getFieldError(name) {
+        return formCore.errors[name];
+      },
+      getFieldsError: function getFieldsError(nameList) {
+        if (!nameList) return formCore.errors;
+        var result = {};
+        nameList.forEach(function (name) {
+          if (formCore.errors[name]) {
+            result[name] = formCore.errors[name];
+          }
+        });
+        return result;
+      },
+      isFieldTouched: function isFieldTouched(name) {
+        return allTouched[name] || false;
+      },
+      isFieldsTouched: function isFieldsTouched(nameList) {
+        var allFieldsTouched = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        if (!nameList) {
+          return Object.keys(allTouched).some(function (key) {
+            return allTouched[key];
+          });
+        }
+        if (allFieldsTouched) {
+          return nameList.every(function (name) {
+            return allTouched[name];
+          });
+        }
+        return nameList.some(function (name) {
+          return allTouched[name];
+        });
+      },
+      isFieldValidating: function isFieldValidating(name) {
+        return validating[name] || false;
+      },
+      setFieldError: formCore.setFieldError,
+      setFieldsError: function setFieldsError(fieldsError) {
+        Object.entries(fieldsError).forEach(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            name = _ref2[0],
+            error = _ref2[1];
+          formCore.setFieldError(name, error);
+        });
+      },
+      setFieldTouched: function setFieldTouched(name) {
+        var isTouched = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+        setExtraTouched(function (prev) {
+          return Object.assign(Object.assign({}, prev), _defineProperty({}, name, isTouched));
+        });
+      },
+      setFieldsTouched: function setFieldsTouched(fieldsTouch) {
+        setExtraTouched(function (prev) {
+          return Object.assign(Object.assign({}, prev), fieldsTouch);
+        });
+      },
+      resetFields: function resetFields(fields) {
+        if (!fields) {
+          formCore.resetFields();
+          setExtraTouched({});
+          setValidating({});
+        } else {
+          var resetValues = {};
+          fields.forEach(function (field) {
+            resetValues[field] = initialValues[field];
+          });
+          formCore.setFieldsValue(resetValues);
+          setExtraTouched(function (prev) {
+            var newTouched = Object.assign({}, prev);
+            fields.forEach(function (field) {
+              delete newTouched[field];
+            });
+            return newTouched;
+          });
+          setValidating(function (prev) {
+            var newValidating = Object.assign({}, prev);
+            fields.forEach(function (field) {
+              delete newValidating[field];
+            });
+            return newValidating;
+          });
+          fields.forEach(function (field) {
+            formCore.setFieldError(field, null);
+          });
+        }
+      },
+      submit: function submit(callback) {
+        return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+          var validatedValues;
+          return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.prev = 0;
+                _context5.next = 3;
+                return validateFieldsAsync();
+              case 3:
+                validatedValues = _context5.sent;
+                if (!callback) {
+                  _context5.next = 7;
+                  break;
+                }
+                _context5.next = 7;
+                return callback(validatedValues);
+              case 7:
+                return _context5.abrupt("return", validatedValues);
+              case 10:
+                _context5.prev = 10;
+                _context5.t0 = _context5["catch"](0);
+                return _context5.abrupt("return", undefined);
+              case 13:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5, null, [[0, 10]]);
+        }));
+      },
+      defineField: defineField,
+      registerField: formCore.registerField,
+      unregisterField: formCore.unregisterField
+    });
+  }, [formCore, allTouched, validating, validateFieldsAsync, defineField, initialValues, setValidating]);
+  return [formInstance];
+};
+export default useForm;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Form/hooks/useForm.js","components/Form/src/components/Form/hooks/useForm.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","__rest","s","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","React","useState","useMemo","useCallback","useEffect","memo","Fragment","useEventCallback","useMemoizedFn","useSafeState","useFormCore","useForm","initialValues","arguments","undefined","options","onValuesChange","_options$validateTrig","validateTrigger","formCore","_useSafeState","_useSafeState2","_slicedToArray","validating","setValidating","_useState","_useState2","extraTouched","setExtraTouched","allTouched","assign","touched","validateFieldAsync","name","rules","_regeneratorRuntime","mark","_callee","basicValid","_iterator","_step","rule","error","errorMessage","_error","_error2","emailPattern","_error3","_error4","wrap","_callee$","_context","prev","abrupt","isValid","_defineProperty","validateField","errors","_createForOfIteratorHelper","n","validator","values","sent","setFieldError","t0","Error","message","Array","isArray","includes","concat","join","type","isNaN","test","String","URL","t1","t2","f","finish","newValidating","stop","handleFieldBlur","_callee2","_callee2$","_context2","fieldRules","validateFieldsAsync","nameList","_callee4","fieldsToValidate","hasError","fieldErrors","validationPromises","_callee4$","_context4","keys","map","_callee3","_yield$validateFieldA","_callee3$","_context3","all","reduce","acc","defineField","fieldOptions","_fieldOptions$rules","FieldComponent","_a","_b","children","render","props","fieldValue","fieldError","fieldTouched","fieldValidating","existingRules","getFieldRules","registerField","unregisterField","handleFieldChange","setFieldValue","handleBlur","fieldProps","onChange","onBlur","handleMergeChange","_typeof","target","isValidElement","handleMergeBlur","mergedProps","cloneElement","createElement","_toConsumableArray","child","index","key","displayName","formInstance","validateFields","getFieldError","getFieldsError","forEach","isFieldTouched","isFieldsTouched","allFieldsTouched","some","every","isFieldValidating","setFieldsError","fieldsError","entries","_ref","_ref2","setFieldTouched","isTouched","setFieldsTouched","fieldsTouch","resetFields","fields","resetValues","field","setFieldsValue","newTouched","submit","callback","_callee5","validatedValues","_callee5$","_context5"],"mappings":"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","file":"components/Form/hooks/useForm.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport React, { useState, useMemo, useCallback, useEffect, memo, Fragment } from 'react';\nimport { useEventCallback, useMemoizedFn, useSafeState } from '@1money/hooks';\nimport { useFormCore } from './useFormCore';\nexport const useForm = (initialValues = {}, options = {}) => {\n    const { onValuesChange, validateTrigger = 'onChange' } = options;\n    const formCore = useFormCore({\n        initialValues,\n        onValuesChange,\n        validateTrigger,\n    });\n    const [validating, setValidating] = useSafeState({});\n    const [extraTouched, setExtraTouched] = useState({});\n    const allTouched = useMemo(() => (Object.assign(Object.assign({}, formCore.touched), extraTouched)), [formCore.touched, extraTouched]);\n    const validateFieldAsync = useMemoizedFn((name, value, rules) => __awaiter(void 0, void 0, void 0, function* () {\n        if (!rules || rules.length === 0)\n            return { isValid: true, error: null };\n        setValidating((prev) => (Object.assign(Object.assign({}, prev), { [name]: true })));\n        try {\n            const basicValid = formCore.validateField(name, rules, value);\n            if (!basicValid) {\n                return { isValid: false, error: formCore.errors[name] || null };\n            }\n            for (const rule of rules) {\n                if (rule.validator && typeof rule.validator === 'function') {\n                    try {\n                        const result = yield Promise.resolve(rule.validator(value, formCore.values));\n                        if (result !== true && result !== undefined) {\n                            const error = typeof result === 'string' ? result : 'Validation failed';\n                            formCore.setFieldError(name, error);\n                            return { isValid: false, error };\n                        }\n                    }\n                    catch (err) {\n                        const errorMessage = err instanceof Error ? err.message : 'Validation error';\n                        formCore.setFieldError(name, errorMessage);\n                        return { isValid: false, error: errorMessage };\n                    }\n                }\n                if (rule.enum && Array.isArray(rule.enum) && value) {\n                    if (!rule.enum.includes(value)) {\n                        const error = rule.message ||\n                            `${name} must be one of ${rule.enum.join(', ')}`;\n                        formCore.setFieldError(name, error);\n                        return { isValid: false, error };\n                    }\n                }\n                if (rule.type === 'number' &&\n                    value !== undefined &&\n                    value !== null &&\n                    value !== '') {\n                    if (typeof value !== 'number' || isNaN(value)) {\n                        const error = rule.message || `${name} must be a number`;\n                        formCore.setFieldError(name, error);\n                        return { isValid: false, error };\n                    }\n                }\n                if (rule.type === 'email' && value) {\n                    const emailPattern = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n                    if (!emailPattern.test(String(value))) {\n                        const error = rule.message || `${name} must be a valid email`;\n                        formCore.setFieldError(name, error);\n                        return { isValid: false, error };\n                    }\n                }\n                if (rule.type === 'url' && value) {\n                    try {\n                        new URL(String(value));\n                    }\n                    catch (_a) {\n                        const error = rule.message || `${name} must be a valid URL`;\n                        formCore.setFieldError(name, error);\n                        return { isValid: false, error };\n                    }\n                }\n            }\n            if (formCore.errors[name]) {\n                formCore.setFieldError(name, null);\n            }\n            return { isValid: true, error: null };\n        }\n        finally {\n            setValidating((prev) => {\n                const newValidating = Object.assign({}, prev);\n                delete newValidating[name];\n                return newValidating;\n            });\n        }\n    }));\n    const handleFieldBlur = useEventCallback((name) => __awaiter(void 0, void 0, void 0, function* () {\n        setExtraTouched((prev) => (Object.assign(Object.assign({}, prev), { [name]: true })));\n        const rules = formCore.fieldRules[name];\n        if (rules && validateTrigger === 'onBlur') {\n            yield validateFieldAsync(name, formCore.values[name], rules);\n        }\n    }));\n    const validateFieldsAsync = useMemoizedFn((nameList) => __awaiter(void 0, void 0, void 0, function* () {\n        const fieldsToValidate = nameList || Object.keys(formCore.fieldRules);\n        let hasError = false;\n        const fieldErrors = {};\n        const validationPromises = fieldsToValidate.map((name) => __awaiter(void 0, void 0, void 0, function* () {\n            const rules = formCore.fieldRules[name];\n            if (rules) {\n                const { isValid, error } = yield validateFieldAsync(name, formCore.values[name], rules);\n                if (!isValid && error) {\n                    hasError = true;\n                    fieldErrors[name] = error;\n                }\n            }\n        }));\n        yield Promise.all(validationPromises);\n        if (hasError) {\n            const error = new Error('Validation failed');\n            error.values = formCore.values;\n            error.errors = fieldErrors;\n            throw error;\n        }\n        if (nameList) {\n            return nameList.reduce((acc, name) => {\n                acc[name] = formCore.values[name];\n                return acc;\n            }, {});\n        }\n        return formCore.values;\n    }));\n    const defineField = useCallback((name, fieldOptions = {}) => {\n        const { rules = [] } = fieldOptions;\n        const FieldComponent = memo((_a) => {\n            var _b;\n            var { children, render } = _a, props = __rest(_a, [\"children\", \"render\"]);\n            const fieldValue = (_b = formCore.values[name]) !== null && _b !== void 0 ? _b : '';\n            const fieldError = formCore.errors[name];\n            const fieldTouched = allTouched[name];\n            const fieldValidating = validating[name];\n            useEffect(() => {\n                const existingRules = formCore.getFieldRules(name);\n                if (!existingRules && rules.length > 0) {\n                    formCore.registerField(name, rules);\n                }\n                return () => {\n                    formCore.unregisterField(name);\n                };\n            }, []); // Only register on mount\n            const handleFieldChange = useEventCallback((value) => {\n                formCore.setFieldValue(name, value);\n                if (validateTrigger === 'onChange') {\n                    formCore.validateField(name, rules, value);\n                }\n            });\n            const handleBlur = useEventCallback(() => {\n                handleFieldBlur(name);\n            });\n            const fieldProps = Object.assign({ name, value: fieldValue, error: fieldError, touched: fieldTouched, validating: fieldValidating, onChange: handleFieldChange, onBlur: handleBlur }, props);\n            const handleMergeChange = (e) => {\n                var _a;\n                const value = e && typeof e === 'object' && 'target' in e\n                    ? e.target.value\n                    : e;\n                handleFieldChange(value);\n                if (React.isValidElement(children) &&\n                    ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onChange)) {\n                    children.props.onChange(value);\n                }\n            };\n            const handleMergeBlur = () => {\n                var _a;\n                handleBlur();\n                if (React.isValidElement(children) &&\n                    ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onBlur)) {\n                    children.props.onBlur();\n                }\n            };\n            if (render && typeof render === 'function') {\n                return render(fieldProps);\n            }\n            if (typeof children === 'function') {\n                return children(fieldProps);\n            }\n            if (React.isValidElement(children)) {\n                const mergedProps = Object.assign(Object.assign({}, fieldProps), { onChange: handleMergeChange, onBlur: handleMergeBlur });\n                return React.cloneElement(children, mergedProps);\n            }\n            if (Array.isArray(children)) {\n                return React.createElement(Fragment, null, ...children.map((child, index) => {\n                    if (React.isValidElement(child)) {\n                        const mergedProps = Object.assign(Object.assign({}, fieldProps), { key: child.key || index, onChange: handleMergeChange, onBlur: handleMergeBlur });\n                        return React.cloneElement(child, mergedProps);\n                    }\n                    return child;\n                }));\n            }\n            return null;\n        });\n        FieldComponent.displayName = `Field(${name})`;\n        return FieldComponent;\n    }, [\n        formCore,\n        allTouched,\n        validating,\n        validateTrigger,\n        handleFieldBlur,\n    ]);\n    const formInstance = useMemo(() => (Object.assign(Object.assign({}, formCore.formInstance), { validateFields: validateFieldsAsync, setFieldValue: formCore.setFieldValue, getFieldError: (name) => formCore.errors[name], getFieldsError: (nameList) => {\n            if (!nameList)\n                return formCore.errors;\n            const result = {};\n            nameList.forEach((name) => {\n                if (formCore.errors[name]) {\n                    result[name] = formCore.errors[name];\n                }\n            });\n            return result;\n        }, isFieldTouched: (name) => allTouched[name] || false, isFieldsTouched: (nameList, allFieldsTouched = false) => {\n            if (!nameList) {\n                return Object.keys(allTouched).some((key) => allTouched[key]);\n            }\n            if (allFieldsTouched) {\n                return nameList.every((name) => allTouched[name]);\n            }\n            return nameList.some((name) => allTouched[name]);\n        }, isFieldValidating: (name) => validating[name] || false, setFieldError: formCore.setFieldError, setFieldsError: (fieldsError) => {\n            Object.entries(fieldsError).forEach(([name, error]) => {\n                formCore.setFieldError(name, error);\n            });\n        }, setFieldTouched: (name, isTouched = true) => {\n            setExtraTouched((prev) => (Object.assign(Object.assign({}, prev), { [name]: isTouched })));\n        }, setFieldsTouched: (fieldsTouch) => {\n            setExtraTouched((prev) => (Object.assign(Object.assign({}, prev), fieldsTouch)));\n        }, resetFields: (fields) => {\n            if (!fields) {\n                formCore.resetFields();\n                setExtraTouched({});\n                setValidating({});\n            }\n            else {\n                const resetValues = {};\n                fields.forEach((field) => {\n                    resetValues[field] = initialValues[field];\n                });\n                formCore.setFieldsValue(resetValues);\n                setExtraTouched((prev) => {\n                    const newTouched = Object.assign({}, prev);\n                    fields.forEach((field) => {\n                        delete newTouched[field];\n                    });\n                    return newTouched;\n                });\n                setValidating((prev) => {\n                    const newValidating = Object.assign({}, prev);\n                    fields.forEach((field) => {\n                        delete newValidating[field];\n                    });\n                    return newValidating;\n                });\n                fields.forEach((field) => {\n                    formCore.setFieldError(field, null);\n                });\n            }\n        }, submit: (callback) => __awaiter(void 0, void 0, void 0, function* () {\n            try {\n                const validatedValues = yield validateFieldsAsync();\n                if (callback) {\n                    yield callback(validatedValues);\n                }\n                return validatedValues;\n            }\n            catch (_a) {\n                return undefined;\n            }\n        }), defineField, registerField: formCore.registerField, unregisterField: formCore.unregisterField })), [\n        formCore,\n        allTouched,\n        validating,\n        validateFieldsAsync,\n        defineField,\n        initialValues,\n        setValidating,\n    ]);\n    return [formInstance];\n};\nexport default useForm;",null],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/Form/hooks/useFormCore.d.ts

@@ -0,0 +1,3 @@
+import type { UseFormCoreConfig, UseFormCoreReturn } from '../interface';
+export declare const useFormCore: (config?: UseFormCoreConfig) => UseFormCoreReturn;
+export default useFormCore;