@qsxy/element-plus-react 1.0.0-next.2 → 1.0.0-next.21

package/dist/Form/useForm.js

@@ -1,751 +1,891 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/Form/useForm.ts
-var useForm_exports = {};
-__export(useForm_exports, {
-  FormStore: () => FormStore,
-  default: () => useForm_default
-});
-module.exports = __toCommonJS(useForm_exports);
-var import_react = require("react");
-var import_scroll_into_view_if_needed = __toESM(require("scroll-into-view-if-needed"));
-var import_Util = require("../Util");
-var import_FieldContext = require("./FieldContext");
-var import_NameMap = __toESM(require("./utils/NameMap"));
-var import_asyncUtil = require("./utils/asyncUtil");
-var import_cloneDeep = __toESM(require("./utils/cloneDeep"));
-var import_messages = require("./utils/messages");
-var import_typeUtil = require("./utils/typeUtil");
-var import_valueUtil = require("./utils/valueUtil");
-var FormStore = class {
-  constructor(forceRootUpdate) {
-    this.formHooked = false;
-    this.subscribable = true;
-    this.store = {};
-    this.fieldEntities = [];
-    this.initialValues = {};
-    this.callbacks = {};
-    this.validateMessages = null;
-    this.preserve = null;
-    this.lastValidatePromise = null;
-    this.getForm = () => ({
-      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,
+var _excluded = ["name", "errors"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useRef, useState } from 'react';
+import scrollIntoView from 'scroll-into-view-if-needed';
+import { warning } from "../Util";
+import { HOOK_MARK } from "./FieldContext";
+import NameMap from "./utils/NameMap";
+import { allPromiseFinish } from "./utils/asyncUtil";
+import cloneDeep from "./utils/cloneDeep";
+import { defaultValidateMessages } from "./utils/messages";
+import { toArray } from "./utils/typeUtil";
+import { cloneByNamePathList, containsNamePath, getNamePath, getValue, matchNamePath, setValue, setValues } from "./utils/valueUtil";
+export var FormStore = /*#__PURE__*/_createClass(function FormStore(forceRootUpdate) {
+  var _this = this;
+  _classCallCheck(this, FormStore);
+  _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: _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,
-      scrollToField: this.scrollToField,
-      getInternalHooks: this.getInternalHooks
-    });
-    this.scrollToField = (name, options = {}) => {
-      var _a;
-      const namePath = (0, import_typeUtil.toArray)(name);
-      const node = (_a = this.getFieldsMap().get(namePath)) == null ? void 0 : _a.base;
-      if (node) {
-        (0, import_scroll_into_view_if_needed.default)(node, {
-          scrollMode: "if-needed",
-          block: "nearest",
-          ...options
-        });
-      }
-    };
-    // ======================== Internal Hooks ========================
-    this.getInternalHooks = (key) => {
-      if (key === import_FieldContext.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
-        };
-      }
-      (0, import_Util.warning)(false, "`getInternalHooks` is internal usage. Should not call directly.");
-      return null;
-    };
-    this.useSubscribe = (subscribable) => {
-      this.subscribable = subscribable;
-    };
-    /**
-     * Record prev Form unmount fieldEntities which config preserve false.
-     * This need to be refill with initialValues instead of store value.
-     */
-    this.prevWithoutPreserves = null;
-    /**
-     * First time `setInitialValues` should update store with initial value
-     */
-    this.setInitialValues = (initialValues, init) => {
-      var _a;
-      this.initialValues = initialValues || {};
-      if (init) {
-        let nextStore = (0, import_valueUtil.setValues)({}, initialValues, this.store);
-        (_a = this.prevWithoutPreserves) == null ? void 0 : _a.map(({ key: namePath }) => {
-          nextStore = (0, import_valueUtil.setValue)(nextStore, namePath, (0, import_valueUtil.getValue)(initialValues, namePath));
-        });
-        this.prevWithoutPreserves = null;
-        this.updateStore(nextStore);
+      scrollToField: _this.scrollToField,
+      getInternalHooks: _this.getInternalHooks
+    };
+  });
+  _defineProperty(this, "scrollToField", function (name) {
+    var _this$getFieldsMap$ge;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var namePath = toArray(name);
+    var node = (_this$getFieldsMap$ge = _this.getFieldsMap().get(namePath)) === null || _this$getFieldsMap$ge === void 0 ? void 0 : _this$getFieldsMap$ge.containerRef;
+    if (node.current) {
+      scrollIntoView(node.current, _objectSpread({
+        scrollMode: 'if-needed',
+        block: 'center'
+      }, options));
+    }
+  });
+  // ======================== Internal Hooks ========================
+  _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
+      };
+    }
+    warning(false, '`getInternalHooks` is internal usage. Should not call directly.');
+    return null;
+  });
+  _defineProperty(this, "useSubscribe", function (subscribable) {
+    _this.subscribable = subscribable;
+  });
+  /**
+   * Record prev Form unmount fieldEntities which config preserve false.
+   * This need to be refill with initialValues instead of store value.
+   */
+  _defineProperty(this, "prevWithoutPreserves", null);
+  /**
+   * First time `setInitialValues` should update store with initial value
+   */
+  _defineProperty(this, "setInitialValues", function (initialValues, init) {
+    _this.initialValues = initialValues || {};
+    if (init) {
+      var _this$prevWithoutPres;
+      var nextStore = setValues({}, initialValues, _this.store);
+
+      // We will take consider prev form unmount fields.
+      // When the field is not `preserve`, we need fill this with initialValues instead of store.
+      // eslint-disable-next-line array-callback-return
+      (_this$prevWithoutPres = _this.prevWithoutPreserves) === null || _this$prevWithoutPres === void 0 || _this$prevWithoutPres.map(function (_ref) {
+        var namePath = _ref.key;
+        nextStore = setValue(nextStore, namePath, getValue(initialValues, namePath));
+      });
+      _this.prevWithoutPreserves = null;
+      _this.updateStore(nextStore);
+    }
+  });
+  _defineProperty(this, "destroyForm", function () {
+    var prevWithoutPreserves = new NameMap();
+    _this.getFieldEntities(true).forEach(function (entity) {
+      if (!_this.isMergedPreserve(entity.isPreserve())) {
+        prevWithoutPreserves.set(entity.getNamePath(), true);
       }
+    });
+    _this.prevWithoutPreserves = prevWithoutPreserves;
+  });
+  _defineProperty(this, "getInitialValue", function (namePath) {
+    var initValue = getValue(_this.initialValues, namePath);
+
+    // Not cloneDeep when without `namePath`
+    return namePath.length ? cloneDeep(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;
+  });
+  // ============================= Watch ============================
+  _defineProperty(this, "watchList", []);
+  _defineProperty(this, "registerWatch", function (callback) {
+    _this.watchList.push(callback);
+    return function () {
+      _this.watchList = _this.watchList.filter(function (fn) {
+        return fn !== callback;
+      });
     };
-    this.destroyForm = () => {
-      const prevWithoutPreserves = new import_NameMap.default();
-      this.getFieldEntities(true).forEach((entity) => {
-        if (!this.isMergedPreserve(entity.isPreserve())) {
-          prevWithoutPreserves.set(entity.getNamePath(), true);
+  });
+  _defineProperty(this, "notifyWatch", function () {
+    var namePath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    // No need to cost perf when nothing need to watch
+    if (_this.watchList.length) {
+      var values = _this.getFieldsValue();
+      _this.watchList.forEach(function (callback) {
+        callback(values, namePath);
+      });
+    }
+  });
+  // ========================== Dev Warning =========================
+  _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) {
+          warning(false, 'Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?');
         }
       });
-      this.prevWithoutPreserves = prevWithoutPreserves;
-    };
-    this.getInitialValue = (namePath) => {
-      const initValue = (0, import_valueUtil.getValue)(this.initialValues, namePath);
-      return namePath.length ? (0, import_cloneDeep.default)(initValue) : initValue;
-    };
-    this.setCallbacks = (callbacks) => {
-      this.callbacks = callbacks;
-    };
-    this.setValidateMessages = (validateMessages) => {
-      this.validateMessages = validateMessages;
-    };
-    this.setPreserve = (preserve) => {
-      this.preserve = preserve;
-    };
-    // ============================= Watch ============================
-    this.watchList = [];
-    this.registerWatch = (callback) => {
-      this.watchList.push(callback);
-      return () => {
-        this.watchList = this.watchList.filter((fn) => fn !== callback);
+    }
+  });
+  // ============================ Store =============================
+  _defineProperty(this, "updateStore", function (nextStore) {
+    _this.store = nextStore;
+  });
+  // ============================ Fields ============================
+  /**
+   * Get registered field entities.
+   * @param pure Only return field which has a `name`. Default: false
+   */
+  _defineProperty(this, "getFieldEntities", function () {
+    var pure = arguments.length > 0 && arguments[0] !== undefined ? 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] !== undefined ? 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)
       };
-    };
-    this.notifyWatch = (namePath = []) => {
-      if (this.watchList.length) {
-        const values = this.getFieldsValue();
-        this.watchList.forEach((callback) => {
-          callback(values, namePath);
-        });
+    });
+  });
+  _defineProperty(this, "getFieldsValue", function (nameList, filterFunc) {
+    _this.warningUnhooked();
+    if (nameList === true && !filterFunc) {
+      return _this.store;
+    }
+    var fieldEntities = _this.getFieldEntitiesForNamePathList(Array.isArray(nameList) ? nameList : null);
+    var filteredNameList = [];
+    fieldEntities.forEach(function (entity) {
+      var _isListField, _ref2;
+      var namePath = 'INVALIDATE_NAME_PATH' in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
+
+      // Ignore when it's a list item and not specific the namePath,
+      // since parent field is already take in count
+      if (!nameList && (_isListField = (_ref2 = entity).isListField) !== null && _isListField !== void 0 && _isListField.call(_ref2)) {
+        return;
       }
-    };
-    // ========================== Dev Warning =========================
-    this.timeoutId = null;
-    this.warningUnhooked = () => {
-      if (process.env.NODE_ENV !== "production" && !this.timeoutId && typeof window !== "undefined") {
-        this.timeoutId = setTimeout(() => {
-          this.timeoutId = null;
-          if (!this.formHooked) {
-            (0, import_Util.warning)(false, "Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?");
-          }
-        });
+      if (!filterFunc) {
+        filteredNameList.push(namePath);
+      } else {
+        var _meta = 'getMeta' in entity ? entity.getMeta() : null;
+        if (filterFunc(_meta)) {
+          filteredNameList.push(namePath);
+        }
       }
-    };
-    // ============================ Store =============================
-    this.updateStore = (nextStore) => {
-      this.store = nextStore;
-    };
-    // ============================ Fields ============================
-    /**
-     * Get registered field entities.
-     * @param pure Only return field which has a `name`. Default: false
-     */
-    this.getFieldEntities = (pure = false) => {
-      if (!pure) {
-        return this.fieldEntities;
+    });
+    return cloneByNamePathList(_this.store, filteredNameList.map(getNamePath));
+  });
+  _defineProperty(this, "getFieldValue", function (name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    return getValue(_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 this.fieldEntities.filter((field) => field.getNamePath().length);
+      return {
+        name: getNamePath(nameList[index]),
+        errors: [],
+        warnings: []
+      };
+    });
+  });
+  _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 isFieldTouched(field) {
+      return field.isFieldTouched();
     };
-    this.getFieldsMap = (pure = false) => {
-      const cache = new import_NameMap.default();
-      this.getFieldEntities(pure).forEach((field) => {
-        const namePath = field.getNamePath();
-        cache.set(namePath, field);
+
+    // ===== Will get fully compare when not config namePathList =====
+    if (!namePathList) {
+      return isAllFieldsTouched ? fieldEntities.every(isFieldTouched) : fieldEntities.some(isFieldTouched);
+    }
+
+    // Generate a nest tree for validate
+    var map = new NameMap();
+    namePathList.forEach(function (shortNamePath) {
+      map.set(shortNamePath, []);
+    });
+    fieldEntities.forEach(function (field) {
+      var fieldNamePath = field.getNamePath();
+
+      // Find matched entity and put into list
+      namePathList.forEach(function (shortNamePath) {
+        if (shortNamePath.every(function (nameUnit, i) {
+          return fieldNamePath[i] === nameUnit;
+        })) {
+          map.update(shortNamePath, function (list) {
+            return [].concat(_toConsumableArray(list), [field]);
+          });
+        }
       });
-      return cache;
+    });
+
+    // Check if NameMap value is touched
+    var isNamePathListTouched = function isNamePathListTouched(entities) {
+      return entities.some(isFieldTouched);
     };
-    this.getFieldEntitiesForNamePathList = (nameList) => {
-      if (!nameList) {
-        return this.getFieldEntities(true);
-      }
-      const cache = this.getFieldsMap(true);
-      return nameList.map((name) => {
-        const namePath = (0, import_valueUtil.getNamePath)(name);
-        return cache.get(namePath) || { INVALIDATE_NAME_PATH: (0, import_valueUtil.getNamePath)(name) };
+    var namePathListEntities = map.map(function (_ref3) {
+      var value = _ref3.value;
+      return value;
+    });
+    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();
       });
-    };
-    this.getFieldsValue = (nameList, filterFunc) => {
-      this.warningUnhooked();
-      if (nameList === true && !filterFunc) {
-        return this.store;
+    }
+    var namePathList = nameList.map(getNamePath);
+    return fieldEntities.some(function (testField) {
+      var fieldNamePath = testField.getNamePath();
+      return containsNamePath(namePathList, fieldNamePath) && testField.isFieldValidating();
+    });
+  });
+  _defineProperty(this, "isFieldValidating", function (name) {
+    _this.warningUnhooked();
+    return _this.isFieldsValidating([name]);
+  });
+  /**
+   * Reset Field with field `initialValue` prop.
+   * Can pass `entities` or `namePathList` or just nothing.
+   */
+  _defineProperty(this, "resetWithFieldInitialValue", function () {
+    var info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // Create cache
+    var cache = new NameMap();
+    var fieldEntities = _this.getFieldEntities(true);
+    fieldEntities.forEach(function (field) {
+      var initialValue = field.props.initialValue;
+      var namePath = field.getNamePath();
+
+      // Record only if has `initialValue`
+      if (initialValue !== undefined) {
+        var records = cache.get(namePath) || new Set();
+        records.add({
+          entity: field,
+          value: initialValue
+        });
+        cache.set(namePath, records);
       }
-      const fieldEntities = this.getFieldEntitiesForNamePathList(Array.isArray(nameList) ? nameList : null);
-      const filteredNameList = [];
-      fieldEntities.forEach((entity) => {
-        var _a;
-        const namePath = "INVALIDATE_NAME_PATH" in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
-        if (!nameList && ((_a = entity.isListField) == null ? void 0 : _a.call(entity))) {
-          return;
-        }
-        if (!filterFunc) {
-          filteredNameList.push(namePath);
-        } else {
-          const meta = "getMeta" in entity ? entity.getMeta() : null;
-          if (filterFunc(meta)) {
-            filteredNameList.push(namePath);
+    });
+
+    // Reset
+    var resetWithFields = function resetWithFields(entities) {
+      entities.forEach(function (field) {
+        var initialValue = field.props.initialValue;
+        if (initialValue !== undefined) {
+          var namePath = field.getNamePath();
+          var formInitialValue = _this.getInitialValue(namePath);
+          if (formInitialValue !== undefined) {
+            // Warning if conflict with form initialValues and do not modify value
+            warning(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) {
+              // Warning if multiple field set `initialValue`and do not modify value
+              warning(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);
+              // Set `initialValue`
+              if (!info.skipExist || originValue === undefined) {
+                _this.updateStore(setValue(_this.store, namePath, _toConsumableArray(records)[0].value));
+              }
+            }
           }
         }
       });
-      return (0, import_valueUtil.cloneByNamePathList)(this.store, filteredNameList.map(import_valueUtil.getNamePath));
     };
-    this.getFieldValue = (name) => {
-      this.warningUnhooked();
-      const namePath = (0, import_valueUtil.getNamePath)(name);
-      return (0, import_valueUtil.getValue)(this.store, namePath);
-    };
-    this.getFieldsError = (nameList) => {
-      this.warningUnhooked();
-      const fieldEntities = this.getFieldEntitiesForNamePathList(nameList);
-      return fieldEntities.map((entity, index) => {
-        if (entity && !("INVALIDATE_NAME_PATH" in entity)) {
-          return {
-            name: entity.getNamePath(),
-            errors: entity.getErrors(),
-            warnings: entity.getWarnings()
-          };
+    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;
+          })));
         }
-        return {
-          name: (0, import_valueUtil.getNamePath)(nameList[index]),
-          errors: [],
-          warnings: []
-        };
       });
-    };
-    this.getFieldError = (name) => {
-      this.warningUnhooked();
-      const namePath = (0, import_valueUtil.getNamePath)(name);
-      const fieldError = this.getFieldsError([namePath])[0];
-      return fieldError.errors;
-    };
-    this.getFieldWarning = (name) => {
-      this.warningUnhooked();
-      const namePath = (0, import_valueUtil.getNamePath)(name);
-      const fieldError = this.getFieldsError([namePath])[0];
-      return fieldError.warnings;
-    };
-    this.isFieldsTouched = (...args) => {
-      this.warningUnhooked();
-      const [arg0, arg1] = args;
-      let namePathList;
-      let isAllFieldsTouched = false;
-      if (args.length === 0) {
-        namePathList = null;
-      } else if (args.length === 1) {
-        if (Array.isArray(arg0)) {
-          namePathList = arg0.map(import_valueUtil.getNamePath);
-          isAllFieldsTouched = false;
-        } else {
-          namePathList = null;
-          isAllFieldsTouched = arg0;
-        }
-      } else {
-        namePathList = arg0.map(import_valueUtil.getNamePath);
-        isAllFieldsTouched = arg1;
-      }
-      const fieldEntities = this.getFieldEntities(true);
-      const isFieldTouched = (field) => field.isFieldTouched();
-      if (!namePathList) {
-        return isAllFieldsTouched ? fieldEntities.every(isFieldTouched) : fieldEntities.some(isFieldTouched);
-      }
-      const map = new import_NameMap.default();
-      namePathList.forEach((shortNamePath) => {
-        map.set(shortNamePath, []);
-      });
-      fieldEntities.forEach((field) => {
-        const fieldNamePath = field.getNamePath();
-        namePathList.forEach((shortNamePath) => {
-          if (shortNamePath.every((nameUnit, i) => fieldNamePath[i] === nameUnit)) {
-            map.update(shortNamePath, (list) => [...list, field]);
-          }
-        });
+    } else {
+      requiredFieldEntities = fieldEntities;
+    }
+    resetWithFields(requiredFieldEntities);
+  });
+  _defineProperty(this, "resetFields", function (nameList) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    if (!nameList) {
+      _this.updateStore(setValues({}, _this.initialValues));
+      _this.resetWithFieldInitialValue();
+      _this.notifyObservers(prevStore, null, {
+        type: 'reset'
       });
-      const isNamePathListTouched = (entities) => entities.some(isFieldTouched);
-      const namePathListEntities = map.map(({ value }) => value);
-      return isAllFieldsTouched ? namePathListEntities.every(isNamePathListTouched) : namePathListEntities.some(isNamePathListTouched);
-    };
-    this.isFieldTouched = (name) => {
-      this.warningUnhooked();
-      return this.isFieldsTouched([name]);
-    };
-    this.isFieldsValidating = (nameList) => {
-      this.warningUnhooked();
-      const fieldEntities = this.getFieldEntities();
-      if (!nameList) {
-        return fieldEntities.some((testField) => testField.isFieldValidating());
+      _this.notifyWatch();
+      return;
+    }
+
+    // Reset by `nameList`
+    var namePathList = nameList.map(getNamePath);
+    namePathList.forEach(function (namePath) {
+      var initialValue = _this.getInitialValue(namePath);
+      _this.updateStore(setValue(_this.store, namePath, initialValue));
+    });
+    _this.resetWithFieldInitialValue({
+      namePathList: namePathList
+    });
+    _this.notifyObservers(prevStore, namePathList, {
+      type: 'reset'
+    });
+    _this.notifyWatch(namePathList);
+  });
+  _defineProperty(this, "setFields", function (fields) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    var namePathList = [];
+    fields.forEach(function (fieldData) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      var name = fieldData.name,
+        errors = fieldData.errors,
+        data = _objectWithoutProperties(fieldData, _excluded);
+      var namePath = getNamePath(name);
+      namePathList.push(namePath);
+
+      // Value
+      if ('value' in data) {
+        _this.updateStore(setValue(_this.store, namePath, data.value));
       }
-      const namePathList = nameList.map(import_valueUtil.getNamePath);
-      return fieldEntities.some((testField) => {
-        const fieldNamePath = testField.getNamePath();
-        return (0, import_valueUtil.containsNamePath)(namePathList, fieldNamePath) && testField.isFieldValidating();
+      _this.notifyObservers(prevStore, [namePath], {
+        type: 'setField',
+        data: fieldData
       });
-    };
-    this.isFieldValidating = (name) => {
-      this.warningUnhooked();
-      return this.isFieldsValidating([name]);
-    };
-    /**
-     * Reset Field with field `initialValue` prop.
-     * Can pass `entities` or `namePathList` or just nothing.
-     */
-    this.resetWithFieldInitialValue = (info = {}) => {
-      const cache = new import_NameMap.default();
-      const fieldEntities = this.getFieldEntities(true);
-      fieldEntities.forEach((field) => {
-        const { initialValue } = field.props;
-        const namePath = field.getNamePath();
-        if (initialValue !== void 0) {
-          const records = cache.get(namePath) || /* @__PURE__ */ new Set();
-          records.add({ entity: field, value: initialValue });
-          cache.set(namePath, records);
-        }
+    });
+    _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 = _objectSpread(_objectSpread({}, meta), {}, {
+        name: namePath,
+        value: _this.getFieldValue(namePath)
       });
-      const resetWithFields = (entities) => {
-        entities.forEach((field) => {
-          const { initialValue } = field.props;
-          if (initialValue !== void 0) {
-            const namePath = field.getNamePath();
-            const formInitialValue = this.getInitialValue(namePath);
-            if (formInitialValue !== void 0) {
-              (0, import_Util.warning)(false, `Form already set 'initialValues' with path '${namePath.join(".")}'. Field can not overwrite it.`);
-            } else {
-              const records = cache.get(namePath);
-              if (records && records.size > 1) {
-                (0, import_Util.warning)(false, `Multiple Field with path '${namePath.join(".")}' set 'initialValue'. Can not decide which one to pick.`);
-              } else if (records) {
-                const originValue = this.getFieldValue(namePath);
-                if (!info.skipExist || originValue === void 0) {
-                  this.updateStore((0, import_valueUtil.setValue)(this.store, namePath, [...records][0].value));
-                }
-              }
-            }
-          }
-        });
-      };
-      let requiredFieldEntities;
-      if (info.entities) {
-        requiredFieldEntities = info.entities;
-      } else if (info.namePathList) {
-        requiredFieldEntities = [];
-        info.namePathList.forEach((namePath) => {
-          const records = cache.get(namePath);
-          if (records) {
-            requiredFieldEntities.push(...[...records].map((r) => r.entity));
-          }
-        });
-      } else {
-        requiredFieldEntities = fieldEntities;
-      }
-      resetWithFields(requiredFieldEntities);
-    };
-    this.resetFields = (nameList) => {
-      this.warningUnhooked();
-      const prevStore = this.store;
-      if (!nameList) {
-        this.updateStore((0, import_valueUtil.setValues)({}, this.initialValues));
-        this.resetWithFieldInitialValue();
-        this.notifyObservers(prevStore, null, { type: "reset" });
-        this.notifyWatch();
-        return;
+      Object.defineProperty(fieldData, 'originRCField', {
+        value: true
+      });
+      return fieldData;
+    });
+    return fields;
+  });
+  // =========================== Observer ===========================
+  /**
+   * This only trigger when a field is on constructor to avoid we get initialValue too late
+   */
+  _defineProperty(this, "initEntityValue", function (entity) {
+    var initialValue = entity.props.initialValue;
+    if (initialValue !== undefined) {
+      var namePath = entity.getNamePath();
+      var prevValue = getValue(_this.store, namePath);
+      if (prevValue === undefined) {
+        _this.updateStore(setValue(_this.store, namePath, initialValue));
       }
-      const namePathList = nameList.map(import_valueUtil.getNamePath);
-      namePathList.forEach((namePath) => {
-        const initialValue = this.getInitialValue(namePath);
-        this.updateStore((0, import_valueUtil.setValue)(this.store, namePath, initialValue));
+    }
+  });
+  _defineProperty(this, "isMergedPreserve", function (fieldPreserve) {
+    var mergedPreserve = fieldPreserve !== undefined ? 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]);
+
+    // Set initial values
+    if (entity.props.initialValue !== undefined) {
+      var prevStore = _this.store;
+      _this.resetWithFieldInitialValue({
+        entities: [entity],
+        skipExist: true
       });
-      this.resetWithFieldInitialValue({ namePathList });
-      this.notifyObservers(prevStore, namePathList, { type: "reset" });
-      this.notifyWatch(namePathList);
-    };
-    this.setFields = (fields) => {
-      this.warningUnhooked();
-      const prevStore = this.store;
-      const namePathList = [];
-      fields.forEach((fieldData) => {
-        const { name, errors, ...data } = fieldData;
-        const namePath = (0, import_valueUtil.getNamePath)(name);
-        namePathList.push(namePath);
-        if ("value" in data) {
-          this.updateStore((0, import_valueUtil.setValue)(this.store, namePath, data.value));
-        }
-        this.notifyObservers(prevStore, [namePath], {
-          type: "setField",
-          data: fieldData
-        });
+      _this.notifyObservers(prevStore, [entity.getNamePath()], {
+        type: 'valueUpdate',
+        source: 'internal'
       });
-      this.notifyWatch(namePathList);
-    };
-    this.getFields = () => {
-      const entities = this.getFieldEntities(true);
-      const fields = entities.map((field) => {
-        const namePath = field.getNamePath();
-        const meta = field.getMeta();
-        const fieldData = {
-          ...meta,
-          name: namePath,
-          value: this.getFieldValue(namePath)
-        };
-        Object.defineProperty(fieldData, "originRCField", {
-          value: true
-        });
-        return fieldData;
+    }
+
+    // un-register field callback
+    return function (isListField, preserve) {
+      var subNamePath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      _this.fieldEntities = _this.fieldEntities.filter(function (item) {
+        return item !== entity;
       });
-      return fields;
-    };
-    // =========================== Observer ===========================
-    /**
-     * This only trigger when a field is on constructor to avoid we get initialValue too late
-     */
-    this.initEntityValue = (entity) => {
-      const { initialValue } = entity.props;
-      if (initialValue !== void 0) {
-        const namePath = entity.getNamePath();
-        const prevValue = (0, import_valueUtil.getValue)(this.store, namePath);
-        if (prevValue === void 0) {
-          this.updateStore((0, import_valueUtil.setValue)(this.store, namePath, initialValue));
+
+      // Clean up store value if not preserve
+      if (!_this.isMergedPreserve(preserve) && (!isListField || subNamePath.length > 1)) {
+        var defaultValue = isListField ? undefined : _this.getInitialValue(namePath);
+        if (namePath.length && _this.getFieldValue(namePath) !== defaultValue && _this.fieldEntities.every(function (field) {
+          return (
+            // Only reset when no namePath exist
+            !matchNamePath(field.getNamePath(), namePath)
+          );
+        })) {
+          var _prevStore = _this.store;
+          _this.updateStore(setValue(_prevStore, namePath, defaultValue, true));
+
+          // Notify that field is unmount
+          _this.notifyObservers(_prevStore, [namePath], {
+            type: 'remove'
+          });
+
+          // Dependencies update
+          _this.triggerDependenciesUpdate(_prevStore, namePath);
         }
       }
+      _this.notifyWatch([namePath]);
     };
-    this.isMergedPreserve = (fieldPreserve) => {
-      const mergedPreserve = fieldPreserve !== void 0 ? fieldPreserve : this.preserve;
-      return mergedPreserve ?? true;
-    };
-    this.registerField = (entity) => {
-      this.fieldEntities.push(entity);
-      const namePath = entity.getNamePath();
-      this.notifyWatch([namePath]);
-      if (entity.props.initialValue !== void 0) {
-        const prevStore = this.store;
-        this.resetWithFieldInitialValue({ entities: [entity], skipExist: true });
-        this.notifyObservers(prevStore, [entity.getNamePath()], {
-          type: "valueUpdate",
-          source: "internal"
-        });
-      }
-      return (isListField, preserve, subNamePath = []) => {
-        this.fieldEntities = this.fieldEntities.filter((item) => item !== entity);
-        if (!this.isMergedPreserve(preserve) && (!isListField || subNamePath.length > 1)) {
-          const defaultValue = isListField ? void 0 : this.getInitialValue(namePath);
-          if (namePath.length && this.getFieldValue(namePath) !== defaultValue && this.fieldEntities.every(
-            (field) => (
-              // Only reset when no namePath exist
-              !(0, import_valueUtil.matchNamePath)(field.getNamePath(), namePath)
-            )
-          )) {
-            const prevStore = this.store;
-            this.updateStore((0, import_valueUtil.setValue)(prevStore, namePath, defaultValue, true));
-            this.notifyObservers(prevStore, [namePath], { type: "remove" });
-            this.triggerDependenciesUpdate(prevStore, namePath);
-          }
-        }
-        this.notifyWatch([namePath]);
-      };
-    };
-    this.dispatch = (action) => {
-      switch (action.type) {
-        case "updateValue": {
-          const { namePath, value } = action;
-          this.updateValue(namePath, value);
+  });
+  _defineProperty(this, "dispatch", function (action) {
+    switch (action.type) {
+      case 'updateValue':
+        {
+          var namePath = action.namePath,
+            value = action.value;
+          _this.updateValue(namePath, value);
           break;
         }
-        case "validateField": {
-          const { namePath, triggerName } = action;
-          this.validateFields([namePath], { triggerName });
+      case 'validateField':
+        {
+          var _namePath = action.namePath,
+            triggerName = action.triggerName;
+          _this.validateFields([_namePath], {
+            triggerName: triggerName
+          });
           break;
         }
-        default:
-      }
-    };
-    this.notifyObservers = (prevStore, namePathList, info) => {
-      if (this.subscribable) {
-        const mergedInfo = {
-          ...info,
-          store: this.getFieldsValue(true)
-        };
-        this.getFieldEntities().forEach(({ onStoreChange }) => {
-          onStoreChange(prevStore, namePathList, mergedInfo);
-        });
-      } else {
-        this.forceRootUpdate();
-      }
-    };
-    /**
-     * Notify dependencies children with parent update
-     * We need delay to trigger validate in case Field is under render props
-     */
-    this.triggerDependenciesUpdate = (prevStore, namePath) => {
-      const childrenFields = this.getDependencyChildrenFields(namePath);
-      if (childrenFields.length) {
-        this.validateFields(childrenFields);
-      }
-      this.notifyObservers(prevStore, childrenFields, {
-        type: "dependenciesUpdate",
-        relatedFields: [namePath, ...childrenFields]
+      default:
+      // Currently we don't have other action. Do nothing.
+    }
+  });
+  _defineProperty(this, "notifyObservers", function (prevStore, namePathList, info) {
+    if (_this.subscribable) {
+      var mergedInfo = _objectSpread(_objectSpread({}, info), {}, {
+        store: _this.getFieldsValue(true)
       });
-      return childrenFields;
-    };
-    this.updateValue = (name, value) => {
-      const namePath = (0, import_valueUtil.getNamePath)(name);
-      const prevStore = this.store;
-      this.updateStore((0, import_valueUtil.setValue)(this.store, namePath, value));
-      this.notifyObservers(prevStore, [namePath], {
-        type: "valueUpdate",
-        source: "internal"
+      _this.getFieldEntities().forEach(function (_ref4) {
+        var onStoreChange = _ref4.onStoreChange;
+        onStoreChange(prevStore, namePathList, mergedInfo);
       });
-      this.notifyWatch([namePath]);
-      const childrenFields = this.triggerDependenciesUpdate(prevStore, namePath);
-      const { onValuesChange } = this.callbacks;
-      if (onValuesChange) {
-        const changedValues = (0, import_valueUtil.cloneByNamePathList)(this.store, [namePath]);
-        onValuesChange(changedValues, this.getFieldsValue());
-      }
-      this.triggerOnFieldsChange([namePath, ...childrenFields]);
-    };
-    // Let all child Field get update.
-    this.setFieldsValue = (store) => {
-      this.warningUnhooked();
-      const prevStore = this.store;
-      if (store) {
-        const nextStore = (0, import_valueUtil.setValues)(this.store, store);
-        this.updateStore(nextStore);
-      }
-      this.notifyObservers(prevStore, null, {
-        type: "valueUpdate",
-        source: "external"
+    } else {
+      _this.forceRootUpdate();
+    }
+  });
+  /**
+   * Notify dependencies children with parent update
+   * We need delay to trigger validate in case Field is under render props
+   */
+  _defineProperty(this, "triggerDependenciesUpdate", function (prevStore, namePath) {
+    var childrenFields = _this.getDependencyChildrenFields(namePath);
+    if (childrenFields.length) {
+      _this.validateFields(childrenFields);
+    }
+    _this.notifyObservers(prevStore, childrenFields, {
+      type: 'dependenciesUpdate',
+      relatedFields: [namePath].concat(_toConsumableArray(childrenFields))
+    });
+    return childrenFields;
+  });
+  _defineProperty(this, "updateValue", function (name, value) {
+    var namePath = getNamePath(name);
+    var prevStore = _this.store;
+    _this.updateStore(setValue(_this.store, namePath, value));
+    _this.notifyObservers(prevStore, [namePath], {
+      type: 'valueUpdate',
+      source: 'internal'
+    });
+    _this.notifyWatch([namePath]);
+
+    // Dependencies update
+    var childrenFields = _this.triggerDependenciesUpdate(prevStore, namePath);
+
+    // trigger callback function
+    var onValuesChange = _this.callbacks.onValuesChange;
+    if (onValuesChange) {
+      var changedValues = cloneByNamePathList(_this.store, [namePath]);
+      onValuesChange(changedValues, _this.getFieldsValue());
+    }
+    _this.triggerOnFieldsChange([namePath].concat(_toConsumableArray(childrenFields)));
+  });
+  // Let all child Field get update.
+  _defineProperty(this, "setFieldsValue", function (store) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    if (store) {
+      var nextStore = setValues(_this.store, store);
+      _this.updateStore(nextStore);
+    }
+    _this.notifyObservers(prevStore, null, {
+      type: 'valueUpdate',
+      source: 'external'
+    });
+    _this.notifyWatch();
+  });
+  _defineProperty(this, "setFieldValue", function (name, value) {
+    _this.setFields([{
+      name: name,
+      value: value
+    }]);
+  });
+  _defineProperty(this, "getDependencyChildrenFields", function (rootNamePath) {
+    var children = new Set();
+    var childrenFields = [];
+    var dependencies2fields = new NameMap();
+
+    /**
+     * Generate maps
+     * Can use cache to save perf if user report performance issue with this
+     */
+    _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] !== undefined ? arguments[0] : new Set();
+          fields.add(field);
+          return fields;
+        });
       });
-      this.notifyWatch();
-    };
-    this.setFieldValue = (name, value) => {
-      this.setFields([
-        {
-          name,
-          value
+    });
+    var fillChildren = function fillChildren(namePath) {
+      var fields = dependencies2fields.get(namePath) || 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);
+            fillChildren(fieldNamePath);
+          }
         }
-      ]);
+      });
     };
-    this.getDependencyChildrenFields = (rootNamePath) => {
-      const children = /* @__PURE__ */ new Set();
-      const childrenFields = [];
-      const dependencies2fields = new import_NameMap.default();
-      this.getFieldEntities().forEach((field) => {
-        const { dependencies } = field.props;
-        (dependencies || []).forEach((dependency) => {
-          const dependencyNamePath = (0, import_valueUtil.getNamePath)(dependency);
-          dependencies2fields.update(dependencyNamePath, (fields = /* @__PURE__ */ new Set()) => {
-            fields.add(field);
-            return fields;
-          });
+    fillChildren(rootNamePath);
+    return childrenFields;
+  });
+  _defineProperty(this, "triggerOnFieldsChange", function (namePathList, filedErrors) {
+    var onFieldsChange = _this.callbacks.onFieldsChange;
+    if (onFieldsChange) {
+      var fields = _this.getFields();
+
+      /**
+       * Fill errors since `fields` may be replaced by controlled fields
+       */
+      if (filedErrors) {
+        var cache = new NameMap();
+        filedErrors.forEach(function (_ref5) {
+          var name = _ref5.name,
+            errors = _ref5.errors;
+          cache.set(name, errors);
         });
-      });
-      const fillChildren = (namePath) => {
-        const fields = dependencies2fields.get(namePath) || /* @__PURE__ */ new Set();
-        fields.forEach((field) => {
-          if (!children.has(field)) {
-            children.add(field);
-            const fieldNamePath = field.getNamePath();
-            if (field.isFieldDirty() && fieldNamePath.length) {
-              childrenFields.push(fieldNamePath);
-              fillChildren(fieldNamePath);
-            }
-          }
+        fields.forEach(function (field) {
+          // eslint-disable-next-line no-param-reassign
+          field.errors = cache.get(field.name) || field.errors;
         });
-      };
-      fillChildren(rootNamePath);
-      return childrenFields;
-    };
-    this.triggerOnFieldsChange = (namePathList, filedErrors) => {
-      const { onFieldsChange } = this.callbacks;
-      if (onFieldsChange) {
-        const fields = this.getFields();
-        if (filedErrors) {
-          const cache = new import_NameMap.default();
-          filedErrors.forEach(({ name, errors }) => {
-            cache.set(name, errors);
-          });
-          fields.forEach((field) => {
-            field.errors = cache.get(field.name) || field.errors;
-          });
-        }
-        const changedFields = fields.filter(({ name: fieldName }) => (0, import_valueUtil.containsNamePath)(namePathList, fieldName));
-        onFieldsChange(changedFields, fields);
       }
-    };
-    // =========================== Validate ===========================
-    this.validateFields = (nameList, options) => {
-      this.warningUnhooked();
-      const provideNameList = !!nameList;
-      const namePathList = provideNameList ? nameList.map(import_valueUtil.getNamePath) : [];
-      const promiseList = [];
-      this.getFieldEntities(true).forEach((field) => {
-        var _a;
-        if (!provideNameList) {
-          namePathList.push(field.getNamePath());
-        }
-        if ((options == null ? void 0 : options.recursive) && provideNameList) {
-          const namePath = field.getNamePath();
-          if (
-            // nameList[i] === undefined 说明是以 nameList 开头的
-            // ['name'] -> ['name','list']
-            namePath.every((nameUnit, i) => nameList[i] === nameUnit || nameList[i] === void 0)
-          ) {
-            namePathList.push(namePath);
-          }
-        }
-        if (!field.props.rules || !field.props.rules.length) {
-          return;
+      var changedFields = fields.filter(function (_ref6) {
+        var fieldName = _ref6.name;
+        return containsNamePath(namePathList, fieldName);
+      });
+      onFieldsChange(changedFields, fields);
+    }
+  });
+  // =========================== Validate ===========================
+  _defineProperty(this, "validateFields", function (nameList, options) {
+    _this.warningUnhooked();
+    var provideNameList = !!nameList;
+    var namePathList = provideNameList ? nameList.map(getNamePath) : [];
+
+    // Collect result in promise list
+    var promiseList = [];
+    _this.getFieldEntities(true).forEach(function (field) {
+      // Add field if not provide `nameList`
+      if (!provideNameList) {
+        namePathList.push(field.getNamePath());
+      }
+
+      /**
+       * Recursive validate if configured.
+       * TODO: perf improvement @zombieJ
+       */
+      if (options !== null && options !== void 0 && options.recursive && provideNameList) {
+        var namePath = field.getNamePath();
+        if (
+        // nameList[i] === undefined 说明是以 nameList 开头的
+        // ['name'] -> ['name','list']
+        namePath.every(function (nameUnit, i) {
+          return nameList[i] === nameUnit || nameList[i] === undefined;
+        })) {
+          namePathList.push(namePath);
         }
-        const fieldNamePath = field.getNamePath();
-        if (!provideNameList || (0, import_valueUtil.containsNamePath)(namePathList, fieldNamePath)) {
-          const promise = field.validateRules({
-            validateMessages: {
-              ...import_messages.defaultValidateMessages,
-              ...this.validateMessages
-            },
-            label: typeof ((_a = field == null ? void 0 : field.props) == null ? void 0 : _a.label) === "string" ? field.props.label : "",
-            ...options
+      }
+
+      // Skip if without rule
+      if (!field.props.rules || !field.props.rules.length) {
+        return;
+      }
+      var fieldNamePath = field.getNamePath();
+      // Add field validate rule in to promise list
+      if (!provideNameList || containsNamePath(namePathList, fieldNamePath)) {
+        var _field$props;
+        var promise = field.validateRules(_objectSpread({
+          validateMessages: _objectSpread(_objectSpread({}, defaultValidateMessages), _this.validateMessages),
+          label: typeof (field === null || field === void 0 || (_field$props = field.props) === null || _field$props === void 0 ? void 0 : _field$props.label) === 'string' ? field.props.label : ''
+        }, options));
+
+        // Wrap promise with field
+        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 (_ref7) {
+            var warningOnly = _ref7.rule.warningOnly,
+              errors = _ref7.errors;
+            if (warningOnly) {
+              mergedWarnings.push.apply(mergedWarnings, _toConsumableArray(errors));
+            } else {
+              mergedErrors.push.apply(mergedErrors, _toConsumableArray(errors));
+            }
           });
-          promiseList.push(
-            promise.then(() => ({ name: fieldNamePath, errors: [], warnings: [] })).catch((ruleErrors) => {
-              var _a2;
-              const mergedErrors = [];
-              const mergedWarnings = [];
-              (_a2 = ruleErrors.forEach) == null ? void 0 : _a2.call(ruleErrors, ({ rule: { warningOnly }, errors }) => {
-                if (warningOnly) {
-                  mergedWarnings.push(...errors);
-                } else {
-                  mergedErrors.push(...errors);
-                }
-              });
-              if (mergedErrors.length) {
-                return Promise.reject({
-                  name: fieldNamePath,
-                  errors: mergedErrors,
-                  warnings: mergedWarnings
-                });
-              }
-              return {
-                name: fieldNamePath,
-                errors: mergedErrors,
-                warnings: mergedWarnings
-              };
-            })
-          );
-        }
+          if (mergedErrors.length) {
+            return Promise.reject({
+              name: fieldNamePath,
+              errors: mergedErrors,
+              warnings: mergedWarnings
+            });
+          }
+          return {
+            name: fieldNamePath,
+            errors: mergedErrors,
+            warnings: mergedWarnings
+          };
+        }));
+      }
+    });
+    var summaryPromise = allPromiseFinish(promiseList);
+    _this.lastValidatePromise = summaryPromise;
+
+    // Notify fields with rule that validate has finished and need update
+    summaryPromise.catch(function (results) {
+      return results;
+    }).then(function (results) {
+      var resultNamePathList = results.map(function (_ref8) {
+        var name = _ref8.name;
+        return name;
       });
-      const summaryPromise = (0, import_asyncUtil.allPromiseFinish)(promiseList);
-      this.lastValidatePromise = summaryPromise;
-      summaryPromise.catch((results) => results).then((results) => {
-        const resultNamePathList = results.map(({ name }) => name);
-        this.notifyObservers(this.store, resultNamePathList, {
-          type: "validateFinish"
-        });
-        this.triggerOnFieldsChange(resultNamePathList, results);
+      _this.notifyObservers(_this.store, resultNamePathList, {
+        type: 'validateFinish'
       });
-      const returnPromise = summaryPromise.then(() => {
-        if (this.lastValidatePromise === summaryPromise) {
-          return Promise.resolve(this.getFieldsValue(namePathList));
-        }
-        return Promise.reject([]);
-      }).catch((results) => {
-        const errorList = results.filter((result) => result && result.errors.length);
-        return Promise.reject({
-          values: this.getFieldsValue(namePathList),
-          errorFields: errorList,
-          outOfDate: this.lastValidatePromise !== summaryPromise
-        });
+      _this.triggerOnFieldsChange(resultNamePathList, results);
+    });
+    var returnPromise = summaryPromise.then(function () {
+      if (_this.lastValidatePromise === summaryPromise) {
+        return Promise.resolve(_this.getFieldsValue(namePathList));
+      }
+      return Promise.reject([]);
+    }).catch(function (results) {
+      var _this$getFieldsMap$ge2;
+      var fieldContext = (_this$getFieldsMap$ge2 = _this.getFieldsMap().get(results[0].name)) === null || _this$getFieldsMap$ge2 === void 0 || (_this$getFieldsMap$ge2 = _this$getFieldsMap$ge2.props) === null || _this$getFieldsMap$ge2 === void 0 ? void 0 : _this$getFieldsMap$ge2.fieldContext;
+      if (fieldContext !== null && fieldContext !== void 0 && fieldContext.scrollToError) {
+        _this.scrollToField(results[0].name);
+      }
+      var errorList = results.filter(function (result) {
+        return result && result.errors.length;
       });
-      returnPromise.catch((e) => e);
-      return returnPromise;
-    };
-    // ============================ Submit ============================
-    this.submit = () => {
-      this.warningUnhooked();
-      this.validateFields().then((values) => {
-        const { onFinish } = this.callbacks;
-        if (onFinish) {
-          try {
-            onFinish(values);
-          } catch (err) {
-            console.error(err);
-          }
-        }
-      }).catch((e) => {
-        const { onFinishFailed } = this.callbacks;
-        if (onFinishFailed) {
-          onFinishFailed(e);
-        }
+      return Promise.reject({
+        values: _this.getFieldsValue(namePathList),
+        errorFields: errorList,
+        outOfDate: _this.lastValidatePromise !== summaryPromise
       });
-    };
-    this.forceRootUpdate = forceRootUpdate;
-  }
-};
+    });
+
+    // Do not throw in console
+    returnPromise.catch(function (e) {
+      return e;
+    });
+    return returnPromise;
+  });
+  // ============================ Submit ============================
+  _defineProperty(this, "submit", function () {
+    _this.warningUnhooked();
+    _this.validateFields().then(function (values) {
+      var onFinish = _this.callbacks.onFinish;
+      if (onFinish) {
+        try {
+          onFinish(values);
+        } catch (err) {
+          // Should print error if user `onFinish` callback failed
+          // eslint-disable-next-line no-console
+          console.error(err);
+        }
+      }
+    }).catch(function (e) {
+      var onFinishFailed = _this.callbacks.onFinishFailed;
+      if (onFinishFailed) {
+        onFinishFailed(e);
+      }
+    });
+  });
+  this.forceRootUpdate = forceRootUpdate;
+});
 function useForm(form) {
-  const formRef = (0, import_react.useRef)();
-  const [, forceUpdate] = (0, import_react.useState)({});
+  var formRef = useRef(null);
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    forceUpdate = _useState2[1];
   if (!formRef.current) {
     if (form) {
       formRef.current = form;
     } else {
-      const forceReRender = () => {
+      // Create a new FormStore if not provided
+      var forceReRender = function forceReRender() {
         forceUpdate({});
       };
-      const formStore = new FormStore(forceReRender);
+      var formStore = new FormStore(forceReRender);
       formRef.current = formStore.getForm();
     }
   }
   return [formRef.current];
 }
-var useForm_default = useForm;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FormStore
-});
+export default useForm;