@gobolt/genesis 0.2.13 → 0.2.15

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

@@ -1,543 +1,776 @@
-import H from "../../@babel/runtime/helpers/esm/slicedToArray.js";
-import E from "../../@babel/runtime/helpers/esm/objectSpread2.js";
-import j from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
-import V from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
-import x from "../../@babel/runtime/helpers/esm/typeof.js";
-import K from "../../@babel/runtime/helpers/esm/createClass.js";
-import z from "../../@babel/runtime/helpers/esm/classCallCheck.js";
-import a from "../../@babel/runtime/helpers/esm/defineProperty.js";
-import P, { merge as L } from "../../rc-util/es/utils/set.js";
-import { warningOnce as U } from "../../rc-util/es/warning.js";
-import * as _ from "react";
-import { HOOK_MARK as B } from "./FieldContext.js";
-import { allPromiseFinish as $ } from "./utils/asyncUtil.js";
-import { defaultValidateMessages as q } from "./utils/messages.js";
-import N from "./utils/NameMap.js";
-import { getNamePath as g, cloneByNamePathList as D, containsNamePath as W, matchNamePath as G } from "./utils/valueUtil.js";
-import T from "../../rc-util/es/utils/get.js";
-var J = ["name"], Q = /* @__PURE__ */ K(function k(y) {
-  var e = this;
-  z(this, k), a(this, "formHooked", !1), a(this, "forceRootUpdate", void 0), a(this, "subscribable", !0), a(this, "store", {}), a(this, "fieldEntities", []), a(this, "initialValues", {}), a(this, "callbacks", {}), a(this, "validateMessages", null), a(this, "preserve", null), a(this, "lastValidatePromise", null), a(this, "getForm", function() {
+import _slicedToArray from "../../@babel/runtime/helpers/esm/slicedToArray.js";
+import _objectSpread2 from "../../@babel/runtime/helpers/esm/objectSpread2.js";
+import _objectWithoutProperties from "../../@babel/runtime/helpers/esm/objectWithoutProperties.js";
+import _toConsumableArray from "../../@babel/runtime/helpers/esm/toConsumableArray.js";
+import _typeof from "../../@babel/runtime/helpers/esm/typeof.js";
+import _createClass from "../../@babel/runtime/helpers/esm/createClass.js";
+import _classCallCheck from "../../@babel/runtime/helpers/esm/classCallCheck.js";
+import _defineProperty from "../../@babel/runtime/helpers/esm/defineProperty.js";
+import set, { merge } from "../../rc-util/es/utils/set.js";
+import { warningOnce } from "../../rc-util/es/warning.js";
+import * as React from "react";
+import { HOOK_MARK } from "./FieldContext.js";
+import { allPromiseFinish } from "./utils/asyncUtil.js";
+import { defaultValidateMessages } from "./utils/messages.js";
+import NameMap from "./utils/NameMap.js";
+import { getNamePath, cloneByNamePathList, containsNamePath, matchNamePath } from "./utils/valueUtil.js";
+import get from "../../rc-util/es/utils/get.js";
+var _excluded = ["name"];
+var FormStore = /* @__PURE__ */ _createClass(function FormStore2(forceRootUpdate) {
+  var _this = this;
+  _classCallCheck(this, FormStore2);
+  _defineProperty(this, "formHooked", false);
+  _defineProperty(this, "forceRootUpdate", void 0);
+  _defineProperty(this, "subscribable", true);
+  _defineProperty(this, "store", {});
+  _defineProperty(this, "fieldEntities", []);
+  _defineProperty(this, "initialValues", {});
+  _defineProperty(this, "callbacks", {});
+  _defineProperty(this, "validateMessages", null);
+  _defineProperty(this, "preserve", null);
+  _defineProperty(this, "lastValidatePromise", null);
+  _defineProperty(this, "getForm", function() {
     return {
-      getFieldValue: e.getFieldValue,
-      getFieldsValue: e.getFieldsValue,
-      getFieldError: e.getFieldError,
-      getFieldWarning: e.getFieldWarning,
-      getFieldsError: e.getFieldsError,
-      isFieldsTouched: e.isFieldsTouched,
-      isFieldTouched: e.isFieldTouched,
-      isFieldValidating: e.isFieldValidating,
-      isFieldsValidating: e.isFieldsValidating,
-      resetFields: e.resetFields,
-      setFields: e.setFields,
-      setFieldValue: e.setFieldValue,
-      setFieldsValue: e.setFieldsValue,
-      validateFields: e.validateFields,
-      submit: e.submit,
-      _init: !0,
-      getInternalHooks: e.getInternalHooks
+      getFieldValue: _this.getFieldValue,
+      getFieldsValue: _this.getFieldsValue,
+      getFieldError: _this.getFieldError,
+      getFieldWarning: _this.getFieldWarning,
+      getFieldsError: _this.getFieldsError,
+      isFieldsTouched: _this.isFieldsTouched,
+      isFieldTouched: _this.isFieldTouched,
+      isFieldValidating: _this.isFieldValidating,
+      isFieldsValidating: _this.isFieldsValidating,
+      resetFields: _this.resetFields,
+      setFields: _this.setFields,
+      setFieldValue: _this.setFieldValue,
+      setFieldsValue: _this.setFieldsValue,
+      validateFields: _this.validateFields,
+      submit: _this.submit,
+      _init: true,
+      getInternalHooks: _this.getInternalHooks
     };
-  }), a(this, "getInternalHooks", function(t) {
-    return t === B ? (e.formHooked = !0, {
-      dispatch: e.dispatch,
-      initEntityValue: e.initEntityValue,
-      registerField: e.registerField,
-      useSubscribe: e.useSubscribe,
-      setInitialValues: e.setInitialValues,
-      destroyForm: e.destroyForm,
-      setCallbacks: e.setCallbacks,
-      setValidateMessages: e.setValidateMessages,
-      getFields: e.getFields,
-      setPreserve: e.setPreserve,
-      getInitialValue: e.getInitialValue,
-      registerWatch: e.registerWatch
-    }) : (U(!1, "`getInternalHooks` is internal usage. Should not call directly."), null);
-  }), a(this, "useSubscribe", function(t) {
-    e.subscribable = t;
-  }), a(this, "prevWithoutPreserves", null), a(this, "setInitialValues", function(t, i) {
-    if (e.initialValues = t || {}, i) {
-      var r, n = L(t, e.store);
-      (r = e.prevWithoutPreserves) === null || r === void 0 || r.map(function(l) {
-        var s = l.key;
-        n = P(n, s, T(t, s));
-      }), e.prevWithoutPreserves = null, e.updateStore(n);
+  });
+  _defineProperty(this, "getInternalHooks", function(key) {
+    if (key === HOOK_MARK) {
+      _this.formHooked = true;
+      return {
+        dispatch: _this.dispatch,
+        initEntityValue: _this.initEntityValue,
+        registerField: _this.registerField,
+        useSubscribe: _this.useSubscribe,
+        setInitialValues: _this.setInitialValues,
+        destroyForm: _this.destroyForm,
+        setCallbacks: _this.setCallbacks,
+        setValidateMessages: _this.setValidateMessages,
+        getFields: _this.getFields,
+        setPreserve: _this.setPreserve,
+        getInitialValue: _this.getInitialValue,
+        registerWatch: _this.registerWatch
+      };
+    }
+    warningOnce(false, "`getInternalHooks` is internal usage. Should not call directly.");
+    return null;
+  });
+  _defineProperty(this, "useSubscribe", function(subscribable) {
+    _this.subscribable = subscribable;
+  });
+  _defineProperty(this, "prevWithoutPreserves", null);
+  _defineProperty(this, "setInitialValues", function(initialValues, init) {
+    _this.initialValues = initialValues || {};
+    if (init) {
+      var _this$prevWithoutPres;
+      var nextStore = merge(initialValues, _this.store);
+      (_this$prevWithoutPres = _this.prevWithoutPreserves) === null || _this$prevWithoutPres === void 0 || _this$prevWithoutPres.map(function(_ref) {
+        var namePath = _ref.key;
+        nextStore = set(nextStore, namePath, get(initialValues, namePath));
+      });
+      _this.prevWithoutPreserves = null;
+      _this.updateStore(nextStore);
     }
-  }), a(this, "destroyForm", function(t) {
-    if (t)
-      e.updateStore({});
-    else {
-      var i = new N();
-      e.getFieldEntities(!0).forEach(function(r) {
-        e.isMergedPreserve(r.isPreserve()) || i.set(r.getNamePath(), !0);
-      }), e.prevWithoutPreserves = i;
+  });
+  _defineProperty(this, "destroyForm", function(clearOnDestroy) {
+    if (clearOnDestroy) {
+      _this.updateStore({});
+    } else {
+      var prevWithoutPreserves = new NameMap();
+      _this.getFieldEntities(true).forEach(function(entity) {
+        if (!_this.isMergedPreserve(entity.isPreserve())) {
+          prevWithoutPreserves.set(entity.getNamePath(), true);
+        }
+      });
+      _this.prevWithoutPreserves = prevWithoutPreserves;
     }
-  }), a(this, "getInitialValue", function(t) {
-    var i = T(e.initialValues, t);
-    return t.length ? L(i) : i;
-  }), a(this, "setCallbacks", function(t) {
-    e.callbacks = t;
-  }), a(this, "setValidateMessages", function(t) {
-    e.validateMessages = t;
-  }), a(this, "setPreserve", function(t) {
-    e.preserve = t;
-  }), a(this, "watchList", []), a(this, "registerWatch", function(t) {
-    return e.watchList.push(t), function() {
-      e.watchList = e.watchList.filter(function(i) {
-        return i !== t;
+  });
+  _defineProperty(this, "getInitialValue", function(namePath) {
+    var initValue = get(_this.initialValues, namePath);
+    return namePath.length ? merge(initValue) : initValue;
+  });
+  _defineProperty(this, "setCallbacks", function(callbacks) {
+    _this.callbacks = callbacks;
+  });
+  _defineProperty(this, "setValidateMessages", function(validateMessages) {
+    _this.validateMessages = validateMessages;
+  });
+  _defineProperty(this, "setPreserve", function(preserve) {
+    _this.preserve = preserve;
+  });
+  _defineProperty(this, "watchList", []);
+  _defineProperty(this, "registerWatch", function(callback) {
+    _this.watchList.push(callback);
+    return function() {
+      _this.watchList = _this.watchList.filter(function(fn) {
+        return fn !== callback;
       });
     };
-  }), a(this, "notifyWatch", function() {
-    var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
-    if (e.watchList.length) {
-      var i = e.getFieldsValue(), r = e.getFieldsValue(!0);
-      e.watchList.forEach(function(n) {
-        n(i, r, t);
+  });
+  _defineProperty(this, "notifyWatch", function() {
+    var namePath = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    if (_this.watchList.length) {
+      var values = _this.getFieldsValue();
+      var allValues = _this.getFieldsValue(true);
+      _this.watchList.forEach(function(callback) {
+        callback(values, allValues, namePath);
       });
     }
-  }), a(this, "timeoutId", null), a(this, "warningUnhooked", function() {
-    process.env.NODE_ENV !== "production" && !e.timeoutId && typeof window < "u" && (e.timeoutId = setTimeout(function() {
-      e.timeoutId = null, e.formHooked || U(!1, "Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?");
-    }));
-  }), a(this, "updateStore", function(t) {
-    e.store = t;
-  }), a(this, "getFieldEntities", function() {
-    var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
-    return t ? e.fieldEntities.filter(function(i) {
-      return i.getNamePath().length;
-    }) : e.fieldEntities;
-  }), a(this, "getFieldsMap", function() {
-    var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1, i = new N();
-    return e.getFieldEntities(t).forEach(function(r) {
-      var n = r.getNamePath();
-      i.set(n, r);
-    }), i;
-  }), a(this, "getFieldEntitiesForNamePathList", function(t) {
-    if (!t)
-      return e.getFieldEntities(!0);
-    var i = e.getFieldsMap(!0);
-    return t.map(function(r) {
-      var n = g(r);
-      return i.get(n) || {
-        INVALIDATE_NAME_PATH: g(r)
+  });
+  _defineProperty(this, "timeoutId", null);
+  _defineProperty(this, "warningUnhooked", function() {
+    if (process.env.NODE_ENV !== "production" && !_this.timeoutId && typeof window !== "undefined") {
+      _this.timeoutId = setTimeout(function() {
+        _this.timeoutId = null;
+        if (!_this.formHooked) {
+          warningOnce(false, "Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?");
+        }
+      });
+    }
+  });
+  _defineProperty(this, "updateStore", function(nextStore) {
+    _this.store = nextStore;
+  });
+  _defineProperty(this, "getFieldEntities", function() {
+    var pure = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+    if (!pure) {
+      return _this.fieldEntities;
+    }
+    return _this.fieldEntities.filter(function(field) {
+      return field.getNamePath().length;
+    });
+  });
+  _defineProperty(this, "getFieldsMap", function() {
+    var pure = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+    var cache = new NameMap();
+    _this.getFieldEntities(pure).forEach(function(field) {
+      var namePath = field.getNamePath();
+      cache.set(namePath, field);
+    });
+    return cache;
+  });
+  _defineProperty(this, "getFieldEntitiesForNamePathList", function(nameList) {
+    if (!nameList) {
+      return _this.getFieldEntities(true);
+    }
+    var cache = _this.getFieldsMap(true);
+    return nameList.map(function(name) {
+      var namePath = getNamePath(name);
+      return cache.get(namePath) || {
+        INVALIDATE_NAME_PATH: getNamePath(name)
       };
     });
-  }), a(this, "getFieldsValue", function(t, i) {
-    e.warningUnhooked();
-    var r, n, l;
-    if (t === !0 || Array.isArray(t) ? (r = t, n = i) : t && x(t) === "object" && (l = t.strict, n = t.filter), r === !0 && !n)
-      return e.store;
-    var s = e.getFieldEntitiesForNamePathList(Array.isArray(r) ? r : null), o = [];
-    return s.forEach(function(u) {
-      var d, f, F = "INVALIDATE_NAME_PATH" in u ? u.INVALIDATE_NAME_PATH : u.getNamePath();
-      if (l) {
-        var m, c;
-        if ((m = (c = u).isList) !== null && m !== void 0 && m.call(c))
+  });
+  _defineProperty(this, "getFieldsValue", function(nameList, filterFunc) {
+    _this.warningUnhooked();
+    var mergedNameList;
+    var mergedFilterFunc;
+    var mergedStrict;
+    if (nameList === true || Array.isArray(nameList)) {
+      mergedNameList = nameList;
+      mergedFilterFunc = filterFunc;
+    } else if (nameList && _typeof(nameList) === "object") {
+      mergedStrict = nameList.strict;
+      mergedFilterFunc = nameList.filter;
+    }
+    if (mergedNameList === true && !mergedFilterFunc) {
+      return _this.store;
+    }
+    var fieldEntities = _this.getFieldEntitiesForNamePathList(Array.isArray(mergedNameList) ? mergedNameList : null);
+    var filteredNameList = [];
+    fieldEntities.forEach(function(entity) {
+      var _isListField, _ref3;
+      var namePath = "INVALIDATE_NAME_PATH" in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
+      if (mergedStrict) {
+        var _isList, _ref2;
+        if ((_isList = (_ref2 = entity).isList) !== null && _isList !== void 0 && _isList.call(_ref2)) {
           return;
-      } else if (!r && (d = (f = u).isListField) !== null && d !== void 0 && d.call(f))
+        }
+      } else if (!mergedNameList && (_isListField = (_ref3 = entity).isListField) !== null && _isListField !== void 0 && _isListField.call(_ref3)) {
         return;
-      if (!n)
-        o.push(F);
-      else {
-        var v = "getMeta" in u ? u.getMeta() : null;
-        n(v) && o.push(F);
       }
-    }), D(e.store, o.map(g));
-  }), a(this, "getFieldValue", function(t) {
-    e.warningUnhooked();
-    var i = g(t);
-    return T(e.store, i);
-  }), a(this, "getFieldsError", function(t) {
-    e.warningUnhooked();
-    var i = e.getFieldEntitiesForNamePathList(t);
-    return i.map(function(r, n) {
-      return r && !("INVALIDATE_NAME_PATH" in r) ? {
-        name: r.getNamePath(),
-        errors: r.getErrors(),
-        warnings: r.getWarnings()
-      } : {
-        name: g(t[n]),
+      if (!mergedFilterFunc) {
+        filteredNameList.push(namePath);
+      } else {
+        var meta = "getMeta" in entity ? entity.getMeta() : null;
+        if (mergedFilterFunc(meta)) {
+          filteredNameList.push(namePath);
+        }
+      }
+    });
+    return cloneByNamePathList(_this.store, filteredNameList.map(getNamePath));
+  });
+  _defineProperty(this, "getFieldValue", function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    return get(_this.store, namePath);
+  });
+  _defineProperty(this, "getFieldsError", function(nameList) {
+    _this.warningUnhooked();
+    var fieldEntities = _this.getFieldEntitiesForNamePathList(nameList);
+    return fieldEntities.map(function(entity, index) {
+      if (entity && !("INVALIDATE_NAME_PATH" in entity)) {
+        return {
+          name: entity.getNamePath(),
+          errors: entity.getErrors(),
+          warnings: entity.getWarnings()
+        };
+      }
+      return {
+        name: getNamePath(nameList[index]),
         errors: [],
         warnings: []
       };
     });
-  }), a(this, "getFieldError", function(t) {
-    e.warningUnhooked();
-    var i = g(t), r = e.getFieldsError([i])[0];
-    return r.errors;
-  }), a(this, "getFieldWarning", function(t) {
-    e.warningUnhooked();
-    var i = g(t), r = e.getFieldsError([i])[0];
-    return r.warnings;
-  }), a(this, "isFieldsTouched", function() {
-    e.warningUnhooked();
-    for (var t = arguments.length, i = new Array(t), r = 0; r < t; r++)
-      i[r] = arguments[r];
-    var n = i[0], l = i[1], s, o = !1;
-    i.length === 0 ? s = null : i.length === 1 ? Array.isArray(n) ? (s = n.map(g), o = !1) : (s = null, o = n) : (s = n.map(g), o = l);
-    var u = e.getFieldEntities(!0), d = function(v) {
-      return v.isFieldTouched();
+  });
+  _defineProperty(this, "getFieldError", function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    var fieldError = _this.getFieldsError([namePath])[0];
+    return fieldError.errors;
+  });
+  _defineProperty(this, "getFieldWarning", function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    var fieldError = _this.getFieldsError([namePath])[0];
+    return fieldError.warnings;
+  });
+  _defineProperty(this, "isFieldsTouched", function() {
+    _this.warningUnhooked();
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var arg0 = args[0], arg1 = args[1];
+    var namePathList;
+    var isAllFieldsTouched = false;
+    if (args.length === 0) {
+      namePathList = null;
+    } else if (args.length === 1) {
+      if (Array.isArray(arg0)) {
+        namePathList = arg0.map(getNamePath);
+        isAllFieldsTouched = false;
+      } else {
+        namePathList = null;
+        isAllFieldsTouched = arg0;
+      }
+    } else {
+      namePathList = arg0.map(getNamePath);
+      isAllFieldsTouched = arg1;
+    }
+    var fieldEntities = _this.getFieldEntities(true);
+    var isFieldTouched = function isFieldTouched2(field) {
+      return field.isFieldTouched();
     };
-    if (!s)
-      return o ? u.every(function(c) {
-        return d(c) || c.isList();
-      }) : u.some(d);
-    var f = new N();
-    s.forEach(function(c) {
-      f.set(c, []);
-    }), u.forEach(function(c) {
-      var v = c.getNamePath();
-      s.forEach(function(I) {
-        I.every(function(h, p) {
-          return v[p] === h;
-        }) && f.update(I, function(h) {
-          return [].concat(V(h), [c]);
-        });
+    if (!namePathList) {
+      return isAllFieldsTouched ? fieldEntities.every(function(entity) {
+        return isFieldTouched(entity) || entity.isList();
+      }) : fieldEntities.some(isFieldTouched);
+    }
+    var map = new NameMap();
+    namePathList.forEach(function(shortNamePath) {
+      map.set(shortNamePath, []);
+    });
+    fieldEntities.forEach(function(field) {
+      var fieldNamePath = field.getNamePath();
+      namePathList.forEach(function(shortNamePath) {
+        if (shortNamePath.every(function(nameUnit, i) {
+          return fieldNamePath[i] === nameUnit;
+        })) {
+          map.update(shortNamePath, function(list) {
+            return [].concat(_toConsumableArray(list), [field]);
+          });
+        }
       });
     });
-    var F = function(v) {
-      return v.some(d);
-    }, m = f.map(function(c) {
-      var v = c.value;
-      return v;
+    var isNamePathListTouched = function isNamePathListTouched2(entities) {
+      return entities.some(isFieldTouched);
+    };
+    var namePathListEntities = map.map(function(_ref4) {
+      var value = _ref4.value;
+      return value;
     });
-    return o ? m.every(F) : m.some(F);
-  }), a(this, "isFieldTouched", function(t) {
-    return e.warningUnhooked(), e.isFieldsTouched([t]);
-  }), a(this, "isFieldsValidating", function(t) {
-    e.warningUnhooked();
-    var i = e.getFieldEntities();
-    if (!t)
-      return i.some(function(n) {
-        return n.isFieldValidating();
+    return isAllFieldsTouched ? namePathListEntities.every(isNamePathListTouched) : namePathListEntities.some(isNamePathListTouched);
+  });
+  _defineProperty(this, "isFieldTouched", function(name) {
+    _this.warningUnhooked();
+    return _this.isFieldsTouched([name]);
+  });
+  _defineProperty(this, "isFieldsValidating", function(nameList) {
+    _this.warningUnhooked();
+    var fieldEntities = _this.getFieldEntities();
+    if (!nameList) {
+      return fieldEntities.some(function(testField) {
+        return testField.isFieldValidating();
       });
-    var r = t.map(g);
-    return i.some(function(n) {
-      var l = n.getNamePath();
-      return W(r, l) && n.isFieldValidating();
+    }
+    var namePathList = nameList.map(getNamePath);
+    return fieldEntities.some(function(testField) {
+      var fieldNamePath = testField.getNamePath();
+      return containsNamePath(namePathList, fieldNamePath) && testField.isFieldValidating();
     });
-  }), a(this, "isFieldValidating", function(t) {
-    return e.warningUnhooked(), e.isFieldsValidating([t]);
-  }), a(this, "resetWithFieldInitialValue", function() {
-    var t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, i = new N(), r = e.getFieldEntities(!0);
-    r.forEach(function(s) {
-      var o = s.props.initialValue, u = s.getNamePath();
-      if (o !== void 0) {
-        var d = i.get(u) || /* @__PURE__ */ new Set();
-        d.add({
-          entity: s,
-          value: o
-        }), i.set(u, d);
+  });
+  _defineProperty(this, "isFieldValidating", function(name) {
+    _this.warningUnhooked();
+    return _this.isFieldsValidating([name]);
+  });
+  _defineProperty(this, "resetWithFieldInitialValue", function() {
+    var info = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var cache = new NameMap();
+    var fieldEntities = _this.getFieldEntities(true);
+    fieldEntities.forEach(function(field) {
+      var initialValue = field.props.initialValue;
+      var namePath = field.getNamePath();
+      if (initialValue !== void 0) {
+        var records = cache.get(namePath) || /* @__PURE__ */ new Set();
+        records.add({
+          entity: field,
+          value: initialValue
+        });
+        cache.set(namePath, records);
       }
     });
-    var n = function(o) {
-      o.forEach(function(u) {
-        var d = u.props.initialValue;
-        if (d !== void 0) {
-          var f = u.getNamePath(), F = e.getInitialValue(f);
-          if (F !== void 0)
-            U(!1, "Form already set 'initialValues' with path '".concat(f.join("."), "'. Field can not overwrite it."));
-          else {
-            var m = i.get(f);
-            if (m && m.size > 1)
-              U(!1, "Multiple Field with path '".concat(f.join("."), "' set 'initialValue'. Can not decide which one to pick."));
-            else if (m) {
-              var c = e.getFieldValue(f), v = u.isListField();
-              !v && (!t.skipExist || c === void 0) && e.updateStore(P(e.store, f, V(m)[0].value));
+    var resetWithFields = function resetWithFields2(entities) {
+      entities.forEach(function(field) {
+        var initialValue = field.props.initialValue;
+        if (initialValue !== void 0) {
+          var namePath = field.getNamePath();
+          var formInitialValue = _this.getInitialValue(namePath);
+          if (formInitialValue !== void 0) {
+            warningOnce(false, "Form already set 'initialValues' with path '".concat(namePath.join("."), "'. Field can not overwrite it."));
+          } else {
+            var records = cache.get(namePath);
+            if (records && records.size > 1) {
+              warningOnce(false, "Multiple Field with path '".concat(namePath.join("."), "' set 'initialValue'. Can not decide which one to pick."));
+            } else if (records) {
+              var originValue = _this.getFieldValue(namePath);
+              var isListField = field.isListField();
+              if (!isListField && (!info.skipExist || originValue === void 0)) {
+                _this.updateStore(set(_this.store, namePath, _toConsumableArray(records)[0].value));
+              }
             }
           }
         }
       });
-    }, l;
-    t.entities ? l = t.entities : t.namePathList ? (l = [], t.namePathList.forEach(function(s) {
-      var o = i.get(s);
-      if (o) {
-        var u;
-        (u = l).push.apply(u, V(V(o).map(function(d) {
-          return d.entity;
-        })));
-      }
-    })) : l = r, n(l);
-  }), a(this, "resetFields", function(t) {
-    e.warningUnhooked();
-    var i = e.store;
-    if (!t) {
-      e.updateStore(L(e.initialValues)), e.resetWithFieldInitialValue(), e.notifyObservers(i, null, {
+    };
+    var requiredFieldEntities;
+    if (info.entities) {
+      requiredFieldEntities = info.entities;
+    } else if (info.namePathList) {
+      requiredFieldEntities = [];
+      info.namePathList.forEach(function(namePath) {
+        var records = cache.get(namePath);
+        if (records) {
+          var _requiredFieldEntitie;
+          (_requiredFieldEntitie = requiredFieldEntities).push.apply(_requiredFieldEntitie, _toConsumableArray(_toConsumableArray(records).map(function(r) {
+            return r.entity;
+          })));
+        }
+      });
+    } else {
+      requiredFieldEntities = fieldEntities;
+    }
+    resetWithFields(requiredFieldEntities);
+  });
+  _defineProperty(this, "resetFields", function(nameList) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    if (!nameList) {
+      _this.updateStore(merge(_this.initialValues));
+      _this.resetWithFieldInitialValue();
+      _this.notifyObservers(prevStore, null, {
         type: "reset"
-      }), e.notifyWatch();
+      });
+      _this.notifyWatch();
       return;
     }
-    var r = t.map(g);
-    r.forEach(function(n) {
-      var l = e.getInitialValue(n);
-      e.updateStore(P(e.store, n, l));
-    }), e.resetWithFieldInitialValue({
-      namePathList: r
-    }), e.notifyObservers(i, r, {
+    var namePathList = nameList.map(getNamePath);
+    namePathList.forEach(function(namePath) {
+      var initialValue = _this.getInitialValue(namePath);
+      _this.updateStore(set(_this.store, namePath, initialValue));
+    });
+    _this.resetWithFieldInitialValue({
+      namePathList
+    });
+    _this.notifyObservers(prevStore, namePathList, {
       type: "reset"
-    }), e.notifyWatch(r);
-  }), a(this, "setFields", function(t) {
-    e.warningUnhooked();
-    var i = e.store, r = [];
-    t.forEach(function(n) {
-      var l = n.name, s = j(n, J), o = g(l);
-      r.push(o), "value" in s && e.updateStore(P(e.store, o, s.value)), e.notifyObservers(i, [o], {
+    });
+    _this.notifyWatch(namePathList);
+  });
+  _defineProperty(this, "setFields", function(fields) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    var namePathList = [];
+    fields.forEach(function(fieldData) {
+      var name = fieldData.name, data = _objectWithoutProperties(fieldData, _excluded);
+      var namePath = getNamePath(name);
+      namePathList.push(namePath);
+      if ("value" in data) {
+        _this.updateStore(set(_this.store, namePath, data.value));
+      }
+      _this.notifyObservers(prevStore, [namePath], {
         type: "setField",
-        data: n
+        data: fieldData
+      });
+    });
+    _this.notifyWatch(namePathList);
+  });
+  _defineProperty(this, "getFields", function() {
+    var entities = _this.getFieldEntities(true);
+    var fields = entities.map(function(field) {
+      var namePath = field.getNamePath();
+      var meta = field.getMeta();
+      var fieldData = _objectSpread2(_objectSpread2({}, meta), {}, {
+        name: namePath,
+        value: _this.getFieldValue(namePath)
       });
-    }), e.notifyWatch(r);
-  }), a(this, "getFields", function() {
-    var t = e.getFieldEntities(!0), i = t.map(function(r) {
-      var n = r.getNamePath(), l = r.getMeta(), s = E(E({}, l), {}, {
-        name: n,
-        value: e.getFieldValue(n)
+      Object.defineProperty(fieldData, "originRCField", {
+        value: true
       });
-      return Object.defineProperty(s, "originRCField", {
-        value: !0
-      }), s;
+      return fieldData;
     });
-    return i;
-  }), a(this, "initEntityValue", function(t) {
-    var i = t.props.initialValue;
-    if (i !== void 0) {
-      var r = t.getNamePath(), n = T(e.store, r);
-      n === void 0 && e.updateStore(P(e.store, r, i));
+    return fields;
+  });
+  _defineProperty(this, "initEntityValue", function(entity) {
+    var initialValue = entity.props.initialValue;
+    if (initialValue !== void 0) {
+      var namePath = entity.getNamePath();
+      var prevValue = get(_this.store, namePath);
+      if (prevValue === void 0) {
+        _this.updateStore(set(_this.store, namePath, initialValue));
+      }
     }
-  }), a(this, "isMergedPreserve", function(t) {
-    var i = t !== void 0 ? t : e.preserve;
-    return i ?? !0;
-  }), a(this, "registerField", function(t) {
-    e.fieldEntities.push(t);
-    var i = t.getNamePath();
-    if (e.notifyWatch([i]), t.props.initialValue !== void 0) {
-      var r = e.store;
-      e.resetWithFieldInitialValue({
-        entities: [t],
-        skipExist: !0
-      }), e.notifyObservers(r, [t.getNamePath()], {
+  });
+  _defineProperty(this, "isMergedPreserve", function(fieldPreserve) {
+    var mergedPreserve = fieldPreserve !== void 0 ? fieldPreserve : _this.preserve;
+    return mergedPreserve !== null && mergedPreserve !== void 0 ? mergedPreserve : true;
+  });
+  _defineProperty(this, "registerField", function(entity) {
+    _this.fieldEntities.push(entity);
+    var namePath = entity.getNamePath();
+    _this.notifyWatch([namePath]);
+    if (entity.props.initialValue !== void 0) {
+      var prevStore = _this.store;
+      _this.resetWithFieldInitialValue({
+        entities: [entity],
+        skipExist: true
+      });
+      _this.notifyObservers(prevStore, [entity.getNamePath()], {
         type: "valueUpdate",
         source: "internal"
       });
     }
-    return function(n, l) {
-      var s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
-      if (e.fieldEntities = e.fieldEntities.filter(function(d) {
-        return d !== t;
-      }), !e.isMergedPreserve(l) && (!n || s.length > 1)) {
-        var o = n ? void 0 : e.getInitialValue(i);
-        if (i.length && e.getFieldValue(i) !== o && e.fieldEntities.every(function(d) {
+    return function(isListField, preserve) {
+      var subNamePath = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+      _this.fieldEntities = _this.fieldEntities.filter(function(item) {
+        return item !== entity;
+      });
+      if (!_this.isMergedPreserve(preserve) && (!isListField || subNamePath.length > 1)) {
+        var defaultValue = isListField ? void 0 : _this.getInitialValue(namePath);
+        if (namePath.length && _this.getFieldValue(namePath) !== defaultValue && _this.fieldEntities.every(function(field) {
           return (
             // Only reset when no namePath exist
-            !G(d.getNamePath(), i)
+            !matchNamePath(field.getNamePath(), namePath)
           );
         })) {
-          var u = e.store;
-          e.updateStore(P(u, i, o, !0)), e.notifyObservers(u, [i], {
+          var _prevStore = _this.store;
+          _this.updateStore(set(_prevStore, namePath, defaultValue, true));
+          _this.notifyObservers(_prevStore, [namePath], {
             type: "remove"
-          }), e.triggerDependenciesUpdate(u, i);
+          });
+          _this.triggerDependenciesUpdate(_prevStore, namePath);
         }
       }
-      e.notifyWatch([i]);
+      _this.notifyWatch([namePath]);
     };
-  }), a(this, "dispatch", function(t) {
-    switch (t.type) {
+  });
+  _defineProperty(this, "dispatch", function(action) {
+    switch (action.type) {
       case "updateValue": {
-        var i = t.namePath, r = t.value;
-        e.updateValue(i, r);
+        var namePath = action.namePath, value = action.value;
+        _this.updateValue(namePath, value);
         break;
       }
       case "validateField": {
-        var n = t.namePath, l = t.triggerName;
-        e.validateFields([n], {
-          triggerName: l
+        var _namePath = action.namePath, triggerName = action.triggerName;
+        _this.validateFields([_namePath], {
+          triggerName
         });
         break;
       }
     }
-  }), a(this, "notifyObservers", function(t, i, r) {
-    if (e.subscribable) {
-      var n = E(E({}, r), {}, {
-        store: e.getFieldsValue(!0)
+  });
+  _defineProperty(this, "notifyObservers", function(prevStore, namePathList, info) {
+    if (_this.subscribable) {
+      var mergedInfo = _objectSpread2(_objectSpread2({}, info), {}, {
+        store: _this.getFieldsValue(true)
       });
-      e.getFieldEntities().forEach(function(l) {
-        var s = l.onStoreChange;
-        s(t, i, n);
+      _this.getFieldEntities().forEach(function(_ref5) {
+        var onStoreChange = _ref5.onStoreChange;
+        onStoreChange(prevStore, namePathList, mergedInfo);
       });
-    } else
-      e.forceRootUpdate();
-  }), a(this, "triggerDependenciesUpdate", function(t, i) {
-    var r = e.getDependencyChildrenFields(i);
-    return r.length && e.validateFields(r), e.notifyObservers(t, r, {
+    } else {
+      _this.forceRootUpdate();
+    }
+  });
+  _defineProperty(this, "triggerDependenciesUpdate", function(prevStore, namePath) {
+    var childrenFields = _this.getDependencyChildrenFields(namePath);
+    if (childrenFields.length) {
+      _this.validateFields(childrenFields);
+    }
+    _this.notifyObservers(prevStore, childrenFields, {
       type: "dependenciesUpdate",
-      relatedFields: [i].concat(V(r))
-    }), r;
-  }), a(this, "updateValue", function(t, i) {
-    var r = g(t), n = e.store;
-    e.updateStore(P(e.store, r, i)), e.notifyObservers(n, [r], {
+      relatedFields: [namePath].concat(_toConsumableArray(childrenFields))
+    });
+    return childrenFields;
+  });
+  _defineProperty(this, "updateValue", function(name, value) {
+    var namePath = getNamePath(name);
+    var prevStore = _this.store;
+    _this.updateStore(set(_this.store, namePath, value));
+    _this.notifyObservers(prevStore, [namePath], {
       type: "valueUpdate",
       source: "internal"
-    }), e.notifyWatch([r]);
-    var l = e.triggerDependenciesUpdate(n, r), s = e.callbacks.onValuesChange;
-    if (s) {
-      var o = D(e.store, [r]);
-      s(o, e.getFieldsValue());
+    });
+    _this.notifyWatch([namePath]);
+    var childrenFields = _this.triggerDependenciesUpdate(prevStore, namePath);
+    var onValuesChange = _this.callbacks.onValuesChange;
+    if (onValuesChange) {
+      var changedValues = cloneByNamePathList(_this.store, [namePath]);
+      onValuesChange(changedValues, _this.getFieldsValue());
     }
-    e.triggerOnFieldsChange([r].concat(V(l)));
-  }), a(this, "setFieldsValue", function(t) {
-    e.warningUnhooked();
-    var i = e.store;
-    if (t) {
-      var r = L(e.store, t);
-      e.updateStore(r);
+    _this.triggerOnFieldsChange([namePath].concat(_toConsumableArray(childrenFields)));
+  });
+  _defineProperty(this, "setFieldsValue", function(store) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    if (store) {
+      var nextStore = merge(_this.store, store);
+      _this.updateStore(nextStore);
     }
-    e.notifyObservers(i, null, {
+    _this.notifyObservers(prevStore, null, {
       type: "valueUpdate",
       source: "external"
-    }), e.notifyWatch();
-  }), a(this, "setFieldValue", function(t, i) {
-    e.setFields([{
-      name: t,
-      value: i,
+    });
+    _this.notifyWatch();
+  });
+  _defineProperty(this, "setFieldValue", function(name, value) {
+    _this.setFields([{
+      name,
+      value,
       errors: [],
       warnings: []
     }]);
-  }), a(this, "getDependencyChildrenFields", function(t) {
-    var i = /* @__PURE__ */ new Set(), r = [], n = new N();
-    e.getFieldEntities().forEach(function(s) {
-      var o = s.props.dependencies;
-      (o || []).forEach(function(u) {
-        var d = g(u);
-        n.update(d, function() {
-          var f = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : /* @__PURE__ */ new Set();
-          return f.add(s), f;
+  });
+  _defineProperty(this, "getDependencyChildrenFields", function(rootNamePath) {
+    var children = /* @__PURE__ */ new Set();
+    var childrenFields = [];
+    var dependencies2fields = new NameMap();
+    _this.getFieldEntities().forEach(function(field) {
+      var dependencies = field.props.dependencies;
+      (dependencies || []).forEach(function(dependency) {
+        var dependencyNamePath = getNamePath(dependency);
+        dependencies2fields.update(dependencyNamePath, function() {
+          var fields = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : /* @__PURE__ */ new Set();
+          fields.add(field);
+          return fields;
         });
       });
     });
-    var l = function s(o) {
-      var u = n.get(o) || /* @__PURE__ */ new Set();
-      u.forEach(function(d) {
-        if (!i.has(d)) {
-          i.add(d);
-          var f = d.getNamePath();
-          d.isFieldDirty() && f.length && (r.push(f), s(f));
+    var fillChildren = function fillChildren2(namePath) {
+      var fields = dependencies2fields.get(namePath) || /* @__PURE__ */ new Set();
+      fields.forEach(function(field) {
+        if (!children.has(field)) {
+          children.add(field);
+          var fieldNamePath = field.getNamePath();
+          if (field.isFieldDirty() && fieldNamePath.length) {
+            childrenFields.push(fieldNamePath);
+            fillChildren2(fieldNamePath);
+          }
         }
       });
     };
-    return l(t), r;
-  }), a(this, "triggerOnFieldsChange", function(t, i) {
-    var r = e.callbacks.onFieldsChange;
-    if (r) {
-      var n = e.getFields();
-      if (i) {
-        var l = new N();
-        i.forEach(function(o) {
-          var u = o.name, d = o.errors;
-          l.set(u, d);
-        }), n.forEach(function(o) {
-          o.errors = l.get(o.name) || o.errors;
+    fillChildren(rootNamePath);
+    return childrenFields;
+  });
+  _defineProperty(this, "triggerOnFieldsChange", function(namePathList, filedErrors) {
+    var onFieldsChange = _this.callbacks.onFieldsChange;
+    if (onFieldsChange) {
+      var fields = _this.getFields();
+      if (filedErrors) {
+        var cache = new NameMap();
+        filedErrors.forEach(function(_ref6) {
+          var name = _ref6.name, errors = _ref6.errors;
+          cache.set(name, errors);
+        });
+        fields.forEach(function(field) {
+          field.errors = cache.get(field.name) || field.errors;
         });
       }
-      var s = n.filter(function(o) {
-        var u = o.name;
-        return W(t, u);
+      var changedFields = fields.filter(function(_ref7) {
+        var fieldName = _ref7.name;
+        return containsNamePath(namePathList, fieldName);
       });
-      s.length && r(s, n);
+      if (changedFields.length) {
+        onFieldsChange(changedFields, fields);
+      }
     }
-  }), a(this, "validateFields", function(t, i) {
-    e.warningUnhooked();
-    var r, n;
-    Array.isArray(t) || typeof t == "string" || typeof i == "string" ? (r = t, n = i) : n = t;
-    var l = !!r, s = l ? r.map(g) : [], o = [], u = String(Date.now()), d = /* @__PURE__ */ new Set(), f = n || {}, F = f.recursive, m = f.dirty;
-    e.getFieldEntities(!0).forEach(function(h) {
-      if (l || s.push(h.getNamePath()), !(!h.props.rules || !h.props.rules.length) && !(m && !h.isFieldDirty())) {
-        var p = h.getNamePath();
-        if (d.add(p.join(u)), !l || W(s, p, F)) {
-          var w = h.validateRules(E({
-            validateMessages: E(E({}, q), e.validateMessages)
-          }, n));
-          o.push(w.then(function() {
-            return {
-              name: p,
-              errors: [],
-              warnings: []
-            };
-          }).catch(function(S) {
-            var M, b = [], A = [];
-            return (M = S.forEach) === null || M === void 0 || M.call(S, function(C) {
-              var R = C.rule.warningOnly, O = C.errors;
-              R ? A.push.apply(A, V(O)) : b.push.apply(b, V(O));
-            }), b.length ? Promise.reject({
-              name: p,
-              errors: b,
-              warnings: A
-            }) : {
-              name: p,
-              errors: b,
-              warnings: A
-            };
-          }));
-        }
+  });
+  _defineProperty(this, "validateFields", function(arg1, arg2) {
+    _this.warningUnhooked();
+    var nameList;
+    var options;
+    if (Array.isArray(arg1) || typeof arg1 === "string" || typeof arg2 === "string") {
+      nameList = arg1;
+      options = arg2;
+    } else {
+      options = arg1;
+    }
+    var provideNameList = !!nameList;
+    var namePathList = provideNameList ? nameList.map(getNamePath) : [];
+    var promiseList = [];
+    var TMP_SPLIT = String(Date.now());
+    var validateNamePathList = /* @__PURE__ */ new Set();
+    var _ref8 = options || {}, recursive = _ref8.recursive, dirty = _ref8.dirty;
+    _this.getFieldEntities(true).forEach(function(field) {
+      if (!provideNameList) {
+        namePathList.push(field.getNamePath());
+      }
+      if (!field.props.rules || !field.props.rules.length) {
+        return;
+      }
+      if (dirty && !field.isFieldDirty()) {
+        return;
+      }
+      var fieldNamePath = field.getNamePath();
+      validateNamePathList.add(fieldNamePath.join(TMP_SPLIT));
+      if (!provideNameList || containsNamePath(namePathList, fieldNamePath, recursive)) {
+        var promise = field.validateRules(_objectSpread2({
+          validateMessages: _objectSpread2(_objectSpread2({}, defaultValidateMessages), _this.validateMessages)
+        }, options));
+        promiseList.push(promise.then(function() {
+          return {
+            name: fieldNamePath,
+            errors: [],
+            warnings: []
+          };
+        }).catch(function(ruleErrors) {
+          var _ruleErrors$forEach;
+          var mergedErrors = [];
+          var mergedWarnings = [];
+          (_ruleErrors$forEach = ruleErrors.forEach) === null || _ruleErrors$forEach === void 0 || _ruleErrors$forEach.call(ruleErrors, function(_ref9) {
+            var warningOnly = _ref9.rule.warningOnly, errors = _ref9.errors;
+            if (warningOnly) {
+              mergedWarnings.push.apply(mergedWarnings, _toConsumableArray(errors));
+            } else {
+              mergedErrors.push.apply(mergedErrors, _toConsumableArray(errors));
+            }
+          });
+          if (mergedErrors.length) {
+            return Promise.reject({
+              name: fieldNamePath,
+              errors: mergedErrors,
+              warnings: mergedWarnings
+            });
+          }
+          return {
+            name: fieldNamePath,
+            errors: mergedErrors,
+            warnings: mergedWarnings
+          };
+        }));
       }
     });
-    var c = $(o);
-    e.lastValidatePromise = c, c.catch(function(h) {
-      return h;
-    }).then(function(h) {
-      var p = h.map(function(w) {
-        var S = w.name;
-        return S;
+    var summaryPromise = allPromiseFinish(promiseList);
+    _this.lastValidatePromise = summaryPromise;
+    summaryPromise.catch(function(results) {
+      return results;
+    }).then(function(results) {
+      var resultNamePathList = results.map(function(_ref10) {
+        var name = _ref10.name;
+        return name;
       });
-      e.notifyObservers(e.store, p, {
+      _this.notifyObservers(_this.store, resultNamePathList, {
         type: "validateFinish"
-      }), e.triggerOnFieldsChange(p, h);
+      });
+      _this.triggerOnFieldsChange(resultNamePathList, results);
     });
-    var v = c.then(function() {
-      return e.lastValidatePromise === c ? Promise.resolve(e.getFieldsValue(s)) : Promise.reject([]);
-    }).catch(function(h) {
-      var p = h.filter(function(w) {
-        return w && w.errors.length;
+    var returnPromise = summaryPromise.then(function() {
+      if (_this.lastValidatePromise === summaryPromise) {
+        return Promise.resolve(_this.getFieldsValue(namePathList));
+      }
+      return Promise.reject([]);
+    }).catch(function(results) {
+      var errorList = results.filter(function(result) {
+        return result && result.errors.length;
       });
       return Promise.reject({
-        values: e.getFieldsValue(s),
-        errorFields: p,
-        outOfDate: e.lastValidatePromise !== c
+        values: _this.getFieldsValue(namePathList),
+        errorFields: errorList,
+        outOfDate: _this.lastValidatePromise !== summaryPromise
       });
     });
-    v.catch(function(h) {
-      return h;
+    returnPromise.catch(function(e) {
+      return e;
     });
-    var I = s.filter(function(h) {
-      return d.has(h.join(u));
+    var triggerNamePathList = namePathList.filter(function(namePath) {
+      return validateNamePathList.has(namePath.join(TMP_SPLIT));
     });
-    return e.triggerOnFieldsChange(I), v;
-  }), a(this, "submit", function() {
-    e.warningUnhooked(), e.validateFields().then(function(t) {
-      var i = e.callbacks.onFinish;
-      if (i)
+    _this.triggerOnFieldsChange(triggerNamePathList);
+    return returnPromise;
+  });
+  _defineProperty(this, "submit", function() {
+    _this.warningUnhooked();
+    _this.validateFields().then(function(values) {
+      var onFinish = _this.callbacks.onFinish;
+      if (onFinish) {
         try {
-          i(t);
-        } catch (r) {
-          console.error(r);
+          onFinish(values);
+        } catch (err) {
+          console.error(err);
         }
-    }).catch(function(t) {
-      var i = e.callbacks.onFinishFailed;
-      i && i(t);
+      }
+    }).catch(function(e) {
+      var onFinishFailed = _this.callbacks.onFinishFailed;
+      if (onFinishFailed) {
+        onFinishFailed(e);
+      }
     });
-  }), this.forceRootUpdate = y;
+  });
+  this.forceRootUpdate = forceRootUpdate;
 });
-function he(k) {
-  var y = _.useRef(), e = _.useState({}), t = H(e, 2), i = t[1];
-  if (!y.current)
-    if (k)
-      y.current = k;
-    else {
-      var r = function() {
-        i({});
-      }, n = new Q(r);
-      y.current = n.getForm();
+function useForm(form) {
+  var formRef = React.useRef();
+  var _React$useState = React.useState({}), _React$useState2 = _slicedToArray(_React$useState, 2), forceUpdate = _React$useState2[1];
+  if (!formRef.current) {
+    if (form) {
+      formRef.current = form;
+    } else {
+      var forceReRender = function forceReRender2() {
+        forceUpdate({});
+      };
+      var formStore = new FormStore(forceReRender);
+      formRef.current = formStore.getForm();
     }
-  return [y.current];
+  }
+  return [formRef.current];
 }
 export {
-  Q as FormStore,
-  he as default
+  FormStore,
+  useForm as default
 };