@gobolt/genesis 0.2.13 → 0.2.15

package/dist/node_modules/rc-field-form/es/Field.js

@@ -1,71 +1,124 @@
-import J from "../../@babel/runtime/helpers/esm/extends.js";
-import Q from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
-import K from "../../@babel/runtime/helpers/esm/regeneratorRuntime.js";
-import X from "../../@babel/runtime/helpers/esm/asyncToGenerator.js";
-import I from "../../@babel/runtime/helpers/esm/objectSpread2.js";
-import H from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
-import Z from "../../@babel/runtime/helpers/esm/classCallCheck.js";
-import ee from "../../@babel/runtime/helpers/esm/createClass.js";
-import a from "../../@babel/runtime/helpers/esm/assertThisInitialized.js";
-import re from "../../@babel/runtime/helpers/esm/inherits.js";
-import te from "../../@babel/runtime/helpers/esm/createSuper.js";
-import n from "../../@babel/runtime/helpers/esm/defineProperty.js";
-import ie from "../../rc-util/es/Children/toArray.js";
-import S from "../../rc-util/es/isEqual.js";
-import { warningOnce as G } from "../../rc-util/es/warning.js";
-import * as x from "react";
-import B, { HOOK_MARK as A } from "./FieldContext.js";
-import ne from "./ListContext.js";
-import { toArray as Y } from "./utils/typeUtil.js";
-import { validateRules as ae } from "./utils/validateUtil.js";
-import { getNamePath as W, containsNamePath as j, defaultGetValueFromEvent as oe } from "./utils/valueUtil.js";
-import se from "../../rc-util/es/utils/get.js";
-var le = ["name"], m = [];
-function z(M, $, y, f, e, P) {
-  return typeof M == "function" ? M($, y, "source" in P ? {
-    source: P.source
-  } : {}) : f !== e;
+import _extends from "../../@babel/runtime/helpers/esm/extends.js";
+import _objectWithoutProperties from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
+import _regeneratorRuntime from "../../@babel/runtime/helpers/esm/regeneratorRuntime.js";
+import _asyncToGenerator from "../../@babel/runtime/helpers/esm/asyncToGenerator.js";
+import _objectSpread2 from "../../@babel/runtime/helpers/esm/objectSpread2.js";
+import _toConsumableArray from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import _classCallCheck from "../../@babel/runtime/helpers/esm/classCallCheck.js";
+import _createClass from "../../@babel/runtime/helpers/esm/createClass.js";
+import _assertThisInitialized from "../../@babel/runtime/helpers/esm/assertThisInitialized.js";
+import _inherits from "../../@babel/runtime/helpers/esm/inherits.js";
+import _createSuper from "../../@babel/runtime/helpers/esm/createSuper.js";
+import _defineProperty from "../../@babel/runtime/helpers/esm/defineProperty.js";
+import toArray$1 from "../../rc-util/es/Children/toArray.js";
+import isEqual from "../../rc-util/es/isEqual.js";
+import { warningOnce } from "../../rc-util/es/warning.js";
+import * as React from "react";
+import Context, { HOOK_MARK } from "./FieldContext.js";
+import ListContext from "./ListContext.js";
+import { toArray } from "./utils/typeUtil.js";
+import { validateRules } from "./utils/validateUtil.js";
+import { getNamePath, containsNamePath, defaultGetValueFromEvent } from "./utils/valueUtil.js";
+import get from "../../rc-util/es/utils/get.js";
+var _excluded = ["name"];
+var EMPTY_ERRORS = [];
+function requireUpdate(shouldUpdate, prev, next, prevValue, nextValue, info) {
+  if (typeof shouldUpdate === "function") {
+    return shouldUpdate(prev, next, "source" in info ? {
+      source: info.source
+    } : {});
+  }
+  return prevValue !== nextValue;
 }
-var q = /* @__PURE__ */ function(M) {
-  re(y, M);
-  var $ = te(y);
-  function y(f) {
-    var e;
-    if (Z(this, y), e = $.call(this, f), n(a(e), "state", {
+var Field = /* @__PURE__ */ function(_React$Component) {
+  _inherits(Field2, _React$Component);
+  var _super = _createSuper(Field2);
+  function Field2(props) {
+    var _this;
+    _classCallCheck(this, Field2);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "state", {
       resetCount: 0
-    }), n(a(e), "cancelRegisterFunc", null), n(a(e), "mounted", !1), n(a(e), "touched", !1), n(a(e), "dirty", !1), n(a(e), "validatePromise", void 0), n(a(e), "prevValidating", void 0), n(a(e), "errors", m), n(a(e), "warnings", m), n(a(e), "cancelRegister", function() {
-      var r = e.props, t = r.preserve, i = r.isListField, l = r.name;
-      e.cancelRegisterFunc && e.cancelRegisterFunc(i, t, W(l)), e.cancelRegisterFunc = null;
-    }), n(a(e), "getNamePath", function() {
-      var r = e.props, t = r.name, i = r.fieldContext, l = i.prefixName, o = l === void 0 ? [] : l;
-      return t !== void 0 ? [].concat(H(o), H(t)) : [];
-    }), n(a(e), "getRules", function() {
-      var r = e.props, t = r.rules, i = t === void 0 ? [] : t, l = r.fieldContext;
-      return i.map(function(o) {
-        return typeof o == "function" ? o(l) : o;
+    });
+    _defineProperty(_assertThisInitialized(_this), "cancelRegisterFunc", null);
+    _defineProperty(_assertThisInitialized(_this), "mounted", false);
+    _defineProperty(_assertThisInitialized(_this), "touched", false);
+    _defineProperty(_assertThisInitialized(_this), "dirty", false);
+    _defineProperty(_assertThisInitialized(_this), "validatePromise", void 0);
+    _defineProperty(_assertThisInitialized(_this), "prevValidating", void 0);
+    _defineProperty(_assertThisInitialized(_this), "errors", EMPTY_ERRORS);
+    _defineProperty(_assertThisInitialized(_this), "warnings", EMPTY_ERRORS);
+    _defineProperty(_assertThisInitialized(_this), "cancelRegister", function() {
+      var _this$props = _this.props, preserve = _this$props.preserve, isListField = _this$props.isListField, name = _this$props.name;
+      if (_this.cancelRegisterFunc) {
+        _this.cancelRegisterFunc(isListField, preserve, getNamePath(name));
+      }
+      _this.cancelRegisterFunc = null;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getNamePath", function() {
+      var _this$props2 = _this.props, name = _this$props2.name, fieldContext = _this$props2.fieldContext;
+      var _fieldContext$prefixN = fieldContext.prefixName, prefixName = _fieldContext$prefixN === void 0 ? [] : _fieldContext$prefixN;
+      return name !== void 0 ? [].concat(_toConsumableArray(prefixName), _toConsumableArray(name)) : [];
+    });
+    _defineProperty(_assertThisInitialized(_this), "getRules", function() {
+      var _this$props3 = _this.props, _this$props3$rules = _this$props3.rules, rules = _this$props3$rules === void 0 ? [] : _this$props3$rules, fieldContext = _this$props3.fieldContext;
+      return rules.map(function(rule) {
+        if (typeof rule === "function") {
+          return rule(fieldContext);
+        }
+        return rule;
       });
-    }), n(a(e), "refresh", function() {
-      e.mounted && e.setState(function(r) {
-        var t = r.resetCount;
+    });
+    _defineProperty(_assertThisInitialized(_this), "refresh", function() {
+      if (!_this.mounted) return;
+      _this.setState(function(_ref) {
+        var resetCount = _ref.resetCount;
         return {
-          resetCount: t + 1
+          resetCount: resetCount + 1
         };
       });
-    }), n(a(e), "metaCache", null), n(a(e), "triggerMetaEvent", function(r) {
-      var t = e.props.onMetaChange;
-      if (t) {
-        var i = I(I({}, e.getMeta()), {}, {
-          destroy: r
+    });
+    _defineProperty(_assertThisInitialized(_this), "metaCache", null);
+    _defineProperty(_assertThisInitialized(_this), "triggerMetaEvent", function(destroy) {
+      var onMetaChange = _this.props.onMetaChange;
+      if (onMetaChange) {
+        var _meta = _objectSpread2(_objectSpread2({}, _this.getMeta()), {}, {
+          destroy
         });
-        S(e.metaCache, i) || t(i), e.metaCache = i;
-      } else
-        e.metaCache = null;
-    }), n(a(e), "onStoreChange", function(r, t, i) {
-      var l = e.props, o = l.shouldUpdate, _ = l.dependencies, O = _ === void 0 ? [] : _, v = l.onReset, k = i.store, p = e.getNamePath(), F = e.getValue(r), V = e.getValue(k), w = t && j(t, p);
-      switch (i.type === "valueUpdate" && i.source === "external" && !S(F, V) && (e.touched = !0, e.dirty = !0, e.validatePromise = null, e.errors = m, e.warnings = m, e.triggerMetaEvent()), i.type) {
+        if (!isEqual(_this.metaCache, _meta)) {
+          onMetaChange(_meta);
+        }
+        _this.metaCache = _meta;
+      } else {
+        _this.metaCache = null;
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "onStoreChange", function(prevStore, namePathList, info) {
+      var _this$props4 = _this.props, shouldUpdate = _this$props4.shouldUpdate, _this$props4$dependen = _this$props4.dependencies, dependencies = _this$props4$dependen === void 0 ? [] : _this$props4$dependen, onReset = _this$props4.onReset;
+      var store = info.store;
+      var namePath = _this.getNamePath();
+      var prevValue = _this.getValue(prevStore);
+      var curValue = _this.getValue(store);
+      var namePathMatch = namePathList && containsNamePath(namePathList, namePath);
+      if (info.type === "valueUpdate" && info.source === "external" && !isEqual(prevValue, curValue)) {
+        _this.touched = true;
+        _this.dirty = true;
+        _this.validatePromise = null;
+        _this.errors = EMPTY_ERRORS;
+        _this.warnings = EMPTY_ERRORS;
+        _this.triggerMetaEvent();
+      }
+      switch (info.type) {
         case "reset":
-          if (!t || w) {
-            e.touched = !1, e.dirty = !1, e.validatePromise = void 0, e.errors = m, e.warnings = m, e.triggerMetaEvent(), v == null || v(), e.refresh();
+          if (!namePathList || namePathMatch) {
+            _this.touched = false;
+            _this.dirty = false;
+            _this.validatePromise = void 0;
+            _this.errors = EMPTY_ERRORS;
+            _this.warnings = EMPTY_ERRORS;
+            _this.triggerMetaEvent();
+            onReset === null || onReset === void 0 || onReset();
+            _this.refresh();
             return;
           }
           break;
@@ -76,230 +129,364 @@ var q = /* @__PURE__ */ function(M) {
          * - Reset A, need clean B, C
          */
         case "remove": {
-          if (o && z(o, r, k, F, V, i)) {
-            e.reRender();
+          if (shouldUpdate && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
+            _this.reRender();
             return;
           }
           break;
         }
         case "setField": {
-          var u = i.data;
-          if (w) {
-            "touched" in u && (e.touched = u.touched), "validating" in u && !("originRCField" in u) && (e.validatePromise = u.validating ? Promise.resolve([]) : null), "errors" in u && (e.errors = u.errors || m), "warnings" in u && (e.warnings = u.warnings || m), e.dirty = !0, e.triggerMetaEvent(), e.reRender();
+          var data = info.data;
+          if (namePathMatch) {
+            if ("touched" in data) {
+              _this.touched = data.touched;
+            }
+            if ("validating" in data && !("originRCField" in data)) {
+              _this.validatePromise = data.validating ? Promise.resolve([]) : null;
+            }
+            if ("errors" in data) {
+              _this.errors = data.errors || EMPTY_ERRORS;
+            }
+            if ("warnings" in data) {
+              _this.warnings = data.warnings || EMPTY_ERRORS;
+            }
+            _this.dirty = true;
+            _this.triggerMetaEvent();
+            _this.reRender();
             return;
-          } else if ("value" in u && j(t, p, !0)) {
-            e.reRender();
+          } else if ("value" in data && containsNamePath(namePathList, namePath, true)) {
+            _this.reRender();
             return;
           }
-          if (o && !p.length && z(o, r, k, F, V, i)) {
-            e.reRender();
+          if (shouldUpdate && !namePath.length && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
+            _this.reRender();
             return;
           }
           break;
         }
         case "dependenciesUpdate": {
-          var N = O.map(W);
-          if (N.some(function(b) {
-            return j(i.relatedFields, b);
+          var dependencyList = dependencies.map(getNamePath);
+          if (dependencyList.some(function(dependency) {
+            return containsNamePath(info.relatedFields, dependency);
           })) {
-            e.reRender();
+            _this.reRender();
             return;
           }
           break;
         }
         default:
-          if (w || (!O.length || p.length || o) && z(o, r, k, F, V, i)) {
-            e.reRender();
+          if (namePathMatch || (!dependencies.length || namePath.length || shouldUpdate) && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
+            _this.reRender();
             return;
           }
           break;
       }
-      o === !0 && e.reRender();
-    }), n(a(e), "validateRules", function(r) {
-      var t = e.getNamePath(), i = e.getValue(), l = r || {}, o = l.triggerName, _ = l.validateOnly, O = _ === void 0 ? !1 : _, v = Promise.resolve().then(/* @__PURE__ */ X(/* @__PURE__ */ K().mark(function k() {
-        var p, F, V, w, u, N, b;
-        return K().wrap(function(g) {
-          for (; ; ) switch (g.prev = g.next) {
+      if (shouldUpdate === true) {
+        _this.reRender();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "validateRules", function(options) {
+      var namePath = _this.getNamePath();
+      var currentValue = _this.getValue();
+      var _ref2 = options || {}, triggerName = _ref2.triggerName, _ref2$validateOnly = _ref2.validateOnly, validateOnly = _ref2$validateOnly === void 0 ? false : _ref2$validateOnly;
+      var rootPromise = Promise.resolve().then(/* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
+        var _this$props5, _this$props5$validate, validateFirst, messageVariables, validateDebounce, filteredRules, promise;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
             case 0:
-              if (e.mounted) {
-                g.next = 2;
+              if (_this.mounted) {
+                _context.next = 2;
                 break;
               }
-              return g.abrupt("return", []);
+              return _context.abrupt("return", []);
             case 2:
-              if (p = e.props, F = p.validateFirst, V = F === void 0 ? !1 : F, w = p.messageVariables, u = p.validateDebounce, N = e.getRules(), o && (N = N.filter(function(c) {
-                return c;
-              }).filter(function(c) {
-                var C = c.validateTrigger;
-                if (!C)
-                  return !0;
-                var R = Y(C);
-                return R.includes(o);
-              })), !(u && o)) {
-                g.next = 10;
+              _this$props5 = _this.props, _this$props5$validate = _this$props5.validateFirst, validateFirst = _this$props5$validate === void 0 ? false : _this$props5$validate, messageVariables = _this$props5.messageVariables, validateDebounce = _this$props5.validateDebounce;
+              filteredRules = _this.getRules();
+              if (triggerName) {
+                filteredRules = filteredRules.filter(function(rule) {
+                  return rule;
+                }).filter(function(rule) {
+                  var validateTrigger = rule.validateTrigger;
+                  if (!validateTrigger) {
+                    return true;
+                  }
+                  var triggerList = toArray(validateTrigger);
+                  return triggerList.includes(triggerName);
+                });
+              }
+              if (!(validateDebounce && triggerName)) {
+                _context.next = 10;
                 break;
               }
-              return g.next = 8, new Promise(function(c) {
-                setTimeout(c, u);
+              _context.next = 8;
+              return new Promise(function(resolve) {
+                setTimeout(resolve, validateDebounce);
               });
             case 8:
-              if (e.validatePromise === v) {
-                g.next = 10;
+              if (!(_this.validatePromise !== rootPromise)) {
+                _context.next = 10;
                 break;
               }
-              return g.abrupt("return", []);
+              return _context.abrupt("return", []);
             case 10:
-              return b = ae(t, i, N, r, V, w), b.catch(function(c) {
-                return c;
+              promise = validateRules(namePath, currentValue, filteredRules, options, validateFirst, messageVariables);
+              promise.catch(function(e) {
+                return e;
               }).then(function() {
-                var c = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : m;
-                if (e.validatePromise === v) {
-                  var C;
-                  e.validatePromise = null;
-                  var R = [], U = [];
-                  (C = c.forEach) === null || C === void 0 || C.call(c, function(s) {
-                    var T = s.rule.warningOnly, E = s.errors, L = E === void 0 ? m : E;
-                    T ? U.push.apply(U, H(L)) : R.push.apply(R, H(L));
-                  }), e.errors = R, e.warnings = U, e.triggerMetaEvent(), e.reRender();
+                var ruleErrors = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : EMPTY_ERRORS;
+                if (_this.validatePromise === rootPromise) {
+                  var _ruleErrors$forEach;
+                  _this.validatePromise = null;
+                  var nextErrors = [];
+                  var nextWarnings = [];
+                  (_ruleErrors$forEach = ruleErrors.forEach) === null || _ruleErrors$forEach === void 0 || _ruleErrors$forEach.call(ruleErrors, function(_ref4) {
+                    var warningOnly = _ref4.rule.warningOnly, _ref4$errors = _ref4.errors, errors = _ref4$errors === void 0 ? EMPTY_ERRORS : _ref4$errors;
+                    if (warningOnly) {
+                      nextWarnings.push.apply(nextWarnings, _toConsumableArray(errors));
+                    } else {
+                      nextErrors.push.apply(nextErrors, _toConsumableArray(errors));
+                    }
+                  });
+                  _this.errors = nextErrors;
+                  _this.warnings = nextWarnings;
+                  _this.triggerMetaEvent();
+                  _this.reRender();
                 }
-              }), g.abrupt("return", b);
+              });
+              return _context.abrupt("return", promise);
             case 13:
             case "end":
-              return g.stop();
+              return _context.stop();
           }
-        }, k);
+        }, _callee);
       })));
-      return O || (e.validatePromise = v, e.dirty = !0, e.errors = m, e.warnings = m, e.triggerMetaEvent(), e.reRender()), v;
-    }), n(a(e), "isFieldValidating", function() {
-      return !!e.validatePromise;
-    }), n(a(e), "isFieldTouched", function() {
-      return e.touched;
-    }), n(a(e), "isFieldDirty", function() {
-      if (e.dirty || e.props.initialValue !== void 0)
-        return !0;
-      var r = e.props.fieldContext, t = r.getInternalHooks(A), i = t.getInitialValue;
-      return i(e.getNamePath()) !== void 0;
-    }), n(a(e), "getErrors", function() {
-      return e.errors;
-    }), n(a(e), "getWarnings", function() {
-      return e.warnings;
-    }), n(a(e), "isListField", function() {
-      return e.props.isListField;
-    }), n(a(e), "isList", function() {
-      return e.props.isList;
-    }), n(a(e), "isPreserve", function() {
-      return e.props.preserve;
-    }), n(a(e), "getMeta", function() {
-      e.prevValidating = e.isFieldValidating();
-      var r = {
-        touched: e.isFieldTouched(),
-        validating: e.prevValidating,
-        errors: e.errors,
-        warnings: e.warnings,
-        name: e.getNamePath(),
-        validated: e.validatePromise === null
+      if (validateOnly) {
+        return rootPromise;
+      }
+      _this.validatePromise = rootPromise;
+      _this.dirty = true;
+      _this.errors = EMPTY_ERRORS;
+      _this.warnings = EMPTY_ERRORS;
+      _this.triggerMetaEvent();
+      _this.reRender();
+      return rootPromise;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isFieldValidating", function() {
+      return !!_this.validatePromise;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isFieldTouched", function() {
+      return _this.touched;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isFieldDirty", function() {
+      if (_this.dirty || _this.props.initialValue !== void 0) {
+        return true;
+      }
+      var fieldContext = _this.props.fieldContext;
+      var _fieldContext$getInte = fieldContext.getInternalHooks(HOOK_MARK), getInitialValue = _fieldContext$getInte.getInitialValue;
+      if (getInitialValue(_this.getNamePath()) !== void 0) {
+        return true;
+      }
+      return false;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getErrors", function() {
+      return _this.errors;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getWarnings", function() {
+      return _this.warnings;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isListField", function() {
+      return _this.props.isListField;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isList", function() {
+      return _this.props.isList;
+    });
+    _defineProperty(_assertThisInitialized(_this), "isPreserve", function() {
+      return _this.props.preserve;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getMeta", function() {
+      _this.prevValidating = _this.isFieldValidating();
+      var meta = {
+        touched: _this.isFieldTouched(),
+        validating: _this.prevValidating,
+        errors: _this.errors,
+        warnings: _this.warnings,
+        name: _this.getNamePath(),
+        validated: _this.validatePromise === null
       };
-      return r;
-    }), n(a(e), "getOnlyChild", function(r) {
-      if (typeof r == "function") {
-        var t = e.getMeta();
-        return I(I({}, e.getOnlyChild(r(e.getControlled(), t, e.props.fieldContext))), {}, {
-          isFunction: !0
+      return meta;
+    });
+    _defineProperty(_assertThisInitialized(_this), "getOnlyChild", function(children) {
+      if (typeof children === "function") {
+        var _meta2 = _this.getMeta();
+        return _objectSpread2(_objectSpread2({}, _this.getOnlyChild(children(_this.getControlled(), _meta2, _this.props.fieldContext))), {}, {
+          isFunction: true
         });
       }
-      var i = ie(r);
-      return i.length !== 1 || !/* @__PURE__ */ x.isValidElement(i[0]) ? {
-        child: i,
-        isFunction: !1
-      } : {
-        child: i[0],
-        isFunction: !1
+      var childList = toArray$1(children);
+      if (childList.length !== 1 || !/* @__PURE__ */ React.isValidElement(childList[0])) {
+        return {
+          child: childList,
+          isFunction: false
+        };
+      }
+      return {
+        child: childList[0],
+        isFunction: false
       };
-    }), n(a(e), "getValue", function(r) {
-      var t = e.props.fieldContext.getFieldsValue, i = e.getNamePath();
-      return se(r || t(!0), i);
-    }), n(a(e), "getControlled", function() {
-      var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, t = e.props, i = t.name, l = t.trigger, o = t.validateTrigger, _ = t.getValueFromEvent, O = t.normalize, v = t.valuePropName, k = t.getValueProps, p = t.fieldContext, F = o !== void 0 ? o : p.validateTrigger, V = e.getNamePath(), w = p.getInternalHooks, u = p.getFieldsValue, N = w(A), b = N.dispatch, D = e.getValue(), g = k || function(s) {
-        return n({}, v, s);
-      }, c = r[l], C = i !== void 0 ? g(D) : {};
-      process.env.NODE_ENV !== "production" && C && Object.keys(C).forEach(function(s) {
-        G(typeof C[s] != "function", "It's not recommended to generate dynamic function prop by `getValueProps`. Please pass it to child component directly (prop: ".concat(s, ")"));
-      });
-      var R = I(I({}, r), C);
-      R[l] = function() {
-        e.touched = !0, e.dirty = !0, e.triggerMetaEvent();
-        for (var s, T = arguments.length, E = new Array(T), L = 0; L < T; L++)
-          E[L] = arguments[L];
-        _ ? s = _.apply(void 0, E) : s = oe.apply(void 0, [v].concat(E)), O && (s = O(s, D, u(!0))), s !== D && b({
-          type: "updateValue",
-          namePath: V,
-          value: s
-        }), c && c.apply(void 0, E);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getValue", function(store) {
+      var getFieldsValue = _this.props.fieldContext.getFieldsValue;
+      var namePath = _this.getNamePath();
+      return get(store || getFieldsValue(true), namePath);
+    });
+    _defineProperty(_assertThisInitialized(_this), "getControlled", function() {
+      var childProps = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      var _this$props6 = _this.props, name = _this$props6.name, trigger = _this$props6.trigger, validateTrigger = _this$props6.validateTrigger, getValueFromEvent = _this$props6.getValueFromEvent, normalize = _this$props6.normalize, valuePropName = _this$props6.valuePropName, getValueProps = _this$props6.getValueProps, fieldContext = _this$props6.fieldContext;
+      var mergedValidateTrigger = validateTrigger !== void 0 ? validateTrigger : fieldContext.validateTrigger;
+      var namePath = _this.getNamePath();
+      var getInternalHooks2 = fieldContext.getInternalHooks, getFieldsValue = fieldContext.getFieldsValue;
+      var _getInternalHooks = getInternalHooks2(HOOK_MARK), dispatch = _getInternalHooks.dispatch;
+      var value = _this.getValue();
+      var mergedGetValueProps = getValueProps || function(val) {
+        return _defineProperty({}, valuePropName, val);
       };
-      var U = Y(F || []);
-      return U.forEach(function(s) {
-        var T = R[s];
-        R[s] = function() {
-          T && T.apply(void 0, arguments);
-          var E = e.props.rules;
-          E && E.length && b({
-            type: "validateField",
-            namePath: V,
-            triggerName: s
+      var originTriggerFunc = childProps[trigger];
+      var valueProps = name !== void 0 ? mergedGetValueProps(value) : {};
+      if (process.env.NODE_ENV !== "production" && valueProps) {
+        Object.keys(valueProps).forEach(function(key) {
+          warningOnce(typeof valueProps[key] !== "function", "It's not recommended to generate dynamic function prop by `getValueProps`. Please pass it to child component directly (prop: ".concat(key, ")"));
+        });
+      }
+      var control = _objectSpread2(_objectSpread2({}, childProps), valueProps);
+      control[trigger] = function() {
+        _this.touched = true;
+        _this.dirty = true;
+        _this.triggerMetaEvent();
+        var newValue;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        if (getValueFromEvent) {
+          newValue = getValueFromEvent.apply(void 0, args);
+        } else {
+          newValue = defaultGetValueFromEvent.apply(void 0, [valuePropName].concat(args));
+        }
+        if (normalize) {
+          newValue = normalize(newValue, value, getFieldsValue(true));
+        }
+        if (newValue !== value) {
+          dispatch({
+            type: "updateValue",
+            namePath,
+            value: newValue
           });
+        }
+        if (originTriggerFunc) {
+          originTriggerFunc.apply(void 0, args);
+        }
+      };
+      var validateTriggerList = toArray(mergedValidateTrigger || []);
+      validateTriggerList.forEach(function(triggerName) {
+        var originTrigger = control[triggerName];
+        control[triggerName] = function() {
+          if (originTrigger) {
+            originTrigger.apply(void 0, arguments);
+          }
+          var rules = _this.props.rules;
+          if (rules && rules.length) {
+            dispatch({
+              type: "validateField",
+              namePath,
+              triggerName
+            });
+          }
         };
-      }), R;
-    }), f.fieldContext) {
-      var P = f.fieldContext.getInternalHooks, h = P(A), d = h.initEntityValue;
-      d(a(e));
+      });
+      return control;
+    });
+    if (props.fieldContext) {
+      var getInternalHooks = props.fieldContext.getInternalHooks;
+      var _getInternalHooks2 = getInternalHooks(HOOK_MARK), initEntityValue = _getInternalHooks2.initEntityValue;
+      initEntityValue(_assertThisInitialized(_this));
     }
-    return e;
+    return _this;
   }
-  return ee(y, [{
+  _createClass(Field2, [{
     key: "componentDidMount",
-    value: function() {
-      var e = this.props, P = e.shouldUpdate, h = e.fieldContext;
-      if (this.mounted = !0, h) {
-        var d = h.getInternalHooks, r = d(A), t = r.registerField;
-        this.cancelRegisterFunc = t(this);
+    value: function componentDidMount() {
+      var _this$props7 = this.props, shouldUpdate = _this$props7.shouldUpdate, fieldContext = _this$props7.fieldContext;
+      this.mounted = true;
+      if (fieldContext) {
+        var getInternalHooks = fieldContext.getInternalHooks;
+        var _getInternalHooks3 = getInternalHooks(HOOK_MARK), registerField = _getInternalHooks3.registerField;
+        this.cancelRegisterFunc = registerField(this);
+      }
+      if (shouldUpdate === true) {
+        this.reRender();
       }
-      P === !0 && this.reRender();
     }
   }, {
     key: "componentWillUnmount",
-    value: function() {
-      this.cancelRegister(), this.triggerMetaEvent(!0), this.mounted = !1;
+    value: function componentWillUnmount() {
+      this.cancelRegister();
+      this.triggerMetaEvent(true);
+      this.mounted = false;
     }
   }, {
     key: "reRender",
-    value: function() {
-      this.mounted && this.forceUpdate();
+    value: function reRender() {
+      if (!this.mounted) return;
+      this.forceUpdate();
     }
   }, {
     key: "render",
-    value: function() {
-      var e = this.state.resetCount, P = this.props.children, h = this.getOnlyChild(P), d = h.child, r = h.isFunction, t;
-      return r ? t = d : /* @__PURE__ */ x.isValidElement(d) ? t = /* @__PURE__ */ x.cloneElement(d, this.getControlled(d.props)) : (G(!d, "`children` of Field is not validate ReactElement."), t = d), /* @__PURE__ */ x.createElement(x.Fragment, {
-        key: e
-      }, t);
+    value: function render() {
+      var resetCount = this.state.resetCount;
+      var children = this.props.children;
+      var _this$getOnlyChild = this.getOnlyChild(children), child = _this$getOnlyChild.child, isFunction = _this$getOnlyChild.isFunction;
+      var returnChildNode;
+      if (isFunction) {
+        returnChildNode = child;
+      } else if (/* @__PURE__ */ React.isValidElement(child)) {
+        returnChildNode = /* @__PURE__ */ React.cloneElement(child, this.getControlled(child.props));
+      } else {
+        warningOnce(!child, "`children` of Field is not validate ReactElement.");
+        returnChildNode = child;
+      }
+      return /* @__PURE__ */ React.createElement(React.Fragment, {
+        key: resetCount
+      }, returnChildNode);
     }
-  }]), y;
-}(x.Component);
-n(q, "contextType", B);
-n(q, "defaultProps", {
+  }]);
+  return Field2;
+}(React.Component);
+_defineProperty(Field, "contextType", Context);
+_defineProperty(Field, "defaultProps", {
   trigger: "onChange",
   valuePropName: "value"
 });
-function be(M) {
-  var $, y = M.name, f = Q(M, le), e = x.useContext(B), P = x.useContext(ne), h = y !== void 0 ? W(y) : void 0, d = ($ = f.isListField) !== null && $ !== void 0 ? $ : !!P, r = "keep";
-  return d || (r = "_".concat((h || []).join("_"))), process.env.NODE_ENV !== "production" && f.preserve === !1 && d && h.length <= 1 && G(!1, "`preserve` should not apply on Form.List fields."), /* @__PURE__ */ x.createElement(q, J({
-    key: r,
-    name: h,
-    isListField: d
-  }, f, {
-    fieldContext: e
+function WrapperField(_ref6) {
+  var _restProps$isListFiel;
+  var name = _ref6.name, restProps = _objectWithoutProperties(_ref6, _excluded);
+  var fieldContext = React.useContext(Context);
+  var listContext = React.useContext(ListContext);
+  var namePath = name !== void 0 ? getNamePath(name) : void 0;
+  var isMergedListField = (_restProps$isListFiel = restProps.isListField) !== null && _restProps$isListFiel !== void 0 ? _restProps$isListFiel : !!listContext;
+  var key = "keep";
+  if (!isMergedListField) {
+    key = "_".concat((namePath || []).join("_"));
+  }
+  if (process.env.NODE_ENV !== "production" && restProps.preserve === false && isMergedListField && namePath.length <= 1) {
+    warningOnce(false, "`preserve` should not apply on Form.List fields.");
+  }
+  return /* @__PURE__ */ React.createElement(Field, _extends({
+    key,
+    name: namePath,
+    isListField: isMergedListField
+  }, restProps, {
+    fieldContext
   }));
 }
 export {
-  be as default
+  WrapperField as default
 };