@easyv/biz-components 1.0.20 → 1.0.22

package/dist/node_modules/.pnpm/rc-field-form@1.27.4_react-dom@18.2.0_react@18.2.0__react@18.2.0/node_modules/rc-field-form/es/useForm.es.js

@@ -0,0 +1,742 @@
+import _slicedToArray from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/slicedToArray.es.js";
+import _objectSpread2 from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/objectSpread2.es.js";
+import _objectWithoutProperties from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.es.js";
+import _toConsumableArray from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/toConsumableArray.es.js";
+import _createClass from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/createClass.es.js";
+import _classCallCheck from "../../../../@babel_runtime@7.27.0/node_modules/@babel/runtime/helpers/esm/classCallCheck.es.js";
+import { warningOnce } from "../../../../rc-util@5.44.4_react-dom@18.2.0_react@18.2.0__react@18.2.0/node_modules/rc-util/es/warning.es.js";
+import * as React from "react";
+import { HOOK_MARK } from "./FieldContext.es.js";
+import { allPromiseFinish } from "./utils/asyncUtil.es.js";
+import cloneDeep from "./utils/cloneDeep.es.js";
+import { defaultValidateMessages } from "./utils/messages.es.js";
+import NameMap from "./utils/NameMap.es.js";
+import { setValues, setValue, getValue, getNamePath, cloneByNamePathList, containsNamePath, matchNamePath } from "./utils/valueUtil.es.js";
+var _excluded = ["name", "errors"];
+var FormStore = /* @__PURE__ */ _createClass(function FormStore2(forceRootUpdate) {
+  var _this = this;
+  _classCallCheck(this, FormStore2);
+  this.formHooked = false;
+  this.forceRootUpdate = void 0;
+  this.subscribable = true;
+  this.store = {};
+  this.fieldEntities = [];
+  this.initialValues = {};
+  this.callbacks = {};
+  this.validateMessages = null;
+  this.preserve = null;
+  this.lastValidatePromise = null;
+  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,
+      getInternalHooks: _this.getInternalHooks
+    };
+  };
+  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;
+  };
+  this.useSubscribe = function(subscribable) {
+    _this.subscribable = subscribable;
+  };
+  this.prevWithoutPreserves = null;
+  this.setInitialValues = function(initialValues, init) {
+    _this.initialValues = initialValues || {};
+    if (init) {
+      var _this$prevWithoutPres;
+      var nextStore = setValues({}, initialValues, _this.store);
+      (_this$prevWithoutPres = _this.prevWithoutPreserves) === null || _this$prevWithoutPres === void 0 ? void 0 : _this$prevWithoutPres.map(function(_ref) {
+        var namePath = _ref.key;
+        nextStore = setValue(nextStore, namePath, getValue(initialValues, namePath));
+      });
+      _this.prevWithoutPreserves = null;
+      _this.updateStore(nextStore);
+    }
+  };
+  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;
+  };
+  this.getInitialValue = function(namePath) {
+    var initValue = getValue(_this.initialValues, namePath);
+    return namePath.length ? cloneDeep(initValue) : initValue;
+  };
+  this.setCallbacks = function(callbacks) {
+    _this.callbacks = callbacks;
+  };
+  this.setValidateMessages = function(validateMessages) {
+    _this.validateMessages = validateMessages;
+  };
+  this.setPreserve = function(preserve) {
+    _this.preserve = preserve;
+  };
+  this.watchList = [];
+  this.registerWatch = function(callback) {
+    _this.watchList.push(callback);
+    return function() {
+      _this.watchList = _this.watchList.filter(function(fn) {
+        return fn !== callback;
+      });
+    };
+  };
+  this.notifyWatch = function() {
+    var namePath = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    if (_this.watchList.length) {
+      var values = _this.getFieldsValue();
+      _this.watchList.forEach(function(callback) {
+        callback(values, namePath);
+      });
+    }
+  };
+  this.timeoutId = null;
+  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?");
+        }
+      });
+    }
+  };
+  this.updateStore = function(nextStore) {
+    _this.store = nextStore;
+  };
+  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;
+    });
+  };
+  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;
+  };
+  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.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 _entity$isListField;
+      var namePath = "INVALIDATE_NAME_PATH" in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
+      if (!nameList && ((_entity$isListField = entity.isListField) === null || _entity$isListField === void 0 ? void 0 : _entity$isListField.call(entity))) {
+        return;
+      }
+      if (!filterFunc) {
+        filteredNameList.push(namePath);
+      } else {
+        var meta = "getMeta" in entity ? entity.getMeta() : null;
+        if (filterFunc(meta)) {
+          filteredNameList.push(namePath);
+        }
+      }
+    });
+    return cloneByNamePathList(_this.store, filteredNameList.map(getNamePath));
+  };
+  this.getFieldValue = function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    return getValue(_this.store, namePath);
+  };
+  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: []
+      };
+    });
+  };
+  this.getFieldError = function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    var fieldError = _this.getFieldsError([namePath])[0];
+    return fieldError.errors;
+  };
+  this.getFieldWarning = function(name) {
+    _this.warningUnhooked();
+    var namePath = getNamePath(name);
+    var fieldError = _this.getFieldsError([namePath])[0];
+    return fieldError.warnings;
+  };
+  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 (!namePathList) {
+      return isAllFieldsTouched ? fieldEntities.every(isFieldTouched) : 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 isNamePathListTouched = function isNamePathListTouched2(entities) {
+      return entities.some(isFieldTouched);
+    };
+    var namePathListEntities = map.map(function(_ref2) {
+      var value = _ref2.value;
+      return value;
+    });
+    return isAllFieldsTouched ? namePathListEntities.every(isNamePathListTouched) : namePathListEntities.some(isNamePathListTouched);
+  };
+  this.isFieldTouched = function(name) {
+    _this.warningUnhooked();
+    return _this.isFieldsTouched([name]);
+  };
+  this.isFieldsValidating = function(nameList) {
+    _this.warningUnhooked();
+    var fieldEntities = _this.getFieldEntities();
+    if (!nameList) {
+      return fieldEntities.some(function(testField) {
+        return testField.isFieldValidating();
+      });
+    }
+    var namePathList = nameList.map(getNamePath);
+    return fieldEntities.some(function(testField) {
+      var fieldNamePath = testField.getNamePath();
+      return containsNamePath(namePathList, fieldNamePath) && testField.isFieldValidating();
+    });
+  };
+  this.isFieldValidating = function(name) {
+    _this.warningUnhooked();
+    return _this.isFieldsValidating([name]);
+  };
+  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 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);
+              if (!info.skipExist || originValue === void 0) {
+                _this.updateStore(setValue(_this.store, namePath, _toConsumableArray(records)[0].value));
+              }
+            }
+          }
+        }
+      });
+    };
+    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);
+  };
+  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"
+      });
+      _this.notifyWatch();
+      return;
+    }
+    var namePathList = nameList.map(getNamePath);
+    namePathList.forEach(function(namePath) {
+      var initialValue = _this.getInitialValue(namePath);
+      _this.updateStore(setValue(_this.store, namePath, initialValue));
+    });
+    _this.resetWithFieldInitialValue({
+      namePathList
+    });
+    _this.notifyObservers(prevStore, namePathList, {
+      type: "reset"
+    });
+    _this.notifyWatch(namePathList);
+  };
+  this.setFields = function(fields) {
+    _this.warningUnhooked();
+    var prevStore = _this.store;
+    var namePathList = [];
+    fields.forEach(function(fieldData) {
+      var name = fieldData.name;
+      fieldData.errors;
+      var data = _objectWithoutProperties(fieldData, _excluded);
+      var namePath = getNamePath(name);
+      namePathList.push(namePath);
+      if ("value" in data) {
+        _this.updateStore(setValue(_this.store, namePath, data.value));
+      }
+      _this.notifyObservers(prevStore, [namePath], {
+        type: "setField",
+        data: fieldData
+      });
+    });
+    _this.notifyWatch(namePathList);
+  };
+  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)
+      });
+      Object.defineProperty(fieldData, "originRCField", {
+        value: true
+      });
+      return fieldData;
+    });
+    return fields;
+  };
+  this.initEntityValue = function(entity) {
+    var initialValue = entity.props.initialValue;
+    if (initialValue !== void 0) {
+      var namePath = entity.getNamePath();
+      var prevValue = getValue(_this.store, namePath);
+      if (prevValue === void 0) {
+        _this.updateStore(setValue(_this.store, namePath, initialValue));
+      }
+    }
+  };
+  this.isMergedPreserve = function(fieldPreserve) {
+    var mergedPreserve = fieldPreserve !== void 0 ? fieldPreserve : _this.preserve;
+    return mergedPreserve !== null && mergedPreserve !== void 0 ? mergedPreserve : true;
+  };
+  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(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
+            !matchNamePath(field.getNamePath(), namePath)
+          );
+        })) {
+          var _prevStore = _this.store;
+          _this.updateStore(setValue(_prevStore, namePath, defaultValue, true));
+          _this.notifyObservers(_prevStore, [namePath], {
+            type: "remove"
+          });
+          _this.triggerDependenciesUpdate(_prevStore, namePath);
+        }
+      }
+      _this.notifyWatch([namePath]);
+    };
+  };
+  this.dispatch = function(action) {
+    switch (action.type) {
+      case "updateValue": {
+        var namePath = action.namePath, value = action.value;
+        _this.updateValue(namePath, value);
+        break;
+      }
+      case "validateField": {
+        var _namePath = action.namePath, triggerName = action.triggerName;
+        _this.validateFields([_namePath], {
+          triggerName
+        });
+        break;
+      }
+    }
+  };
+  this.notifyObservers = function(prevStore, namePathList, info) {
+    if (_this.subscribable) {
+      var mergedInfo = _objectSpread2(_objectSpread2({}, info), {}, {
+        store: _this.getFieldsValue(true)
+      });
+      _this.getFieldEntities().forEach(function(_ref3) {
+        var onStoreChange = _ref3.onStoreChange;
+        onStoreChange(prevStore, namePathList, mergedInfo);
+      });
+    } else {
+      _this.forceRootUpdate();
+    }
+  };
+  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;
+  };
+  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]);
+    var childrenFields = _this.triggerDependenciesUpdate(prevStore, namePath);
+    var onValuesChange = _this.callbacks.onValuesChange;
+    if (onValuesChange) {
+      var changedValues = cloneByNamePathList(_this.store, [namePath]);
+      onValuesChange(changedValues, _this.getFieldsValue());
+    }
+    _this.triggerOnFieldsChange([namePath].concat(_toConsumableArray(childrenFields)));
+  };
+  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();
+  };
+  this.setFieldValue = function(name, value) {
+    _this.setFields([{
+      name,
+      value
+    }]);
+  };
+  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 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);
+          }
+        }
+      });
+    };
+    fillChildren(rootNamePath);
+    return childrenFields;
+  };
+  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(_ref4) {
+          var name = _ref4.name, errors = _ref4.errors;
+          cache.set(name, errors);
+        });
+        fields.forEach(function(field) {
+          field.errors = cache.get(field.name) || field.errors;
+        });
+      }
+      var changedFields = fields.filter(function(_ref5) {
+        var fieldName = _ref5.name;
+        return containsNamePath(namePathList, fieldName);
+      });
+      onFieldsChange(changedFields, fields);
+    }
+  };
+  this.validateFields = function(nameList, options) {
+    _this.warningUnhooked();
+    var provideNameList = !!nameList;
+    var namePathList = provideNameList ? nameList.map(getNamePath) : [];
+    var promiseList = [];
+    _this.getFieldEntities(true).forEach(function(field) {
+      if (!provideNameList) {
+        namePathList.push(field.getNamePath());
+      }
+      if ((options === null || options === void 0 ? 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] === void 0;
+          })
+        ) {
+          namePathList.push(namePath);
+        }
+      }
+      if (!field.props.rules || !field.props.rules.length) {
+        return;
+      }
+      var fieldNamePath = field.getNamePath();
+      if (!provideNameList || containsNamePath(namePathList, fieldNamePath)) {
+        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 ? void 0 : _ruleErrors$forEach.call(ruleErrors, function(_ref6) {
+            var warningOnly = _ref6.rule.warningOnly, errors = _ref6.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 summaryPromise = allPromiseFinish(promiseList);
+    _this.lastValidatePromise = summaryPromise;
+    summaryPromise.catch(function(results) {
+      return results;
+    }).then(function(results) {
+      var resultNamePathList = results.map(function(_ref7) {
+        var name = _ref7.name;
+        return name;
+      });
+      _this.notifyObservers(_this.store, resultNamePathList, {
+        type: "validateFinish"
+      });
+      _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 errorList = results.filter(function(result) {
+        return result && result.errors.length;
+      });
+      return Promise.reject({
+        values: _this.getFieldsValue(namePathList),
+        errorFields: errorList,
+        outOfDate: _this.lastValidatePromise !== summaryPromise
+      });
+    });
+    returnPromise.catch(function(e) {
+      return e;
+    });
+    return returnPromise;
+  };
+  this.submit = function() {
+    _this.warningUnhooked();
+    _this.validateFields().then(function(values) {
+      var onFinish = _this.callbacks.onFinish;
+      if (onFinish) {
+        try {
+          onFinish(values);
+        } catch (err) {
+          console.error(err);
+        }
+      }
+    }).catch(function(e) {
+      var onFinishFailed = _this.callbacks.onFinishFailed;
+      if (onFinishFailed) {
+        onFinishFailed(e);
+      }
+    });
+  };
+  this.forceRootUpdate = forceRootUpdate;
+});
+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 [formRef.current];
+}
+export {
+  FormStore,
+  useForm as default
+};
+//# sourceMappingURL=useForm.es.js.map