@arco-design/mobile-react 2.31.1 → 2.31.3

package/dist/index.js

@@ -63,44 +63,6 @@
         return t;
     }
 
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (g && (g = 0, op[0] && (_ = 0)), _) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
     /** @deprecated */
     function __spreadArrays$1() {
         for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
@@ -1844,6 +1806,9 @@
 
       return DateWithUTC;
     }();
+    function formatDateNumber(value) {
+      return value < 10 ? "0" + value : String(value);
+    }
 
     var ValidatorType;
 
@@ -13470,7 +13435,7 @@
         nextTick(function () {
           setLinkArgs(getCurrentValueData());
         });
-      }, []);
+      }, [value]);
 
       function hidePicker(scene) {
         setLinkVisible(false);
@@ -13642,11 +13607,7 @@
     }
 
     var allTypes = ['year', 'month', 'date', 'hour', 'minute', 'second'];
-
-    var defaultFormatter = function defaultFormatter(value) {
-      return value < 10 ? "0" + value : String(value);
-    };
-
+    var defaultFormatter = formatDateNumber;
     var YEAR = 12 * 30 * 24 * 60 * 60 * 1000;
     var initMinDate = Date.now() - 10 * YEAR;
     var initMaxDate = Date.now() + 10 * YEAR;
@@ -13679,7 +13640,8 @@
           touchToStop = props.touchToStop,
           _k = props.useUTC,
           useUTC = _k === void 0 ? false : _k,
-          otherProps = __rest$1(props, ["currentTs", "className", "visible", "onOk", "onChange", "onValueChange", "mode", "typeArr", "minTs", "maxTs", "formatter", "valueFilter", "columnsProcessor", "touchToStop", "useUTC"]);
+          renderLinkedContainer = props.renderLinkedContainer,
+          otherProps = __rest$1(props, ["currentTs", "className", "visible", "onOk", "onChange", "onValueChange", "mode", "typeArr", "minTs", "maxTs", "formatter", "valueFilter", "columnsProcessor", "touchToStop", "useUTC", "renderLinkedContainer"]);
 
       var currentTs = Math.min(maxTs, Math.max(minTs, userSetCurrentTs));
 
@@ -13949,7 +13911,10 @@
           value: value,
           onPickerChange: _handlePickerChange,
           onOk: _handlePickerConfirm,
-          touchToStop: touchToStop
+          touchToStop: touchToStop,
+          renderLinkedContainer: renderLinkedContainer ? function () {
+            return renderLinkedContainer(currentTs, keyOptions);
+          } : undefined
         }));
       });
     });
@@ -16319,2133 +16284,2165 @@
       });
     });
 
-    var defaultFunc = function defaultFunc() {};
+    var es6Promise = createCommonjsModule(function (module, exports) {
+    /*!
+     * @overview es6-promise - a tiny implementation of Promises/A+.
+     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+     * @license   Licensed under MIT license
+     *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
+     * @version   v4.2.8+1e68dce6
+     */
 
-    var defaultFormDataMethods = {
-      getFieldValue: function getFieldValue(name) {
-        return name;
-      },
-      getFieldsValue: function getFieldsValue(_names) {
-        return {};
-      },
-      getFieldError: function getFieldError(_name) {
-        return [];
-      },
-      setFieldValue: function setFieldValue(_name, _value) {
-        return true;
-      },
-      setFieldsValue: function setFieldsValue(_values) {
-        return true;
-      },
-      registerField: function registerField(_name, _self) {
-        return function () {};
-      },
-      resetFields: defaultFunc,
-      validateFields: defaultFunc,
-      submit: defaultFunc,
-      getInternalHooks: function getInternalHooks() {
-        return {
-          registerField: defaultFunc,
-          setInitialValues: defaultFunc,
-          setCallbacks: defaultFunc
-        };
-      }
-    }; // 在field的静态的状态下设置
+    (function (global, factory) {
+    	module.exports = factory() ;
+    }(commonjsGlobal, (function () {
+    function objectOrFunction(x) {
+      var type = typeof x;
+      return x !== null && (type === 'object' || type === 'function');
+    }
 
-    var FormData =
-    /** @class */
-    function () {
-      function FormData() {
-        var _this = this;
+    function isFunction(x) {
+      return typeof x === 'function';
+    }
 
-        this._formData = {}; // 数据源
 
-        this._fieldsList = {}; // 字段列表
 
-        this._initialValues = {}; // 初始值
+    var _isArray = void 0;
+    if (Array.isArray) {
+      _isArray = Array.isArray;
+    } else {
+      _isArray = function (x) {
+        return Object.prototype.toString.call(x) === '[object Array]';
+      };
+    }
 
-        this._callbacks = {};
+    var isArray = _isArray;
 
-        this.setFieldsValue = function (values) {
-          _this._formData = __assign$3(__assign$3({}, _this._formData), values);
+    var len = 0;
+    var vertxNext = void 0;
+    var customSchedulerFn = void 0;
 
-          _this.notifyField(values);
+    var asap = function asap(callback, arg) {
+      queue[len] = callback;
+      queue[len + 1] = arg;
+      len += 2;
+      if (len === 2) {
+        // If len is 2, that means that we need to schedule an async flush.
+        // If additional callbacks are queued before the queue is flushed, they
+        // will be processed by this flush that we are scheduling.
+        if (customSchedulerFn) {
+          customSchedulerFn(flush);
+        } else {
+          scheduleFlush();
+        }
+      }
+    };
 
-          Object.keys(values).forEach(function (key) {
-            var _a;
+    function setScheduler(scheduleFn) {
+      customSchedulerFn = scheduleFn;
+    }
 
-            if (key in _this._fieldsList) {
-              (_a = _this._fieldsList[key]) === null || _a === void 0 ? void 0 : _a.onValueChange();
-            }
-          });
-          return true;
-        };
+    function setAsap(asapFn) {
+      asap = asapFn;
+    }
 
-        this.setFieldValue = function (name, value) {
-          var _a, _b, _c;
+    var browserWindow = typeof window !== 'undefined' ? window : undefined;
+    var browserGlobal = browserWindow || {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
 
-          _this._formData = __assign$3(__assign$3({}, _this._formData), (_a = {}, _a[name] = value, _a));
-          var onValuesChange = _this._callbacks.onValuesChange;
-          onValuesChange && onValuesChange((_b = {}, _b[name] = value, _b), _this._formData);
+    // test for web worker but not in IE10
+    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
 
-          _this.notifyField((_c = {}, _c[name] = value, _c));
+    // node
+    function useNextTick() {
+      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+      // see https://github.com/cujojs/when/issues/410 for details
+      return function () {
+        return process.nextTick(flush);
+      };
+    }
 
-          return true;
+    // vertx
+    function useVertxTimer() {
+      if (typeof vertxNext !== 'undefined') {
+        return function () {
+          vertxNext(flush);
         };
+      }
 
-        this.notifyField = function (values) {
-          Object.keys(values).map(function (fieldName) {
-            var _a;
+      return useSetTimeout();
+    }
 
-            var fieldObj = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[fieldName]) || null;
+    function useMutationObserver() {
+      var iterations = 0;
+      var observer = new BrowserMutationObserver(flush);
+      var node = document.createTextNode('');
+      observer.observe(node, { characterData: true });
 
-            if (fieldObj) {
-              fieldObj.onValueChange(values[fieldName]);
-            }
-          });
-        };
+      return function () {
+        node.data = iterations = ++iterations % 2;
+      };
+    }
 
-        this.getFieldsValue = function (names) {
-          if (names) {
-            return names.map(function (name) {
-              return _this.getFieldValue(name);
-            });
-          }
+    // web worker
+    function useMessageChannel() {
+      var channel = new MessageChannel();
+      channel.port1.onmessage = flush;
+      return function () {
+        return channel.port2.postMessage(0);
+      };
+    }
 
-          return _this._formData;
-        };
+    function useSetTimeout() {
+      // Store setTimeout reference so es6-promise will be unaffected by
+      // other code modifying setTimeout (like sinon.useFakeTimers())
+      var globalSetTimeout = setTimeout;
+      return function () {
+        return globalSetTimeout(flush, 1);
+      };
+    }
 
-        this.getFieldValue = function (name) {
-          var _a;
+    var queue = new Array(1000);
+    function flush() {
+      for (var i = 0; i < len; i += 2) {
+        var callback = queue[i];
+        var arg = queue[i + 1];
 
-          return (_a = _this._formData) === null || _a === void 0 ? void 0 : _a[name];
-        };
+        callback(arg);
 
-        this.getFieldError = function (name) {
-          var _a;
+        queue[i] = undefined;
+        queue[i + 1] = undefined;
+      }
 
-          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+      len = 0;
+    }
 
-          if (field) {
-            return field.getFieldError();
-          }
+    function attemptVertx() {
+      try {
+        var vertx = Function('return this')().require('vertx');
+        vertxNext = vertx.runOnLoop || vertx.runOnContext;
+        return useVertxTimer();
+      } catch (e) {
+        return useSetTimeout();
+      }
+    }
 
-          return [];
-        };
+    var scheduleFlush = void 0;
+    // Decide what async method to use to triggering processing of queued callbacks:
+    if (isNode) {
+      scheduleFlush = useNextTick();
+    } else if (BrowserMutationObserver) {
+      scheduleFlush = useMutationObserver();
+    } else if (isWorker) {
+      scheduleFlush = useMessageChannel();
+    } else if (browserWindow === undefined && typeof commonjsRequire === 'function') {
+      scheduleFlush = attemptVertx();
+    } else {
+      scheduleFlush = useSetTimeout();
+    }
 
-        this.getFieldsError = function (names) {
-          var fields = names || Object.keys(_this._fieldsList);
-          return fields.reduce(function (pre, name) {
-            var _a;
+    function then(onFulfillment, onRejection) {
+      var parent = this;
 
-            var theField = (_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name];
+      var child = new this.constructor(noop);
 
-            if (theField) {
-              pre[name] = theField === null || theField === void 0 ? void 0 : theField.getFieldError();
-            }
+      if (child[PROMISE_ID] === undefined) {
+        makePromise(child);
+      }
 
-            return pre;
-          }, {});
-        };
+      var _state = parent._state;
 
-        this.isFieldTouched = function (name) {
-          var _a;
 
-          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
+      if (_state) {
+        var callback = arguments[_state - 1];
+        asap(function () {
+          return invokeCallback(_state, child, callback, parent._result);
+        });
+      } else {
+        subscribe(parent, child, onFulfillment, onRejection);
+      }
 
-          if (field) {
-            return field.isFieldTouched();
-          }
+      return child;
+    }
 
-          return false;
-        };
+    /**
+      `Promise.resolve` returns a promise that will become resolved with the
+      passed `value`. It is shorthand for the following:
 
-        this.registerField = function (name, self) {
-          var _a, _b;
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        resolve(1);
+      });
 
-          _this._fieldsList[name] = self;
-          var initialValue = self.props.initialValue;
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
 
-          if (initialValue !== undefined && name) {
-            _this._initialValues = __assign$3(__assign$3({}, _this._initialValues), (_a = {}, _a[name] = initialValue, _a));
+      Instead of writing the above, your code now simply becomes the following:
 
-            _this.setFieldsValue(__assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = initialValue, _b)));
-          }
+      ```javascript
+      let promise = Promise.resolve(1);
 
-          return function () {
-            if (name in _this._fieldsList) {
-              delete _this._fieldsList[name];
-              delete _this._formData[name];
-            }
-          };
-        };
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
 
-        this.setInitialValues = function (initVal) {
-          _this._initialValues = __assign$3({}, initVal || {});
+      @method resolve
+      @static
+      @param {Any} value value that the returned promise will be resolved with
+      Useful for tooling.
+      @return {Promise} a promise that will become fulfilled with the given
+      `value`
+    */
+    function resolve$1(object) {
+      /*jshint validthis:true */
+      var Constructor = this;
 
-          _this.setFieldsValue(initVal);
-        };
+      if (object && typeof object === 'object' && object.constructor === Constructor) {
+        return object;
+      }
 
-        this.resetFields = function () {
-          _this.setFieldsValue(_this._initialValues);
-        };
+      var promise = new Constructor(noop);
+      resolve(promise, object);
+      return promise;
+    }
 
-        this.validateFields = function () {
-          var promiseList = [];
-          Object.values(_this._fieldsList).forEach(function (entity) {
-            var promise = entity.validateField();
-            promiseList.push(promise.then(function (errors) {
-              return errors;
-            }));
-          });
-          var summaryPromise = new Promise(function (resolve, reject) {
-            Promise.all(promiseList).then(function (res) {
-              var errorResults = res.filter(function (item) {
-                var _a;
+    var PROMISE_ID = Math.random().toString(36).substring(2);
 
-                return (_a = item === null || item === void 0 ? void 0 : item.errors) === null || _a === void 0 ? void 0 : _a.length;
-              });
+    function noop() {}
 
-              if (errorResults.length) {
-                reject(errorResults);
-              } else {
-                resolve(res);
-              }
-            });
-          });
-          return summaryPromise;
-        };
+    var PENDING = void 0;
+    var FULFILLED = 1;
+    var REJECTED = 2;
 
-        this.submit = function () {
-          return __awaiter(_this, void 0, void 0, function () {
-            var _this = this;
-
-            return __generator(this, function (_a) {
-              this.validateFields().then(function (result) {
-                var onSubmit = _this._callbacks.onSubmit;
-                onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(_this._formData, result);
-              }).catch(function (e) {
-                var onSubmitFailed = _this._callbacks.onSubmitFailed;
-
-                if (!onSubmitFailed) {
-                  return;
-                }
+    function selfFulfillment() {
+      return new TypeError("You cannot resolve a promise with itself");
+    }
 
-                onSubmitFailed(_this._formData, e);
-              });
-              return [2
-              /*return*/
-              ];
-            });
-          });
-        };
+    function cannotReturnOwn() {
+      return new TypeError('A promises callback cannot return that same promise.');
+    }
 
-        this.setCallbacks = function (callbacks) {
-          _this._callbacks = callbacks;
-        };
+    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
+      try {
+        then$$1.call(value, fulfillmentHandler, rejectionHandler);
+      } catch (e) {
+        return e;
+      }
+    }
 
-        this.getMethods = function () {
-          return {
-            setFieldsValue: _this.setFieldsValue,
-            setFieldValue: _this.setFieldValue,
-            getFieldsValue: _this.getFieldsValue,
-            getFieldValue: _this.getFieldValue,
-            getFieldError: _this.getFieldError,
-            getFieldsError: _this.getFieldsError,
-            isFieldTouched: _this.isFieldTouched,
-            registerField: _this.registerField,
-            resetFields: _this.resetFields,
-            submit: _this.submit,
-            getInternalHooks: _this.getInternalHooks,
-            validateFields: _this.validateFields
-          };
-        };
+    function handleForeignThenable(promise, thenable, then$$1) {
+      asap(function (promise) {
+        var sealed = false;
+        var error = tryThen(then$$1, thenable, function (value) {
+          if (sealed) {
+            return;
+          }
+          sealed = true;
+          if (thenable !== value) {
+            resolve(promise, value);
+          } else {
+            fulfill(promise, value);
+          }
+        }, function (reason) {
+          if (sealed) {
+            return;
+          }
+          sealed = true;
 
-        this.getInternalHooks = function () {
-          return {
-            registerField: _this.registerField,
-            setInitialValues: _this.setInitialValues,
-            setCallbacks: _this.setCallbacks
-          };
-        };
-      }
+          reject(promise, reason);
+        }, 'Settle: ' + (promise._label || ' unknown promise'));
 
-      return FormData;
-    }();
+        if (!sealed && error) {
+          sealed = true;
+          reject(promise, error);
+        }
+      }, promise);
+    }
 
-    function useForm(form) {
-      var formInstanceRef = React.useRef(defaultFormDataMethods);
-      var isSingletonRef = React.useRef(false);
+    function handleOwnThenable(promise, thenable) {
+      if (thenable._state === FULFILLED) {
+        fulfill(promise, thenable._result);
+      } else if (thenable._state === REJECTED) {
+        reject(promise, thenable._result);
+      } else {
+        subscribe(thenable, undefined, function (value) {
+          return resolve(promise, value);
+        }, function (reason) {
+          return reject(promise, reason);
+        });
+      }
+    }
 
-      if (!isSingletonRef.current) {
-        if (form) {
-          formInstanceRef.current = form;
+    function handleMaybeThenable(promise, maybeThenable, then$$1) {
+      if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
+        handleOwnThenable(promise, maybeThenable);
+      } else {
+        if (then$$1 === undefined) {
+          fulfill(promise, maybeThenable);
+        } else if (isFunction(then$$1)) {
+          handleForeignThenable(promise, maybeThenable, then$$1);
         } else {
-          var formIns = new FormData();
-          formInstanceRef.current = formIns.getMethods();
+          fulfill(promise, maybeThenable);
         }
+      }
+    }
 
-        isSingletonRef.current = true;
+    function resolve(promise, value) {
+      if (promise === value) {
+        reject(promise, selfFulfillment());
+      } else if (objectOrFunction(value)) {
+        var then$$1 = void 0;
+        try {
+          then$$1 = value.then;
+        } catch (error) {
+          reject(promise, error);
+          return;
+        }
+        handleMaybeThenable(promise, value, then$$1);
+      } else {
+        fulfill(promise, value);
       }
+    }
 
-      return [formInstanceRef.current];
+    function publishRejection(promise) {
+      if (promise._onerror) {
+        promise._onerror(promise._result);
+      }
+
+      publish(promise);
     }
 
-    var FormItemContext = /*#__PURE__*/React__default["default"].createContext({
-      form: defaultFormDataMethods,
-      layout: 'horizontal'
-    });
+    function fulfill(promise, value) {
+      if (promise._state !== PENDING) {
+        return;
+      }
 
-    // 注意：自动识别form关联组件的依据，请勿轻易改变代码结构
-    // Notice: Automatically identify the basis of the associated component of the form, DO NOT change the code structure.
-    var FormInternalComponentType;
+      promise._result = value;
+      promise._state = FULFILLED;
 
-    (function (FormInternalComponentType) {
-      FormInternalComponentType["Input"] = "Input";
-      FormInternalComponentType["Textarea"] = "Textarea";
-      FormInternalComponentType["Checkbox"] = "Checkbox";
-      FormInternalComponentType["CheckboxGroup"] = "CheckboxGroup";
-      FormInternalComponentType["DatePicker"] = "DatePicker";
-      FormInternalComponentType["Picker"] = "Picker";
-      FormInternalComponentType["Radio"] = "Radio";
-      FormInternalComponentType["RadioGroup"] = "RadioGroup";
-      FormInternalComponentType["Slider"] = "Slider";
-      FormInternalComponentType["Switch"] = "Switch";
-      FormInternalComponentType["ImagePicker"] = "ImagePicker";
-      FormInternalComponentType["Rate"] = "Rate";
-      FormInternalComponentType["Stepper"] = "Stepper";
-    })(FormInternalComponentType || (FormInternalComponentType = {}));
+      if (promise._subscribers.length !== 0) {
+        asap(publish, promise);
+      }
+    }
 
-    var ValidateStatus;
+    function reject(promise, reason) {
+      if (promise._state !== PENDING) {
+        return;
+      }
+      promise._state = REJECTED;
+      promise._result = reason;
 
-    (function (ValidateStatus) {
-      ValidateStatus["Init"] = "init";
-      ValidateStatus["Error"] = "error";
-      ValidateStatus["Warning"] = "warning";
-      ValidateStatus["Validating"] = "validating";
-      ValidateStatus["Success"] = "success";
-    })(ValidateStatus || (ValidateStatus = {}));
-
-    var isFieldRequired = function isFieldRequired(rules) {
-      if (rules === void 0) {
-        rules = [];
-      }
-
-      return (rules || []).some(function (rule) {
-        return rule === null || rule === void 0 ? void 0 : rule.required;
-      });
-    };
-    var getErrorAndWarnings = function getErrorAndWarnings(result) {
-      var errors = [];
-      var warnings = [];
-      var errorTypes = [];
-      result.map(function (_a) {
-        var _b = _a.message,
-            message = _b === void 0 ? [] : _b,
-            _c = _a.validateLevel,
-            validateLevel = _c === void 0 ? 'error' : _c,
-            resultErrorTypes = _a.errorTypes;
+      asap(publishRejection, promise);
+    }
 
-        if (!(message === null || message === void 0 ? void 0 : message.length)) {
-          return;
-        }
+    function subscribe(parent, child, onFulfillment, onRejection) {
+      var _subscribers = parent._subscribers;
+      var length = _subscribers.length;
 
-        if (validateLevel === 'warning') {
-          warnings = __spreadArrays$1(warnings, message);
-        } else {
-          errors = __spreadArrays$1(errors, message);
-          errorTypes = __spreadArrays$1(errorTypes, resultErrorTypes);
-        }
-      });
-      return {
-        warnings: warnings,
-        errors: errors,
-        errorTypes: errorTypes
-      };
-    };
 
-    function DefaultPickerLinkedContainer(_a) {
-      var value = _a.value;
+      parent._onerror = null;
 
-      var _b = React.useContext(GlobalContext),
-          prefixCls = _b.prefixCls,
-          locale = _b.locale;
+      _subscribers[length] = child;
+      _subscribers[length + FULFILLED] = onFulfillment;
+      _subscribers[length + REJECTED] = onRejection;
 
-      var className = prefixCls + "-form-picker-link-container";
-      return /*#__PURE__*/React__default["default"].createElement("div", {
-        className: className
-      }, value && value.length ? value.join('-') : /*#__PURE__*/React__default["default"].createElement("span", {
-        className: className + "-placeholder"
-      }, locale === null || locale === void 0 ? void 0 : locale.Form.pickerDefaultHint));
+      if (length === 0 && parent._state) {
+        asap(publish, parent);
+      }
     }
 
-    var FormItemInner =
-    /** @class */
-    function (_super) {
-      __extends$1(FormItemInner, _super);
-
-      function FormItemInner(props, context) {
-        var _a;
-
-        var _this = _super.call(this, props) || this;
+    function publish(promise) {
+      var subscribers = promise._subscribers;
+      var settled = promise._state;
 
-        _this._errors = [];
-        _this._touched = false;
+      if (subscribers.length === 0) {
+        return;
+      }
 
-        _this.onValueChange = function (preStore, curStore) {
-          _this._touched = true;
-          var shouldUpdate = _this.props.shouldUpdate;
+      var child = void 0,
+          callback = void 0,
+          detail = promise._result;
 
-          if (typeof shouldUpdate === 'function') {
-            shouldUpdate({
-              preStore: preStore,
-              curStore: curStore
-            }) && _this.forceUpdate();
-            return;
-          }
+      for (var i = 0; i < subscribers.length; i += 3) {
+        child = subscribers[i];
+        callback = subscribers[i + settled];
 
-          _this.forceUpdate();
-        };
+        if (child) {
+          invokeCallback(settled, child, callback, detail);
+        } else {
+          callback(detail);
+        }
+      }
 
-        _this.getFieldError = function () {
-          return _this._errors;
-        };
+      promise._subscribers.length = 0;
+    }
 
-        _this.isFieldTouched = function () {
-          return _this._touched;
-        };
+    function invokeCallback(settled, promise, callback, detail) {
+      var hasCallback = isFunction(callback),
+          value = void 0,
+          error = void 0,
+          succeeded = true;
 
-        _this.validateField = function () {
-          var _a;
+      if (hasCallback) {
+        try {
+          value = callback(detail);
+        } catch (e) {
+          succeeded = false;
+          error = e;
+        }
 
-          var validateMessages = _this.context.validateMessages;
-          var getFieldValue = _this.context.form.getFieldValue;
-          var _b = _this.props,
-              field = _b.field,
-              rules = _b.rules,
-              onValidateStatusChange = _b.onValidateStatusChange;
-          var value = getFieldValue(field);
+        if (promise === value) {
+          reject(promise, cannotReturnOwn());
+          return;
+        }
+      } else {
+        value = detail;
+      }
 
-          if ((rules === null || rules === void 0 ? void 0 : rules.length) && field) {
-            var fieldDom_1 = _this.props.getFormItemRef();
+      if (promise._state !== PENDING) ; else if (hasCallback && succeeded) {
+        resolve(promise, value);
+      } else if (succeeded === false) {
+        reject(promise, error);
+      } else if (settled === FULFILLED) {
+        fulfill(promise, value);
+      } else if (settled === REJECTED) {
+        reject(promise, value);
+      }
+    }
 
-            var fieldValidator_1 = new Validator((_a = {}, _a[field] = rules, _a), {
-              validateMessages: validateMessages
-            });
-            return new Promise(function (resolve) {
-              var _a;
+    function initializePromise(promise, resolver) {
+      try {
+        resolver(function resolvePromise(value) {
+          resolve(promise, value);
+        }, function rejectPromise(reason) {
+          reject(promise, reason);
+        });
+      } catch (e) {
+        reject(promise, e);
+      }
+    }
 
-              fieldValidator_1.validate((_a = {}, _a[field] = value, _a), function (errorsMap) {
-                var _a = getErrorAndWarnings((errorsMap === null || errorsMap === void 0 ? void 0 : errorsMap[field]) || []),
-                    errors = _a.errors,
-                    warnings = _a.warnings,
-                    errorTypes = _a.errorTypes;
+    var id = 0;
+    function nextId() {
+      return id++;
+    }
 
-                _this._errors = errors;
-                onValidateStatusChange({
-                  errors: _this._errors,
-                  warnings: warnings,
-                  errorTypes: errorTypes
-                });
-                return resolve({
-                  errors: _this._errors,
-                  warnings: warnings,
-                  value: value,
-                  field: field,
-                  dom: fieldDom_1
-                });
-              });
-            });
-          }
+    function makePromise(promise) {
+      promise[PROMISE_ID] = id++;
+      promise._state = undefined;
+      promise._result = undefined;
+      promise._subscribers = [];
+    }
 
-          return Promise.resolve({
-            errors: [],
-            warnings: [],
-            value: value,
-            field: field,
-            dom: null
-          });
-        };
+    function validationError() {
+      return new Error('Array Methods must be provided an Array');
+    }
 
-        _this.setFieldData = function (value) {
-          var field = _this.props.field;
-          var setFieldValue = _this.context.form.setFieldValue;
-          setFieldValue(field, value);
+    var Enumerator = function () {
+      function Enumerator(Constructor, input) {
+        this._instanceConstructor = Constructor;
+        this.promise = new Constructor(noop);
 
-          _this.validateField();
-        };
+        if (!this.promise[PROMISE_ID]) {
+          makePromise(this.promise);
+        }
 
-        _this.innerTriggerFunction = function (_, value) {
-          var _a, _b;
+        if (isArray(input)) {
+          this.length = input.length;
+          this._remaining = input.length;
 
-          var args = [];
+          this._result = new Array(this.length);
 
-          for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
+          if (this.length === 0) {
+            fulfill(this.promise, this._result);
+          } else {
+            this.length = this.length || 0;
+            this._enumerate(input);
+            if (this._remaining === 0) {
+              fulfill(this.promise, this._result);
+            }
           }
+        } else {
+          reject(this.promise, validationError());
+        }
+      }
 
-          _this.setFieldData(value);
+      Enumerator.prototype._enumerate = function _enumerate(input) {
+        for (var i = 0; this._state === PENDING && i < input.length; i++) {
+          this._eachEntry(input[i], i);
+        }
+      };
 
-          var _c = _this.props,
-              children = _c.children,
-              _d = _c.trigger,
-              trigger = _d === void 0 ? 'onChange' : _d;
+      Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
+        var c = this._instanceConstructor;
+        var resolve$$1 = c.resolve;
 
-          if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
-            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([_, value], args));
-          }
-        };
-
-        _this.innerTriggerFunctionWithValueFirst = function (value) {
-          var _a, _b;
-
-          var args = [];
 
-          for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
+        if (resolve$$1 === resolve$1) {
+          var _then = void 0;
+          var error = void 0;
+          var didError = false;
+          try {
+            _then = entry.then;
+          } catch (e) {
+            didError = true;
+            error = e;
           }
 
-          _this.setFieldData(value);
-
-          var _c = _this.props,
-              children = _c.children,
-              _d = _c.trigger,
-              trigger = _d === void 0 ? 'onChange' : _d;
-
-          if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
-            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([value], args));
+          if (_then === then && entry._state !== PENDING) {
+            this._settledAt(entry._state, i, entry._result);
+          } else if (typeof _then !== 'function') {
+            this._remaining--;
+            this._result[i] = entry;
+          } else if (c === Promise$1) {
+            var promise = new c(noop);
+            if (didError) {
+              reject(promise, error);
+            } else {
+              handleMaybeThenable(promise, entry, _then);
+            }
+            this._willSettleAt(promise, i);
+          } else {
+            this._willSettleAt(new c(function (resolve$$1) {
+              return resolve$$1(entry);
+            }), i);
           }
-        };
-
-        _this.innerClearFunction = function () {
-          var _a, _b;
-
-          var args = [];
+        } else {
+          this._willSettleAt(resolve$$1(entry), i);
+        }
+      };
 
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
+      Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
+        var promise = this.promise;
 
-          var children = _this.props.children;
 
-          _this.setFieldData('');
+        if (promise._state === PENDING) {
+          this._remaining--;
 
-          if ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onClear) {
-            (_b = children.props) === null || _b === void 0 ? void 0 : _b.onClear.apply(_b, args);
+          if (state === REJECTED) {
+            reject(promise, value);
+          } else {
+            this._result[i] = value;
           }
-        };
-
-        _this.destroyField = function () {};
-
-        if ((props === null || props === void 0 ? void 0 : props.initialValue) && props.field) {
-          var setInitialValues = context.form.getInternalHooks().setInitialValues;
-          setInitialValues((_a = {}, _a[props.field] = props.initialValue, _a));
         }
 
-        return _this;
-      }
-
-      FormItemInner.prototype.componentDidMount = function () {
-        var registerField = this.context.form.getInternalHooks().registerField;
-        this.destroyField = registerField(this.props.field, this);
+        if (this._remaining === 0) {
+          fulfill(promise, this._result);
+        }
       };
 
-      FormItemInner.prototype.componentWillUnmount = function () {
-        this.destroyField();
+      Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
+        var enumerator = this;
+
+        subscribe(promise, undefined, function (value) {
+          return enumerator._settledAt(FULFILLED, i, value);
+        }, function (reason) {
+          return enumerator._settledAt(REJECTED, i, reason);
+        });
       };
 
-      FormItemInner.prototype.renderChildren = function () {
-        var _a;
+      return Enumerator;
+    }();
 
-        var _this = this;
+    /**
+      `Promise.all` accepts an array of promises, and returns a new promise which
+      is fulfilled with an array of fulfillment values for the passed promises, or
+      rejected with the reason of the first passed promise to be rejected. It casts all
+      elements of the passed iterable to promises as it runs this algorithm.
 
-        var _b, _c, _d;
+      Example:
 
-        var _e = this.props,
-            children = _e.children,
-            field = _e.field,
-            _f = _e.trigger,
-            trigger = _f === void 0 ? 'onChange' : _f,
-            _g = _e.triggerPropsField,
-            triggerPropsField = _g === void 0 ? 'value' : _g,
-            displayType = _e.displayType;
-        var getFieldValue = this.context.form.getFieldValue;
-        var props = (_a = {}, _a[triggerPropsField] = getFieldValue(field), _a.disabled = this.props.disabled, _a);
-        var childrenType = displayType || ((_b = children.type) === null || _b === void 0 ? void 0 : _b.displayName);
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = resolve(2);
+      let promise3 = resolve(3);
+      let promises = [ promise1, promise2, promise3 ];
 
-        switch (childrenType) {
-          case FormInternalComponentType.Input:
-          case FormInternalComponentType.Textarea:
-            props = {
-              value: getFieldValue(field) || '',
-              onInput: this.innerTriggerFunction,
-              onClear: this.innerClearFunction,
-              disabled: this.props.disabled
-            };
-            break;
+      Promise.all(promises).then(function(array){
+        // The array here would be [ 1, 2, 3 ];
+      });
+      ```
 
-          case FormInternalComponentType.Checkbox:
-          case FormInternalComponentType.Radio:
-          case FormInternalComponentType.Slider:
-          case FormInternalComponentType.RadioGroup:
-          case FormInternalComponentType.CheckboxGroup:
-            props = {
-              value: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
-            break;
+      If any of the `promises` given to `all` are rejected, the first promise
+      that is rejected will be given as an argument to the returned promises's
+      rejection handler. For example:
 
-          case FormInternalComponentType.DatePicker:
-            props = {
-              currentTs: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled,
-              renderLinkedContainer: ((_c = children.props) === null || _c === void 0 ? void 0 : _c.renderLinkedContainer) || function (val) {
-                return /*#__PURE__*/React__default["default"].createElement(DefaultPickerLinkedContainer, {
-                  value: val
-                });
-              }
-            };
-            break;
+      Example:
 
-          case FormInternalComponentType.Picker:
-            props = {
-              value: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled,
-              renderLinkedContainer: ((_d = children.props) === null || _d === void 0 ? void 0 : _d.renderLinkedContainer) || function (val) {
-                return /*#__PURE__*/React__default["default"].createElement(DefaultPickerLinkedContainer, {
-                  value: val
-                });
-              }
-            };
-            break;
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = reject(new Error("2"));
+      let promise3 = reject(new Error("3"));
+      let promises = [ promise1, promise2, promise3 ];
 
-          case FormInternalComponentType.Switch:
-            props = {
-              checked: Boolean(getFieldValue(field)),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
-            break;
+      Promise.all(promises).then(function(array){
+        // Code here never runs because there are rejected promises!
+      }, function(error) {
+        // error.message === "2"
+      });
+      ```
 
-          case FormInternalComponentType.ImagePicker:
-            props = {
-              images: getFieldValue(field),
-              onChange: this.innerTriggerFunctionWithValueFirst,
-              disabled: this.props.disabled
-            };
-            break;
+      @method all
+      @static
+      @param {Array} entries array of promises
+      @param {String} label optional string for labeling the promise.
+      Useful for tooling.
+      @return {Promise} promise that is fulfilled when all `promises` have been
+      fulfilled, or rejected if any of them become rejected.
+      @static
+    */
+    function all(entries) {
+      return new Enumerator(this, entries).promise;
+    }
 
-          default:
-            var originTrigger_1 = children.props[trigger]; // inject the validated result
+    /**
+      `Promise.race` returns a new promise which is settled in the same way as the
+      first passed promise to settle.
 
-            props.error = this._errors;
+      Example:
 
-            props[trigger] = function (newValue) {
-              var args = [];
+      ```javascript
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
+      });
 
-              for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-              }
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 2');
+        }, 100);
+      });
 
-              _this.setFieldData(newValue);
+      Promise.race([promise1, promise2]).then(function(result){
+        // result === 'promise 2' because it was resolved before promise1
+        // was resolved.
+      });
+      ```
 
-              originTrigger_1 && originTrigger_1.apply(void 0, __spreadArrays$1([newValue], args));
-            };
+      `Promise.race` is deterministic in that only the state of the first
+      settled promise matters. For example, even if other promises given to the
+      `promises` array argument are resolved, but the first settled promise has
+      become rejected before the other promises became fulfilled, the returned
+      promise will become rejected:
 
-        }
+      ```javascript
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
+      });
 
-        return /*#__PURE__*/React__default["default"].cloneElement(children, props);
-      };
-
-      FormItemInner.prototype.render = function () {
-        return this.renderChildren();
-      };
-
-      return FormItemInner;
-    }(React.PureComponent);
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          reject(new Error('promise 2'));
+        }, 100);
+      });
 
-    FormItemInner.contextType = FormItemContext;
-    var Item$1 = /*#__PURE__*/React.forwardRef(function (props, ref) {
-      var _a;
+      Promise.race([promise1, promise2]).then(function(result){
+        // Code here never runs
+      }, function(reason){
+        // reason.message === 'promise 2' because promise 2 became rejected before
+        // promise 1 became fulfilled
+      });
+      ```
 
-      var label = props.label,
-          field = props.field,
-          _b = props.disabled,
-          disabled = _b === void 0 ? false : _b,
-          itemLayout = props.layout,
-          style = props.style,
-          extra = props.extra,
-          requiredIcon = props.requiredIcon,
-          rules = props.rules,
-          _c = props.className,
-          className = _c === void 0 ? '' : _c,
-          rest = __rest$1(props, ["label", "field", "disabled", "layout", "style", "extra", "requiredIcon", "rules", "className"]);
+      An example real-world use case is implementing timeouts:
 
-      var prefixCls = React.useContext(GlobalContext).prefixCls;
+      ```javascript
+      Promise.race([ajax('foo.json'), timeout(5000)])
+      ```
 
-      var _d = React.useContext(FormItemContext),
-          layout = _d.layout,
-          propsDisabled = _d.disabled;
+      @method race
+      @static
+      @param {Array} promises array of promises to observe
+      Useful for tooling.
+      @return {Promise} a promise which settles in the same way as the first passed
+      promise to settle.
+    */
+    function race(entries) {
+      /*jshint validthis:true */
+      var Constructor = this;
 
-      var _e = React.useState(null),
-          errors = _e[0],
-          setErrors = _e[1];
+      if (!isArray(entries)) {
+        return new Constructor(function (_, reject) {
+          return reject(new TypeError('You must pass an array to race.'));
+        });
+      } else {
+        return new Constructor(function (resolve, reject) {
+          var length = entries.length;
+          for (var i = 0; i < length; i++) {
+            Constructor.resolve(entries[i]).then(resolve, reject);
+          }
+        });
+      }
+    }
 
-      var _f = React.useState(null),
-          errorTypes = _f[0],
-          setErrorTypes = _f[1];
+    /**
+      `Promise.reject` returns a promise rejected with the passed `reason`.
+      It is shorthand for the following:
 
-      var _g = React.useState([]),
-          warnings = _g[0],
-          setWarnings = _g[1];
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        reject(new Error('WHOOPS'));
+      });
 
-      var formItemRef = React.useRef(null);
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
 
-      var onValidateStatusChange = function onValidateStatusChange(validateResult) {
-        var _errors = validateResult.errors,
-            _warnings = validateResult.warnings,
-            _errorTypes = validateResult.errorTypes;
-        setErrors(_errors.length ? _errors[0] : null);
-        setErrorTypes(_errorTypes.length ? _errorTypes[0] : null);
-        setWarnings(_warnings);
-      };
+      Instead of writing the above, your code now simply becomes the following:
 
-      var getFormItemRef = function getFormItemRef() {
-        return formItemRef.current;
-      };
+      ```javascript
+      let promise = Promise.reject(new Error('WHOOPS'));
 
-      var fieldDisabled = disabled || propsDisabled;
-      var fieldRules = (rest === null || rest === void 0 ? void 0 : rest.required) ? __spreadArrays$1([{
-        type: ValidatorType.String,
-        required: true
-      }], rules || []) : rules;
-      var isRequired = isFieldRequired(rules) || (rest === null || rest === void 0 ? void 0 : rest.required);
-      React.useImperativeHandle(ref, function () {
-        return {
-          dom: formItemRef.current
-        };
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
       });
-      return /*#__PURE__*/React__default["default"].createElement("div", {
-        className: cls(prefixCls + "-form-item", prefixCls + "-form-item-" + (itemLayout || layout), className, (_a = {
-          disabled: fieldDisabled
-        }, _a[prefixCls + "-form-item-error"] = !!errors, _a[prefixCls + "-form-item-warning"] = Boolean(!errors && warnings), _a[prefixCls + "-form-item-error-" + errorTypes] = errorTypes, _a)),
-        style: style,
-        ref: formItemRef
-      }, /*#__PURE__*/React__default["default"].createElement("div", {
-        className: cls(prefixCls + "-form-label-item")
-      }, isRequired ? requiredIcon || /*#__PURE__*/React__default["default"].createElement("span", {
-        className: cls(prefixCls + "-form-label-item-required-asterisk")
-      }, "*") : null, label), /*#__PURE__*/React__default["default"].createElement("div", {
-        className: cls(prefixCls + "-form-item-control-wrapper")
-      }, /*#__PURE__*/React__default["default"].createElement("div", {
-        className: cls(prefixCls + "-form-item-control")
-      }, /*#__PURE__*/React__default["default"].createElement(FormItemInner, __assign$3({}, rest, {
-        rules: fieldRules,
-        disabled: fieldDisabled,
-        field: field,
-        onValidateStatusChange: onValidateStatusChange,
-        getFormItemRef: getFormItemRef
-      }))), errors && /*#__PURE__*/React__default["default"].createElement("div", {
-        className: cls(prefixCls + "-form-item-message " + prefixCls + "-form-item-error-message")
-      }, errors), (warnings || []).map(function (node, key) {
-        return typeof node === 'string' ? /*#__PURE__*/React__default["default"].createElement("div", {
-          className: cls(prefixCls + "-form-item-message " + prefixCls + "-form-item-warning-message"),
-          key: key
-        }, node) : node;
-      })), extra);
-    });
+      ```
 
-    var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
-      var _a = props.className,
-          className = _a === void 0 ? '' : _a,
-          style = props.style,
-          _b = props.layout,
-          layout = _b === void 0 ? 'horizontal' : _b,
-          initialValues = props.initialValues,
-          formInstance = props.form,
-          children = props.children,
-          onValuesChange = props.onValuesChange,
-          onSubmit = props.onSubmit,
-          onSubmitFailed = props.onSubmitFailed,
-          disabled = props.disabled;
-      var domRef = React.useRef(null);
-      var form = useForm(formInstance)[0];
+      @method reject
+      @static
+      @param {Any} reason value that the returned promise will be rejected with.
+      Useful for tooling.
+      @return {Promise} a promise rejected with the given `reason`.
+    */
+    function reject$1(reason) {
+      /*jshint validthis:true */
+      var Constructor = this;
+      var promise = new Constructor(noop);
+      reject(promise, reason);
+      return promise;
+    }
 
-      var _c = form.getInternalHooks(),
-          setCallbacks = _c.setCallbacks,
-          setInitialValues = _c.setInitialValues;
+    function needsResolver() {
+      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+    }
+
+    function needsNew() {
+      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+    }
 
-      setCallbacks({
-        onValuesChange: onValuesChange,
-        onSubmit: onSubmit,
-        onSubmitFailed: onSubmitFailed
-      });
-      React.useEffect(function () {
-        setInitialValues(initialValues || {});
-      }, []);
-      React.useImperativeHandle(ref, function () {
-        return {
-          dom: domRef.current,
-          form: form
-        };
-      });
-      var contextValue = {
-        form: form,
-        layout: layout,
-        disabled: disabled
-      };
-      return /*#__PURE__*/React__default["default"].createElement(ContextLayout, null, function (_a) {
-        var prefixCls = _a.prefixCls,
-            _b = _a.locale,
-            locale = _b === void 0 ? defaultLocale : _b;
-        return /*#__PURE__*/React__default["default"].createElement("form", {
-          className: prefixCls + "-form " + className,
-          style: style,
-          ref: domRef,
-          onSubmit: function onSubmit(e) {
-            e.preventDefault();
-            e.stopPropagation();
-            form.submit();
-          }
-        }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Provider, {
-          value: __assign$3(__assign$3({}, contextValue), {
-            validateMessages: (locale === null || locale === void 0 ? void 0 : locale.Form) || {}
-          })
-        }, children));
-      });
-    });
     /**
-     * 表单组件用于集合数据录入
-     * @en Form, Form for collecting data input
-     * @type 数据录入
-     * @type_en Data Entry
-     * @name 表单
-     * @name_en Form
-     */
+      Promise objects represent the eventual result of an asynchronous operation. The
+      primary way of interacting with a promise is through its `then` method, which
+      registers callbacks to receive either a promise's eventual value or the reason
+      why the promise cannot be fulfilled.
 
-    var index$i = componentWrapper(Form, {
-      Item: Item$1
-    });
+      Terminology
+      -----------
 
-    /**
-     * 宫格可以在水平方向上把页面分隔成等宽度的区块，用于展示内容或进行页面导航。
-     * @en The grid can divide the page into equal-width blocks in the horizontal direction for displaying content or for page navigation.
-     * @type 布局
-     * @type_en Layout
-     * @name 宫格
-     * @name_en Grid
-     */
+      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+      - `thenable` is an object or function that defines a `then` method.
+      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+      - `exception` is a value that is thrown using the throw statement.
+      - `reason` is a value that indicates why a promise was rejected.
+      - `settled` the final resting state of a promise, fulfilled or rejected.
 
-    var Grid = /*#__PURE__*/React.forwardRef(function (props, ref) {
-      var _a = props.className,
-          className = _a === void 0 ? '' : _a,
-          style = props.style,
-          data = props.data,
-          _b = props.columns,
-          columns = _b === void 0 ? 3 : _b,
-          _c = props.border,
-          border = _c === void 0 ? false : _c,
-          _d = props.gutter,
-          gutter = _d === void 0 ? 0 : _d,
-          _e = props.shape,
-          shape = _e === void 0 ? 'square' : _e,
-          _f = props.direction,
-          direction = _f === void 0 ? 'vertical' : _f,
-          _g = props.isSliding,
-          isSliding = _g === void 0 ? false : _g;
-      var useRtl = React.useContext(GlobalContext).useRtl;
-      var domRef = React.useRef(null);
-      React.useImperativeHandle(ref, function () {
-        return {
-          dom: domRef.current
-        };
-      });
-
-      var getRows = function getRows(prefix, rowsData, rows, row) {
-        var placeholders = !isSliding && rowsData.length % columns;
-        var renderData = rowsData;
-
-        if (placeholders) {
-          var fakeGrids = new Array(columns - placeholders).fill({
-            img: null,
-            title: ''
-          });
-          renderData = rowsData.concat(fakeGrids);
-        }
-
-        return /*#__PURE__*/React__default["default"].createElement("div", {
-          className: prefix + "-rows",
-          key: row
-        }, renderData.map(function (item, index) {
-          var _a;
-
-          var img = item.img,
-              title = item.title,
-              content = item.content,
-              itemClassName = item.className,
-              _onClick = item.onClick,
-              itemStyle = item.itemStyle,
-              renderGrid = item.renderGrid;
+      A promise can be in one of three states: pending, fulfilled, or rejected.
 
-          if (renderGrid) {
-            return renderGrid(item, index, row);
-          }
+      Promises that are fulfilled have a fulfillment value and are in the fulfilled
+      state.  Promises that are rejected have a rejection reason and are in the
+      rejected state.  A fulfillment value is never a thenable.
 
-          var marginBottom = row + 1 === rows ? 0 : typeof gutter === 'number' ? gutter : (gutter === null || gutter === void 0 ? void 0 : gutter.y) || 0;
-          var rowLen = renderData.length;
-          var marginValue = index + 1 === rowLen ? 0 : typeof gutter === 'number' ? gutter : (gutter === null || gutter === void 0 ? void 0 : gutter.x) || 0;
-          var marginStyle = (_a = {}, _a[useRtl ? 'marginLeft' : 'marginRight'] = marginValue, _a);
-          return /*#__PURE__*/React__default["default"].createElement("div", {
-            key: index,
-            style: __assign$3(__assign$3({
-              marginBottom: marginBottom
-            }, marginStyle), itemStyle),
-            onClick: function onClick() {
-              _onClick && _onClick(item);
-            },
-            className: cls(prefix + "-rows-item", {
-              horizontal: direction === 'horizontal',
-              border: border && gutter === 0
-            }, itemClassName)
-          }, typeof img === 'string' ? /*#__PURE__*/React__default["default"].createElement("img", {
-            src: img,
-            className: prefix + "-rows-item-icon " + (shape === 'circle' ? 'circle' : '')
-          }) : img, title || content ? /*#__PURE__*/React__default["default"].createElement("div", {
-            className: prefix + "-rows-item-text"
-          }, title ? /*#__PURE__*/React__default["default"].createElement("span", {
-            className: prefix + "-rows-item-title"
-          }, title) : null, content ? /*#__PURE__*/React__default["default"].createElement("span", {
-            className: prefix + "-rows-item-content"
-          }, content) : null) : null, (index + 1) % columns !== 0 ? /*#__PURE__*/React__default["default"].createElement("i", {
-            className: "vertical-border"
-          }) : null, (row + 1) % rows !== 0 ? /*#__PURE__*/React__default["default"].createElement("i", {
-            className: "horizontal-border"
-          }) : null);
-        }));
-      };
+      Promises can also be said to *resolve* a value.  If this value is also a
+      promise, then the original promise's settled state will match the value's
+      settled state.  So a promise that *resolves* a promise that rejects will
+      itself reject, and a promise that *resolves* a promise that fulfills will
+      itself fulfill.
 
-      var getGrid = function getGrid(prefix, dataArr) {
-        var rows = dataArr.length || 1;
-        return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, dataArr.map(function (item, index) {
-          return getRows(prefix, item, rows, index);
-        }));
-      };
 
-      var renderEl = function renderEl(_a) {
-        var prefixCls = _a.prefixCls;
-        var prefix = prefixCls + "-grid";
-        var dataLength = (data === null || data === void 0 ? void 0 : data.length) || 0;
+      Basic Usage:
+      ------------
 
-        if (dataLength === 0) {
-          return null;
-        }
+      ```js
+      let promise = new Promise(function(resolve, reject) {
+        // on success
+        resolve(value);
 
-        var index = 0;
-        var newArr = [];
+        // on failure
+        reject(reason);
+      });
 
-        while (index < dataLength) {
-          newArr.push(data.slice(index, isSliding ? index += dataLength : index += columns));
-        }
+      promise.then(function(value) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
 
-        return /*#__PURE__*/React__default["default"].createElement("div", {
-          className: cls(prefix, className, isSliding ? 'sliding' : ''),
-          style: style,
-          ref: domRef
-        }, getGrid(prefix, newArr));
-      };
+      Advanced Usage:
+      ---------------
 
-      return /*#__PURE__*/React__default["default"].createElement(ContextLayout, null, renderEl);
-    });
+      Promises shine when abstracting away asynchronous interactions such as
+      `XMLHttpRequest`s.
 
-    function AddIcon() {
-      return /*#__PURE__*/React__default["default"].createElement("svg", {
-        width: "30",
-        height: "30",
-        viewBox: "0 0 30 30",
-        fill: "none"
-      }, /*#__PURE__*/React__default["default"].createElement("path", {
-        fillRule: "evenodd",
-        clipRule: "evenodd",
-        d: "M14.5 0C14.2239 0 14 0.223857 14 0.5V14H0.5C0.223858 14 0 14.2239 0 14.5V15.5C0 15.7761 0.223857 16 0.5 16H14V29.5C14 29.7761 14.2239 30 14.5 30H15.5C15.7761 30 16 29.7761 16 29.5V16H29.5C29.7761 16 30 15.7761 30 15.5V14.5C30 14.2239 29.7761 14 29.5 14H16V0.5C16 0.223858 15.7761 0 15.5 0H14.5Z",
-        fill: "#C9CDD4"
-      }));
-    }
+      ```js
+      function getJSON(url) {
+        return new Promise(function(resolve, reject){
+          let xhr = new XMLHttpRequest();
 
-    var es6Promise = createCommonjsModule(function (module, exports) {
-    /*!
-     * @overview es6-promise - a tiny implementation of Promises/A+.
-     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
-     * @license   Licensed under MIT license
-     *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
-     * @version   v4.2.8+1e68dce6
-     */
+          xhr.open('GET', url);
+          xhr.onreadystatechange = handler;
+          xhr.responseType = 'json';
+          xhr.setRequestHeader('Accept', 'application/json');
+          xhr.send();
 
-    (function (global, factory) {
-    	module.exports = factory() ;
-    }(commonjsGlobal, (function () {
-    function objectOrFunction(x) {
-      var type = typeof x;
-      return x !== null && (type === 'object' || type === 'function');
-    }
+          function handler() {
+            if (this.readyState === this.DONE) {
+              if (this.status === 200) {
+                resolve(this.response);
+              } else {
+                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+              }
+            }
+          };
+        });
+      }
 
-    function isFunction(x) {
-      return typeof x === 'function';
-    }
+      getJSON('/posts.json').then(function(json) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
 
+      Unlike callbacks, promises are great composable primitives.
 
+      ```js
+      Promise.all([
+        getJSON('/posts'),
+        getJSON('/comments')
+      ]).then(function(values){
+        values[0] // => postsJSON
+        values[1] // => commentsJSON
 
-    var _isArray = void 0;
-    if (Array.isArray) {
-      _isArray = Array.isArray;
-    } else {
-      _isArray = function (x) {
-        return Object.prototype.toString.call(x) === '[object Array]';
-      };
-    }
+        return values;
+      });
+      ```
 
-    var isArray = _isArray;
+      @class Promise
+      @param {Function} resolver
+      Useful for tooling.
+      @constructor
+    */
 
-    var len = 0;
-    var vertxNext = void 0;
-    var customSchedulerFn = void 0;
+    var Promise$1 = function () {
+      function Promise(resolver) {
+        this[PROMISE_ID] = nextId();
+        this._result = this._state = undefined;
+        this._subscribers = [];
 
-    var asap = function asap(callback, arg) {
-      queue[len] = callback;
-      queue[len + 1] = arg;
-      len += 2;
-      if (len === 2) {
-        // If len is 2, that means that we need to schedule an async flush.
-        // If additional callbacks are queued before the queue is flushed, they
-        // will be processed by this flush that we are scheduling.
-        if (customSchedulerFn) {
-          customSchedulerFn(flush);
-        } else {
-          scheduleFlush();
+        if (noop !== resolver) {
+          typeof resolver !== 'function' && needsResolver();
+          this instanceof Promise ? initializePromise(this, resolver) : needsNew();
         }
       }
-    };
-
-    function setScheduler(scheduleFn) {
-      customSchedulerFn = scheduleFn;
-    }
 
-    function setAsap(asapFn) {
-      asap = asapFn;
-    }
-
-    var browserWindow = typeof window !== 'undefined' ? window : undefined;
-    var browserGlobal = browserWindow || {};
-    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+      /**
+      The primary way of interacting with a promise is through its `then` method,
+      which registers callbacks to receive either a promise's eventual value or the
+      reason why the promise cannot be fulfilled.
+       ```js
+      findUser().then(function(user){
+        // user is available
+      }, function(reason){
+        // user is unavailable, and you are given the reason why
+      });
+      ```
+       Chaining
+      --------
+       The return value of `then` is itself a promise.  This second, 'downstream'
+      promise is resolved with the return value of the first promise's fulfillment
+      or rejection handler, or rejected if the handler throws an exception.
+       ```js
+      findUser().then(function (user) {
+        return user.name;
+      }, function (reason) {
+        return 'default name';
+      }).then(function (userName) {
+        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+        // will be `'default name'`
+      });
+       findUser().then(function (user) {
+        throw new Error('Found user, but still unhappy');
+      }, function (reason) {
+        throw new Error('`findUser` rejected and we're unhappy');
+      }).then(function (value) {
+        // never reached
+      }, function (reason) {
+        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+      });
+      ```
+      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+       ```js
+      findUser().then(function (user) {
+        throw new PedagogicalException('Upstream error');
+      }).then(function (value) {
+        // never reached
+      }).then(function (value) {
+        // never reached
+      }, function (reason) {
+        // The `PedgagocialException` is propagated all the way down to here
+      });
+      ```
+       Assimilation
+      ------------
+       Sometimes the value you want to propagate to a downstream promise can only be
+      retrieved asynchronously. This can be achieved by returning a promise in the
+      fulfillment or rejection handler. The downstream promise will then be pending
+      until the returned promise is settled. This is called *assimilation*.
+       ```js
+      findUser().then(function (user) {
+        return findCommentsByAuthor(user);
+      }).then(function (comments) {
+        // The user's comments are now available
+      });
+      ```
+       If the assimliated promise rejects, then the downstream promise will also reject.
+       ```js
+      findUser().then(function (user) {
+        return findCommentsByAuthor(user);
+      }).then(function (comments) {
+        // If `findCommentsByAuthor` fulfills, we'll have the value here
+      }, function (reason) {
+        // If `findCommentsByAuthor` rejects, we'll have the reason here
+      });
+      ```
+       Simple Example
+      --------------
+       Synchronous Example
+       ```javascript
+      let result;
+       try {
+        result = findResult();
+        // success
+      } catch(reason) {
+        // failure
+      }
+      ```
+       Errback Example
+       ```js
+      findResult(function(result, err){
+        if (err) {
+          // failure
+        } else {
+          // success
+        }
+      });
+      ```
+       Promise Example;
+       ```javascript
+      findResult().then(function(result){
+        // success
+      }, function(reason){
+        // failure
+      });
+      ```
+       Advanced Example
+      --------------
+       Synchronous Example
+       ```javascript
+      let author, books;
+       try {
+        author = findAuthor();
+        books  = findBooksByAuthor(author);
+        // success
+      } catch(reason) {
+        // failure
+      }
+      ```
+       Errback Example
+       ```js
+       function foundBooks(books) {
+       }
+       function failure(reason) {
+       }
+       findAuthor(function(author, err){
+        if (err) {
+          failure(err);
+          // failure
+        } else {
+          try {
+            findBoooksByAuthor(author, function(books, err) {
+              if (err) {
+                failure(err);
+              } else {
+                try {
+                  foundBooks(books);
+                } catch(reason) {
+                  failure(reason);
+                }
+              }
+            });
+          } catch(error) {
+            failure(err);
+          }
+          // success
+        }
+      });
+      ```
+       Promise Example;
+       ```javascript
+      findAuthor().
+        then(findBooksByAuthor).
+        then(function(books){
+          // found books
+      }).catch(function(reason){
+        // something went wrong
+      });
+      ```
+       @method then
+      @param {Function} onFulfilled
+      @param {Function} onRejected
+      Useful for tooling.
+      @return {Promise}
+      */
 
-    // test for web worker but not in IE10
-    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+      /**
+      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+      as the catch block of a try/catch statement.
+      ```js
+      function findAuthor(){
+      throw new Error('couldn't find that author');
+      }
+      // synchronous
+      try {
+      findAuthor();
+      } catch(reason) {
+      // something went wrong
+      }
+      // async with promises
+      findAuthor().catch(function(reason){
+      // something went wrong
+      });
+      ```
+      @method catch
+      @param {Function} onRejection
+      Useful for tooling.
+      @return {Promise}
+      */
 
-    // node
-    function useNextTick() {
-      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-      // see https://github.com/cujojs/when/issues/410 for details
-      return function () {
-        return process.nextTick(flush);
+
+      Promise.prototype.catch = function _catch(onRejection) {
+        return this.then(null, onRejection);
       };
-    }
 
-    // vertx
-    function useVertxTimer() {
-      if (typeof vertxNext !== 'undefined') {
-        return function () {
-          vertxNext(flush);
-        };
-      }
+      /**
+        `finally` will be invoked regardless of the promise's fate just as native
+        try/catch/finally behaves
+      
+        Synchronous example:
+      
+        ```js
+        findAuthor() {
+          if (Math.random() > 0.5) {
+            throw new Error();
+          }
+          return new Author();
+        }
+      
+        try {
+          return findAuthor(); // succeed or fail
+        } catch(error) {
+          return findOtherAuther();
+        } finally {
+          // always runs
+          // doesn't affect the return value
+        }
+        ```
+      
+        Asynchronous example:
+      
+        ```js
+        findAuthor().catch(function(reason){
+          return findOtherAuther();
+        }).finally(function(){
+          // author was either found, or not
+        });
+        ```
+      
+        @method finally
+        @param {Function} callback
+        @return {Promise}
+      */
 
-      return useSetTimeout();
-    }
 
-    function useMutationObserver() {
-      var iterations = 0;
-      var observer = new BrowserMutationObserver(flush);
-      var node = document.createTextNode('');
-      observer.observe(node, { characterData: true });
+      Promise.prototype.finally = function _finally(callback) {
+        var promise = this;
+        var constructor = promise.constructor;
 
-      return function () {
-        node.data = iterations = ++iterations % 2;
-      };
-    }
+        if (isFunction(callback)) {
+          return promise.then(function (value) {
+            return constructor.resolve(callback()).then(function () {
+              return value;
+            });
+          }, function (reason) {
+            return constructor.resolve(callback()).then(function () {
+              throw reason;
+            });
+          });
+        }
 
-    // web worker
-    function useMessageChannel() {
-      var channel = new MessageChannel();
-      channel.port1.onmessage = flush;
-      return function () {
-        return channel.port2.postMessage(0);
+        return promise.then(callback, callback);
       };
-    }
 
-    function useSetTimeout() {
-      // Store setTimeout reference so es6-promise will be unaffected by
-      // other code modifying setTimeout (like sinon.useFakeTimers())
-      var globalSetTimeout = setTimeout;
-      return function () {
-        return globalSetTimeout(flush, 1);
-      };
-    }
+      return Promise;
+    }();
 
-    var queue = new Array(1000);
-    function flush() {
-      for (var i = 0; i < len; i += 2) {
-        var callback = queue[i];
-        var arg = queue[i + 1];
+    Promise$1.prototype.then = then;
+    Promise$1.all = all;
+    Promise$1.race = race;
+    Promise$1.resolve = resolve$1;
+    Promise$1.reject = reject$1;
+    Promise$1._setScheduler = setScheduler;
+    Promise$1._setAsap = setAsap;
+    Promise$1._asap = asap;
 
-        callback(arg);
+    /*global self*/
+    function polyfill() {
+      var local = void 0;
 
-        queue[i] = undefined;
-        queue[i + 1] = undefined;
+      if (typeof commonjsGlobal !== 'undefined') {
+        local = commonjsGlobal;
+      } else if (typeof self !== 'undefined') {
+        local = self;
+      } else {
+        try {
+          local = Function('return this')();
+        } catch (e) {
+          throw new Error('polyfill failed because global object is unavailable in this environment');
+        }
       }
 
-      len = 0;
-    }
+      var P = local.Promise;
 
-    function attemptVertx() {
-      try {
-        var vertx = Function('return this')().require('vertx');
-        vertxNext = vertx.runOnLoop || vertx.runOnContext;
-        return useVertxTimer();
-      } catch (e) {
-        return useSetTimeout();
+      if (P) {
+        var promiseToString = null;
+        try {
+          promiseToString = Object.prototype.toString.call(P.resolve());
+        } catch (e) {
+          // silently ignored
+        }
+
+        if (promiseToString === '[object Promise]' && !P.cast) {
+          return;
+        }
       }
-    }
 
-    var scheduleFlush = void 0;
-    // Decide what async method to use to triggering processing of queued callbacks:
-    if (isNode) {
-      scheduleFlush = useNextTick();
-    } else if (BrowserMutationObserver) {
-      scheduleFlush = useMutationObserver();
-    } else if (isWorker) {
-      scheduleFlush = useMessageChannel();
-    } else if (browserWindow === undefined && typeof commonjsRequire === 'function') {
-      scheduleFlush = attemptVertx();
-    } else {
-      scheduleFlush = useSetTimeout();
+      local.Promise = Promise$1;
     }
 
-    function then(onFulfillment, onRejection) {
-      var parent = this;
+    // Strange compat..
+    Promise$1.polyfill = polyfill;
+    Promise$1.Promise = Promise$1;
 
-      var child = new this.constructor(noop);
+    return Promise$1;
 
-      if (child[PROMISE_ID] === undefined) {
-        makePromise(child);
-      }
+    })));
 
-      var _state = parent._state;
 
 
-      if (_state) {
-        var callback = arguments[_state - 1];
-        asap(function () {
-          return invokeCallback(_state, child, callback, parent._result);
-        });
-      } else {
-        subscribe(parent, child, onFulfillment, onRejection);
+
+    });
+
+    var defaultFunc = function defaultFunc() {};
+
+    var defaultFormDataMethods = {
+      getFieldValue: function getFieldValue(name) {
+        return name;
+      },
+      getFieldsValue: function getFieldsValue(_names) {
+        return {};
+      },
+      getFieldError: function getFieldError(_name) {
+        return [];
+      },
+      setFieldValue: function setFieldValue(_name, _value) {
+        return true;
+      },
+      setFieldsValue: function setFieldsValue(_values) {
+        return true;
+      },
+      registerField: function registerField(_name, _self) {
+        return function () {};
+      },
+      resetFields: defaultFunc,
+      validateFields: defaultFunc,
+      submit: defaultFunc,
+      getInternalHooks: function getInternalHooks() {
+        return {
+          registerField: defaultFunc,
+          setInitialValues: defaultFunc,
+          setCallbacks: defaultFunc
+        };
       }
+    }; // 在field的静态的状态下设置
 
-      return child;
-    }
+    var FormData =
+    /** @class */
+    function () {
+      function FormData() {
+        var _this = this;
 
-    /**
-      `Promise.resolve` returns a promise that will become resolved with the
-      passed `value`. It is shorthand for the following:
+        this._formData = {}; // 数据源
 
-      ```javascript
-      let promise = new Promise(function(resolve, reject){
-        resolve(1);
-      });
+        this._fieldsList = {}; // 字段列表
 
-      promise.then(function(value){
-        // value === 1
-      });
-      ```
+        this._initialValues = {}; // 初始值
 
-      Instead of writing the above, your code now simply becomes the following:
+        this._callbacks = {};
 
-      ```javascript
-      let promise = Promise.resolve(1);
+        this.setFieldsValue = function (values) {
+          var oldValues = Object.keys(values).reduce(function (acc, key) {
+            var _a;
 
-      promise.then(function(value){
-        // value === 1
-      });
-      ```
+            return __assign$3(__assign$3({}, acc), (_a = {}, _a[key] = _this.getFieldValue(key), _a));
+          }, {});
+          _this._formData = __assign$3(__assign$3({}, _this._formData), values);
+          var onValuesChange = _this._callbacks.onValuesChange;
+          onValuesChange && onValuesChange(values, _this._formData);
 
-      @method resolve
-      @static
-      @param {Any} value value that the returned promise will be resolved with
-      Useful for tooling.
-      @return {Promise} a promise that will become fulfilled with the given
-      `value`
-    */
-    function resolve$1(object) {
-      /*jshint validthis:true */
-      var Constructor = this;
+          _this.notifyField(values, oldValues);
 
-      if (object && typeof object === 'object' && object.constructor === Constructor) {
-        return object;
-      }
+          return true;
+        };
 
-      var promise = new Constructor(noop);
-      resolve(promise, object);
-      return promise;
-    }
+        this.setFieldValue = function (name, value) {
+          var _a, _b, _c, _d;
 
-    var PROMISE_ID = Math.random().toString(36).substring(2);
+          var oldValues = (_a = {}, _a[name] = _this.getFieldValue(name), _a);
+          _this._formData = __assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = value, _b));
+          var onValuesChange = _this._callbacks.onValuesChange;
+          onValuesChange && onValuesChange((_c = {}, _c[name] = value, _c), _this._formData);
 
-    function noop() {}
+          _this.notifyField((_d = {}, _d[name] = value, _d), oldValues);
 
-    var PENDING = void 0;
-    var FULFILLED = 1;
-    var REJECTED = 2;
+          return true;
+        };
 
-    function selfFulfillment() {
-      return new TypeError("You cannot resolve a promise with itself");
-    }
+        this.notifyField = function (values, oldValues) {
+          Object.keys(values).map(function (fieldName) {
+            var _a;
 
-    function cannotReturnOwn() {
-      return new TypeError('A promises callback cannot return that same promise.');
-    }
+            var fieldObj = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[fieldName]) || null;
 
-    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
-      try {
-        then$$1.call(value, fulfillmentHandler, rejectionHandler);
-      } catch (e) {
-        return e;
-      }
-    }
+            if (fieldObj) {
+              fieldObj.onValueChange(values[fieldName], oldValues[fieldName]);
+            }
+          });
+        };
 
-    function handleForeignThenable(promise, thenable, then$$1) {
-      asap(function (promise) {
-        var sealed = false;
-        var error = tryThen(then$$1, thenable, function (value) {
-          if (sealed) {
-            return;
-          }
-          sealed = true;
-          if (thenable !== value) {
-            resolve(promise, value);
-          } else {
-            fulfill(promise, value);
-          }
-        }, function (reason) {
-          if (sealed) {
-            return;
+        this.getFieldsValue = function (names) {
+          if (names) {
+            return names.map(function (name) {
+              return _this.getFieldValue(name);
+            });
           }
-          sealed = true;
-
-          reject(promise, reason);
-        }, 'Settle: ' + (promise._label || ' unknown promise'));
 
-        if (!sealed && error) {
-          sealed = true;
-          reject(promise, error);
-        }
-      }, promise);
-    }
+          return _this._formData;
+        };
 
-    function handleOwnThenable(promise, thenable) {
-      if (thenable._state === FULFILLED) {
-        fulfill(promise, thenable._result);
-      } else if (thenable._state === REJECTED) {
-        reject(promise, thenable._result);
-      } else {
-        subscribe(thenable, undefined, function (value) {
-          return resolve(promise, value);
-        }, function (reason) {
-          return reject(promise, reason);
-        });
-      }
-    }
+        this.getFieldValue = function (name) {
+          var _a;
 
-    function handleMaybeThenable(promise, maybeThenable, then$$1) {
-      if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
-        handleOwnThenable(promise, maybeThenable);
-      } else {
-        if (then$$1 === undefined) {
-          fulfill(promise, maybeThenable);
-        } else if (isFunction(then$$1)) {
-          handleForeignThenable(promise, maybeThenable, then$$1);
-        } else {
-          fulfill(promise, maybeThenable);
-        }
-      }
-    }
+          return (_a = _this._formData) === null || _a === void 0 ? void 0 : _a[name];
+        };
 
-    function resolve(promise, value) {
-      if (promise === value) {
-        reject(promise, selfFulfillment());
-      } else if (objectOrFunction(value)) {
-        var then$$1 = void 0;
-        try {
-          then$$1 = value.then;
-        } catch (error) {
-          reject(promise, error);
-          return;
-        }
-        handleMaybeThenable(promise, value, then$$1);
-      } else {
-        fulfill(promise, value);
-      }
-    }
+        this.getFieldError = function (name) {
+          var _a;
 
-    function publishRejection(promise) {
-      if (promise._onerror) {
-        promise._onerror(promise._result);
-      }
+          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
 
-      publish(promise);
-    }
+          if (field) {
+            return field.getFieldError();
+          }
 
-    function fulfill(promise, value) {
-      if (promise._state !== PENDING) {
-        return;
-      }
+          return [];
+        };
 
-      promise._result = value;
-      promise._state = FULFILLED;
+        this.getFieldsError = function (names) {
+          var fields = names || Object.keys(_this._fieldsList);
+          return fields.reduce(function (pre, name) {
+            var _a;
 
-      if (promise._subscribers.length !== 0) {
-        asap(publish, promise);
-      }
-    }
+            var theField = (_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name];
 
-    function reject(promise, reason) {
-      if (promise._state !== PENDING) {
-        return;
-      }
-      promise._state = REJECTED;
-      promise._result = reason;
+            if (theField) {
+              pre[name] = theField === null || theField === void 0 ? void 0 : theField.getFieldError();
+            }
 
-      asap(publishRejection, promise);
-    }
+            return pre;
+          }, {});
+        };
 
-    function subscribe(parent, child, onFulfillment, onRejection) {
-      var _subscribers = parent._subscribers;
-      var length = _subscribers.length;
+        this.isFieldTouched = function (name) {
+          var _a;
 
+          var field = ((_a = _this._fieldsList) === null || _a === void 0 ? void 0 : _a[name]) || null;
 
-      parent._onerror = null;
+          if (field) {
+            return field.isFieldTouched();
+          }
 
-      _subscribers[length] = child;
-      _subscribers[length + FULFILLED] = onFulfillment;
-      _subscribers[length + REJECTED] = onRejection;
+          return false;
+        };
 
-      if (length === 0 && parent._state) {
-        asap(publish, parent);
-      }
-    }
+        this.registerField = function (name, self) {
+          var _a, _b;
 
-    function publish(promise) {
-      var subscribers = promise._subscribers;
-      var settled = promise._state;
+          _this._fieldsList[name] = self;
+          var initialValue = self.props.initialValue;
 
-      if (subscribers.length === 0) {
-        return;
-      }
+          if (initialValue !== undefined && name) {
+            _this._initialValues = __assign$3(__assign$3({}, _this._initialValues), (_a = {}, _a[name] = initialValue, _a));
 
-      var child = void 0,
-          callback = void 0,
-          detail = promise._result;
+            _this.setFieldsValue(__assign$3(__assign$3({}, _this._formData), (_b = {}, _b[name] = initialValue, _b)));
+          }
 
-      for (var i = 0; i < subscribers.length; i += 3) {
-        child = subscribers[i];
-        callback = subscribers[i + settled];
+          return function () {
+            if (name in _this._fieldsList) {
+              delete _this._fieldsList[name];
+              delete _this._formData[name];
+            }
+          };
+        };
 
-        if (child) {
-          invokeCallback(settled, child, callback, detail);
-        } else {
-          callback(detail);
-        }
-      }
+        this.setInitialValues = function (initVal) {
+          _this._initialValues = __assign$3({}, initVal || {});
 
-      promise._subscribers.length = 0;
-    }
+          _this.setFieldsValue(initVal);
+        };
 
-    function invokeCallback(settled, promise, callback, detail) {
-      var hasCallback = isFunction(callback),
-          value = void 0,
-          error = void 0,
-          succeeded = true;
+        this.resetFields = function () {
+          _this.setFieldsValue(_this._initialValues);
+        };
 
-      if (hasCallback) {
-        try {
-          value = callback(detail);
-        } catch (e) {
-          succeeded = false;
-          error = e;
-        }
+        this.validateFields = function () {
+          var promiseList = [];
+          Object.values(_this._fieldsList).forEach(function (entity) {
+            var promise = entity.validateField();
+            promiseList.push(promise.then(function (errors) {
+              return errors;
+            }));
+          });
+          var summaryPromise = new es6Promise.Promise(function (resolve, reject) {
+            es6Promise.Promise.all(promiseList).then(function (res) {
+              var errorResults = res.filter(function (item) {
+                var _a;
 
-        if (promise === value) {
-          reject(promise, cannotReturnOwn());
-          return;
-        }
-      } else {
-        value = detail;
-      }
+                return (_a = item === null || item === void 0 ? void 0 : item.errors) === null || _a === void 0 ? void 0 : _a.length;
+              });
 
-      if (promise._state !== PENDING) ; else if (hasCallback && succeeded) {
-        resolve(promise, value);
-      } else if (succeeded === false) {
-        reject(promise, error);
-      } else if (settled === FULFILLED) {
-        fulfill(promise, value);
-      } else if (settled === REJECTED) {
-        reject(promise, value);
-      }
-    }
+              if (errorResults.length) {
+                reject(errorResults);
+              } else {
+                resolve(res);
+              }
+            });
+          });
+          return summaryPromise;
+        };
 
-    function initializePromise(promise, resolver) {
-      try {
-        resolver(function resolvePromise(value) {
-          resolve(promise, value);
-        }, function rejectPromise(reason) {
-          reject(promise, reason);
-        });
-      } catch (e) {
-        reject(promise, e);
-      }
-    }
+        this.submit = function () {
+          _this.validateFields().then(function (result) {
+            var onSubmit = _this._callbacks.onSubmit;
+            onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(_this._formData, result);
+          }).catch(function (e) {
+            var onSubmitFailed = _this._callbacks.onSubmitFailed;
 
-    var id = 0;
-    function nextId() {
-      return id++;
-    }
+            if (!onSubmitFailed) {
+              return;
+            }
 
-    function makePromise(promise) {
-      promise[PROMISE_ID] = id++;
-      promise._state = undefined;
-      promise._result = undefined;
-      promise._subscribers = [];
-    }
+            onSubmitFailed(_this._formData, e);
+          });
+        };
 
-    function validationError() {
-      return new Error('Array Methods must be provided an Array');
-    }
+        this.setCallbacks = function (callbacks) {
+          _this._callbacks = callbacks;
+        };
 
-    var Enumerator = function () {
-      function Enumerator(Constructor, input) {
-        this._instanceConstructor = Constructor;
-        this.promise = new Constructor(noop);
+        this.getMethods = function () {
+          return {
+            setFieldsValue: _this.setFieldsValue,
+            setFieldValue: _this.setFieldValue,
+            getFieldsValue: _this.getFieldsValue,
+            getFieldValue: _this.getFieldValue,
+            getFieldError: _this.getFieldError,
+            getFieldsError: _this.getFieldsError,
+            isFieldTouched: _this.isFieldTouched,
+            registerField: _this.registerField,
+            resetFields: _this.resetFields,
+            submit: _this.submit,
+            getInternalHooks: _this.getInternalHooks,
+            validateFields: _this.validateFields
+          };
+        };
 
-        if (!this.promise[PROMISE_ID]) {
-          makePromise(this.promise);
-        }
+        this.getInternalHooks = function () {
+          return {
+            registerField: _this.registerField,
+            setInitialValues: _this.setInitialValues,
+            setCallbacks: _this.setCallbacks
+          };
+        };
+      }
 
-        if (isArray(input)) {
-          this.length = input.length;
-          this._remaining = input.length;
+      return FormData;
+    }();
 
-          this._result = new Array(this.length);
+    function useForm(form) {
+      var formInstanceRef = React.useRef(defaultFormDataMethods);
+      var isSingletonRef = React.useRef(false);
 
-          if (this.length === 0) {
-            fulfill(this.promise, this._result);
-          } else {
-            this.length = this.length || 0;
-            this._enumerate(input);
-            if (this._remaining === 0) {
-              fulfill(this.promise, this._result);
-            }
-          }
+      if (!isSingletonRef.current) {
+        if (form) {
+          formInstanceRef.current = form;
         } else {
-          reject(this.promise, validationError());
+          var formIns = new FormData();
+          formInstanceRef.current = formIns.getMethods();
         }
+
+        isSingletonRef.current = true;
       }
 
-      Enumerator.prototype._enumerate = function _enumerate(input) {
-        for (var i = 0; this._state === PENDING && i < input.length; i++) {
-          this._eachEntry(input[i], i);
-        }
-      };
+      return [formInstanceRef.current];
+    }
 
-      Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
-        var c = this._instanceConstructor;
-        var resolve$$1 = c.resolve;
+    var FormItemContext = /*#__PURE__*/React__default["default"].createContext({
+      form: defaultFormDataMethods,
+      layout: 'horizontal'
+    });
 
+    // 注意：自动识别form关联组件的依据，请勿轻易改变代码结构
+    // Notice: Automatically identify the basis of the associated component of the form, DO NOT change the code structure.
+    var FormInternalComponentType;
 
-        if (resolve$$1 === resolve$1) {
-          var _then = void 0;
-          var error = void 0;
-          var didError = false;
-          try {
-            _then = entry.then;
-          } catch (e) {
-            didError = true;
-            error = e;
-          }
+    (function (FormInternalComponentType) {
+      FormInternalComponentType["Input"] = "Input";
+      FormInternalComponentType["Textarea"] = "Textarea";
+      FormInternalComponentType["Checkbox"] = "Checkbox";
+      FormInternalComponentType["CheckboxGroup"] = "CheckboxGroup";
+      FormInternalComponentType["DatePicker"] = "DatePicker";
+      FormInternalComponentType["Picker"] = "Picker";
+      FormInternalComponentType["Radio"] = "Radio";
+      FormInternalComponentType["RadioGroup"] = "RadioGroup";
+      FormInternalComponentType["Slider"] = "Slider";
+      FormInternalComponentType["Switch"] = "Switch";
+      FormInternalComponentType["ImagePicker"] = "ImagePicker";
+      FormInternalComponentType["Rate"] = "Rate";
+      FormInternalComponentType["Stepper"] = "Stepper";
+    })(FormInternalComponentType || (FormInternalComponentType = {}));
 
-          if (_then === then && entry._state !== PENDING) {
-            this._settledAt(entry._state, i, entry._result);
-          } else if (typeof _then !== 'function') {
-            this._remaining--;
-            this._result[i] = entry;
-          } else if (c === Promise$1) {
-            var promise = new c(noop);
-            if (didError) {
-              reject(promise, error);
-            } else {
-              handleMaybeThenable(promise, entry, _then);
-            }
-            this._willSettleAt(promise, i);
-          } else {
-            this._willSettleAt(new c(function (resolve$$1) {
-              return resolve$$1(entry);
-            }), i);
-          }
-        } else {
-          this._willSettleAt(resolve$$1(entry), i);
-        }
-      };
+    var ValidateStatus;
 
-      Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
-        var promise = this.promise;
+    (function (ValidateStatus) {
+      ValidateStatus["Init"] = "init";
+      ValidateStatus["Error"] = "error";
+      ValidateStatus["Warning"] = "warning";
+      ValidateStatus["Validating"] = "validating";
+      ValidateStatus["Success"] = "success";
+    })(ValidateStatus || (ValidateStatus = {}));
 
+    var isFieldRequired = function isFieldRequired(rules) {
+      if (rules === void 0) {
+        rules = [];
+      }
 
-        if (promise._state === PENDING) {
-          this._remaining--;
+      return (rules || []).some(function (rule) {
+        return rule === null || rule === void 0 ? void 0 : rule.required;
+      });
+    };
+    var getErrorAndWarnings = function getErrorAndWarnings(result) {
+      var errors = [];
+      var warnings = [];
+      var errorTypes = [];
+      result.map(function (_a) {
+        var _b = _a.message,
+            message = _b === void 0 ? [] : _b,
+            _c = _a.validateLevel,
+            validateLevel = _c === void 0 ? 'error' : _c,
+            resultErrorTypes = _a.errorTypes;
 
-          if (state === REJECTED) {
-            reject(promise, value);
-          } else {
-            this._result[i] = value;
-          }
+        if (!(message === null || message === void 0 ? void 0 : message.length)) {
+          return;
         }
 
-        if (this._remaining === 0) {
-          fulfill(promise, this._result);
+        if (validateLevel === 'warning') {
+          warnings = __spreadArrays$1(warnings, message);
+        } else {
+          errors = __spreadArrays$1(errors, message);
+          errorTypes = __spreadArrays$1(errorTypes, resultErrorTypes);
         }
+      });
+      return {
+        warnings: warnings,
+        errors: errors,
+        errorTypes: errorTypes
       };
+    };
 
-      Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
-        var enumerator = this;
-
-        subscribe(promise, undefined, function (value) {
-          return enumerator._settledAt(FULFILLED, i, value);
-        }, function (reason) {
-          return enumerator._settledAt(REJECTED, i, reason);
-        });
-      };
-
-      return Enumerator;
-    }();
-
-    /**
-      `Promise.all` accepts an array of promises, and returns a new promise which
-      is fulfilled with an array of fulfillment values for the passed promises, or
-      rejected with the reason of the first passed promise to be rejected. It casts all
-      elements of the passed iterable to promises as it runs this algorithm.
-
-      Example:
+    function DefaultPickerLinkedContainer(_a) {
+      var value = _a.value;
 
-      ```javascript
-      let promise1 = resolve(1);
-      let promise2 = resolve(2);
-      let promise3 = resolve(3);
-      let promises = [ promise1, promise2, promise3 ];
+      var _b = React.useContext(GlobalContext),
+          prefixCls = _b.prefixCls,
+          locale = _b.locale;
 
-      Promise.all(promises).then(function(array){
-        // The array here would be [ 1, 2, 3 ];
-      });
-      ```
+      var className = prefixCls + "-form-picker-link-container";
+      return /*#__PURE__*/React__default["default"].createElement("div", {
+        className: className
+      }, value && value.length ? value.join('-') : /*#__PURE__*/React__default["default"].createElement("span", {
+        className: className + "-placeholder"
+      }, locale === null || locale === void 0 ? void 0 : locale.Form.pickerDefaultHint));
+    }
+    function DefaultDatePickerLinkedContainer(_a) {
+      var ts = _a.ts,
+          types = _a.types;
 
-      If any of the `promises` given to `all` are rejected, the first promise
-      that is rejected will be given as an argument to the returned promises's
-      rejection handler. For example:
+      var _b = React.useContext(GlobalContext),
+          prefixCls = _b.prefixCls,
+          locale = _b.locale;
 
-      Example:
+      var className = prefixCls + "-form-picker-link-container";
+      var dateTimeStr = React.useMemo(function () {
+        return formatDateTimeStr(ts, types);
+      }, [ts, types]);
 
-      ```javascript
-      let promise1 = resolve(1);
-      let promise2 = reject(new Error("2"));
-      let promise3 = reject(new Error("3"));
-      let promises = [ promise1, promise2, promise3 ];
+      function formatDateTimeStr(timestamp, itemTypes) {
+        var dateObj = convertTsToDateObj(timestamp);
+        var validDateObj = Object.keys(dateObj).reduce(function (acc, key) {
+          var _a;
 
-      Promise.all(promises).then(function(array){
-        // Code here never runs because there are rejected promises!
-      }, function(error) {
-        // error.message === "2"
-      });
-      ```
+          return __assign$3(__assign$3({}, acc), itemTypes.includes(key) ? (_a = {}, _a[key] = formatDateNumber(dateObj[key]), _a) : {});
+        }, {});
+        var dateStr = [validDateObj.year, validDateObj.month, validDateObj.date].filter(function (v) {
+          return v;
+        }).join('-');
+        var timeStr = [validDateObj.hour, validDateObj.minute, validDateObj.second].filter(function (v) {
+          return v;
+        }).join(':');
+        return dateStr + " " + timeStr;
+      }
 
-      @method all
-      @static
-      @param {Array} entries array of promises
-      @param {String} label optional string for labeling the promise.
-      Useful for tooling.
-      @return {Promise} promise that is fulfilled when all `promises` have been
-      fulfilled, or rejected if any of them become rejected.
-      @static
-    */
-    function all(entries) {
-      return new Enumerator(this, entries).promise;
+      return /*#__PURE__*/React__default["default"].createElement("div", {
+        className: className
+      }, ts ? dateTimeStr : /*#__PURE__*/React__default["default"].createElement("span", {
+        className: className + "-placeholder"
+      }, locale === null || locale === void 0 ? void 0 : locale.Form.pickerDefaultHint));
     }
 
-    /**
-      `Promise.race` returns a new promise which is settled in the same way as the
-      first passed promise to settle.
+    var FormItemInner =
+    /** @class */
+    function (_super) {
+      __extends$1(FormItemInner, _super);
 
-      Example:
+      function FormItemInner(props, context) {
+        var _a;
 
-      ```javascript
-      let promise1 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 1');
-        }, 200);
-      });
+        var _this = _super.call(this, props) || this;
 
-      let promise2 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 2');
-        }, 100);
-      });
+        _this._errors = [];
+        _this._touched = false;
 
-      Promise.race([promise1, promise2]).then(function(result){
-        // result === 'promise 2' because it was resolved before promise1
-        // was resolved.
-      });
-      ```
+        _this.onValueChange = function (curValue, preValue) {
+          _this._touched = true;
+          var shouldUpdate = _this.props.shouldUpdate;
 
-      `Promise.race` is deterministic in that only the state of the first
-      settled promise matters. For example, even if other promises given to the
-      `promises` array argument are resolved, but the first settled promise has
-      become rejected before the other promises became fulfilled, the returned
-      promise will become rejected:
+          if (typeof shouldUpdate === 'function') {
+            shouldUpdate({
+              preValue: preValue,
+              curValue: curValue
+            }) && _this.forceUpdate();
+            return;
+          }
 
-      ```javascript
-      let promise1 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          resolve('promise 1');
-        }, 200);
-      });
+          _this.forceUpdate();
+        };
 
-      let promise2 = new Promise(function(resolve, reject){
-        setTimeout(function(){
-          reject(new Error('promise 2'));
-        }, 100);
-      });
+        _this.getFieldError = function () {
+          return _this._errors;
+        };
 
-      Promise.race([promise1, promise2]).then(function(result){
-        // Code here never runs
-      }, function(reason){
-        // reason.message === 'promise 2' because promise 2 became rejected before
-        // promise 1 became fulfilled
-      });
-      ```
+        _this.isFieldTouched = function () {
+          return _this._touched;
+        };
 
-      An example real-world use case is implementing timeouts:
+        _this.validateField = function () {
+          var _a;
 
-      ```javascript
-      Promise.race([ajax('foo.json'), timeout(5000)])
-      ```
+          var validateMessages = _this.context.validateMessages;
+          var getFieldValue = _this.context.form.getFieldValue;
+          var _b = _this.props,
+              field = _b.field,
+              rules = _b.rules,
+              onValidateStatusChange = _b.onValidateStatusChange;
+          var value = getFieldValue(field);
 
-      @method race
-      @static
-      @param {Array} promises array of promises to observe
-      Useful for tooling.
-      @return {Promise} a promise which settles in the same way as the first passed
-      promise to settle.
-    */
-    function race(entries) {
-      /*jshint validthis:true */
-      var Constructor = this;
+          if ((rules === null || rules === void 0 ? void 0 : rules.length) && field) {
+            var fieldDom_1 = _this.props.getFormItemRef();
 
-      if (!isArray(entries)) {
-        return new Constructor(function (_, reject) {
-          return reject(new TypeError('You must pass an array to race.'));
-        });
-      } else {
-        return new Constructor(function (resolve, reject) {
-          var length = entries.length;
-          for (var i = 0; i < length; i++) {
-            Constructor.resolve(entries[i]).then(resolve, reject);
-          }
-        });
-      }
-    }
+            var fieldValidator_1 = new Validator((_a = {}, _a[field] = rules, _a), {
+              validateMessages: validateMessages
+            });
+            return new es6Promise.Promise(function (resolve) {
+              var _a;
 
-    /**
-      `Promise.reject` returns a promise rejected with the passed `reason`.
-      It is shorthand for the following:
+              fieldValidator_1.validate((_a = {}, _a[field] = value, _a), function (errorsMap) {
+                var _a = getErrorAndWarnings((errorsMap === null || errorsMap === void 0 ? void 0 : errorsMap[field]) || []),
+                    errors = _a.errors,
+                    warnings = _a.warnings,
+                    errorTypes = _a.errorTypes;
 
-      ```javascript
-      let promise = new Promise(function(resolve, reject){
-        reject(new Error('WHOOPS'));
-      });
+                _this._errors = errors;
+                onValidateStatusChange({
+                  errors: _this._errors,
+                  warnings: warnings,
+                  errorTypes: errorTypes
+                });
+                return resolve({
+                  errors: _this._errors,
+                  warnings: warnings,
+                  value: value,
+                  field: field,
+                  dom: fieldDom_1
+                });
+              });
+            });
+          }
 
-      promise.then(function(value){
-        // Code here doesn't run because the promise is rejected!
-      }, function(reason){
-        // reason.message === 'WHOOPS'
-      });
-      ```
+          return es6Promise.Promise.resolve({
+            errors: [],
+            warnings: [],
+            value: value,
+            field: field,
+            dom: null
+          });
+        };
 
-      Instead of writing the above, your code now simply becomes the following:
+        _this.setFieldData = function (value) {
+          var field = _this.props.field;
+          var setFieldValue = _this.context.form.setFieldValue;
+          setFieldValue(field, value);
 
-      ```javascript
-      let promise = Promise.reject(new Error('WHOOPS'));
+          _this.validateField();
+        };
 
-      promise.then(function(value){
-        // Code here doesn't run because the promise is rejected!
-      }, function(reason){
-        // reason.message === 'WHOOPS'
-      });
-      ```
+        _this.innerTriggerFunction = function (_, value) {
+          var _a, _b;
 
-      @method reject
-      @static
-      @param {Any} reason value that the returned promise will be rejected with.
-      Useful for tooling.
-      @return {Promise} a promise rejected with the given `reason`.
-    */
-    function reject$1(reason) {
-      /*jshint validthis:true */
-      var Constructor = this;
-      var promise = new Constructor(noop);
-      reject(promise, reason);
-      return promise;
-    }
+          var args = [];
 
-    function needsResolver() {
-      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
-    }
+          for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+          }
 
-    function needsNew() {
-      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-    }
+          _this.setFieldData(value);
 
-    /**
-      Promise objects represent the eventual result of an asynchronous operation. The
-      primary way of interacting with a promise is through its `then` method, which
-      registers callbacks to receive either a promise's eventual value or the reason
-      why the promise cannot be fulfilled.
+          var _c = _this.props,
+              children = _c.children,
+              _d = _c.trigger,
+              trigger = _d === void 0 ? 'onChange' : _d;
 
-      Terminology
-      -----------
+          if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
+            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([_, value], args));
+          }
+        };
 
-      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-      - `thenable` is an object or function that defines a `then` method.
-      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-      - `exception` is a value that is thrown using the throw statement.
-      - `reason` is a value that indicates why a promise was rejected.
-      - `settled` the final resting state of a promise, fulfilled or rejected.
+        _this.innerTriggerFunctionWithValueFirst = function (value) {
+          var _a, _b;
 
-      A promise can be in one of three states: pending, fulfilled, or rejected.
+          var args = [];
 
-      Promises that are fulfilled have a fulfillment value and are in the fulfilled
-      state.  Promises that are rejected have a rejection reason and are in the
-      rejected state.  A fulfillment value is never a thenable.
+          for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+          }
 
-      Promises can also be said to *resolve* a value.  If this value is also a
-      promise, then the original promise's settled state will match the value's
-      settled state.  So a promise that *resolves* a promise that rejects will
-      itself reject, and a promise that *resolves* a promise that fulfills will
-      itself fulfill.
+          _this.setFieldData(value);
 
+          var _c = _this.props,
+              children = _c.children,
+              _d = _c.trigger,
+              trigger = _d === void 0 ? 'onChange' : _d;
 
-      Basic Usage:
-      ------------
+          if (trigger && ((_a = children.props) === null || _a === void 0 ? void 0 : _a[trigger])) {
+            (_b = children.props) === null || _b === void 0 ? void 0 : _b[trigger].apply(_b, __spreadArrays$1([value], args));
+          }
+        };
 
-      ```js
-      let promise = new Promise(function(resolve, reject) {
-        // on success
-        resolve(value);
+        _this.innerClearFunction = function () {
+          var _a, _b;
 
-        // on failure
-        reject(reason);
-      });
+          var args = [];
 
-      promise.then(function(value) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
 
-      Advanced Usage:
-      ---------------
+          var children = _this.props.children;
 
-      Promises shine when abstracting away asynchronous interactions such as
-      `XMLHttpRequest`s.
+          _this.setFieldData('');
 
-      ```js
-      function getJSON(url) {
-        return new Promise(function(resolve, reject){
-          let xhr = new XMLHttpRequest();
+          if ((_a = children.props) === null || _a === void 0 ? void 0 : _a.onClear) {
+            (_b = children.props) === null || _b === void 0 ? void 0 : _b.onClear.apply(_b, args);
+          }
+        };
 
-          xhr.open('GET', url);
-          xhr.onreadystatechange = handler;
-          xhr.responseType = 'json';
-          xhr.setRequestHeader('Accept', 'application/json');
-          xhr.send();
+        _this.destroyField = function () {};
 
-          function handler() {
-            if (this.readyState === this.DONE) {
-              if (this.status === 200) {
-                resolve(this.response);
-              } else {
-                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-              }
-            }
-          };
-        });
-      }
+        if ((props === null || props === void 0 ? void 0 : props.initialValue) && props.field) {
+          var setInitialValues = context.form.getInternalHooks().setInitialValues;
+          setInitialValues((_a = {}, _a[props.field] = props.initialValue, _a));
+        }
 
-      getJSON('/posts.json').then(function(json) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
+        return _this;
+      }
 
-      Unlike callbacks, promises are great composable primitives.
+      FormItemInner.prototype.componentDidMount = function () {
+        var registerField = this.context.form.getInternalHooks().registerField;
+        this.destroyField = registerField(this.props.field, this);
+      };
 
-      ```js
-      Promise.all([
-        getJSON('/posts'),
-        getJSON('/comments')
-      ]).then(function(values){
-        values[0] // => postsJSON
-        values[1] // => commentsJSON
+      FormItemInner.prototype.componentWillUnmount = function () {
+        this.destroyField();
+      };
 
-        return values;
-      });
-      ```
+      FormItemInner.prototype.renderChildren = function () {
+        var _a;
 
-      @class Promise
-      @param {Function} resolver
-      Useful for tooling.
-      @constructor
-    */
+        var _this = this;
 
-    var Promise$1 = function () {
-      function Promise(resolver) {
-        this[PROMISE_ID] = nextId();
-        this._result = this._state = undefined;
-        this._subscribers = [];
+        var _b, _c, _d;
 
-        if (noop !== resolver) {
-          typeof resolver !== 'function' && needsResolver();
-          this instanceof Promise ? initializePromise(this, resolver) : needsNew();
-        }
-      }
+        var _e = this.props,
+            children = _e.children,
+            field = _e.field,
+            _f = _e.trigger,
+            trigger = _f === void 0 ? 'onChange' : _f,
+            _g = _e.triggerPropsField,
+            triggerPropsField = _g === void 0 ? 'value' : _g,
+            displayType = _e.displayType;
+        var getFieldValue = this.context.form.getFieldValue;
+        var props = (_a = {}, _a[triggerPropsField] = getFieldValue(field), _a.disabled = this.props.disabled, _a);
+        var childrenType = displayType || ((_b = children.type) === null || _b === void 0 ? void 0 : _b.displayName);
 
-      /**
-      The primary way of interacting with a promise is through its `then` method,
-      which registers callbacks to receive either a promise's eventual value or the
-      reason why the promise cannot be fulfilled.
-       ```js
-      findUser().then(function(user){
-        // user is available
-      }, function(reason){
-        // user is unavailable, and you are given the reason why
-      });
-      ```
-       Chaining
-      --------
-       The return value of `then` is itself a promise.  This second, 'downstream'
-      promise is resolved with the return value of the first promise's fulfillment
-      or rejection handler, or rejected if the handler throws an exception.
-       ```js
-      findUser().then(function (user) {
-        return user.name;
-      }, function (reason) {
-        return 'default name';
-      }).then(function (userName) {
-        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-        // will be `'default name'`
-      });
-       findUser().then(function (user) {
-        throw new Error('Found user, but still unhappy');
-      }, function (reason) {
-        throw new Error('`findUser` rejected and we're unhappy');
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
-      });
-      ```
-      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-       ```js
-      findUser().then(function (user) {
-        throw new PedagogicalException('Upstream error');
-      }).then(function (value) {
-        // never reached
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // The `PedgagocialException` is propagated all the way down to here
-      });
-      ```
-       Assimilation
-      ------------
-       Sometimes the value you want to propagate to a downstream promise can only be
-      retrieved asynchronously. This can be achieved by returning a promise in the
-      fulfillment or rejection handler. The downstream promise will then be pending
-      until the returned promise is settled. This is called *assimilation*.
-       ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // The user's comments are now available
-      });
-      ```
-       If the assimliated promise rejects, then the downstream promise will also reject.
-       ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // If `findCommentsByAuthor` fulfills, we'll have the value here
-      }, function (reason) {
-        // If `findCommentsByAuthor` rejects, we'll have the reason here
-      });
-      ```
-       Simple Example
-      --------------
-       Synchronous Example
-       ```javascript
-      let result;
-       try {
-        result = findResult();
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-       Errback Example
-       ```js
-      findResult(function(result, err){
-        if (err) {
-          // failure
-        } else {
-          // success
-        }
-      });
-      ```
-       Promise Example;
-       ```javascript
-      findResult().then(function(result){
-        // success
-      }, function(reason){
-        // failure
-      });
-      ```
-       Advanced Example
-      --------------
-       Synchronous Example
-       ```javascript
-      let author, books;
-       try {
-        author = findAuthor();
-        books  = findBooksByAuthor(author);
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-       Errback Example
-       ```js
-       function foundBooks(books) {
-       }
-       function failure(reason) {
-       }
-       findAuthor(function(author, err){
-        if (err) {
-          failure(err);
-          // failure
-        } else {
-          try {
-            findBoooksByAuthor(author, function(books, err) {
-              if (err) {
-                failure(err);
-              } else {
-                try {
-                  foundBooks(books);
-                } catch(reason) {
-                  failure(reason);
-                }
+        switch (childrenType) {
+          case FormInternalComponentType.Input:
+          case FormInternalComponentType.Textarea:
+            props = {
+              value: getFieldValue(field) || '',
+              onInput: this.innerTriggerFunction,
+              onClear: this.innerClearFunction,
+              disabled: this.props.disabled
+            };
+            break;
+
+          case FormInternalComponentType.Checkbox:
+          case FormInternalComponentType.Radio:
+          case FormInternalComponentType.Slider:
+          case FormInternalComponentType.RadioGroup:
+          case FormInternalComponentType.CheckboxGroup:
+            props = {
+              value: getFieldValue(field),
+              onChange: this.innerTriggerFunctionWithValueFirst,
+              disabled: this.props.disabled
+            };
+            break;
+
+          case FormInternalComponentType.DatePicker:
+            props = {
+              currentTs: getFieldValue(field),
+              onChange: this.innerTriggerFunctionWithValueFirst,
+              disabled: this.props.disabled,
+              renderLinkedContainer: ((_c = children.props) === null || _c === void 0 ? void 0 : _c.renderLinkedContainer) || function (ts, types) {
+                return /*#__PURE__*/React__default["default"].createElement(DefaultDatePickerLinkedContainer, {
+                  ts: ts,
+                  types: types
+                });
               }
-            });
-          } catch(error) {
-            failure(err);
-          }
-          // success
+            };
+            break;
+
+          case FormInternalComponentType.Picker:
+            props = {
+              value: getFieldValue(field),
+              onChange: this.innerTriggerFunctionWithValueFirst,
+              disabled: this.props.disabled,
+              renderLinkedContainer: ((_d = children.props) === null || _d === void 0 ? void 0 : _d.renderLinkedContainer) || function (val) {
+                return /*#__PURE__*/React__default["default"].createElement(DefaultPickerLinkedContainer, {
+                  value: val
+                });
+              }
+            };
+            break;
+
+          case FormInternalComponentType.Switch:
+            props = {
+              checked: Boolean(getFieldValue(field)),
+              onChange: this.innerTriggerFunctionWithValueFirst,
+              disabled: this.props.disabled
+            };
+            break;
+
+          case FormInternalComponentType.ImagePicker:
+            props = {
+              images: getFieldValue(field),
+              onChange: this.innerTriggerFunctionWithValueFirst,
+              disabled: this.props.disabled
+            };
+            break;
+
+          default:
+            var originTrigger_1 = children.props[trigger]; // inject the validated result
+
+            props.error = this._errors;
+
+            props[trigger] = function (newValue) {
+              var args = [];
+
+              for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+              }
+
+              _this.setFieldData(newValue);
+
+              originTrigger_1 && originTrigger_1.apply(void 0, __spreadArrays$1([newValue], args));
+            };
+
         }
-      });
-      ```
-       Promise Example;
-       ```javascript
-      findAuthor().
-        then(findBooksByAuthor).
-        then(function(books){
-          // found books
-      }).catch(function(reason){
-        // something went wrong
-      });
-      ```
-       @method then
-      @param {Function} onFulfilled
-      @param {Function} onRejected
-      Useful for tooling.
-      @return {Promise}
-      */
 
-      /**
-      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-      as the catch block of a try/catch statement.
-      ```js
-      function findAuthor(){
-      throw new Error('couldn't find that author');
-      }
-      // synchronous
-      try {
-      findAuthor();
-      } catch(reason) {
-      // something went wrong
-      }
-      // async with promises
-      findAuthor().catch(function(reason){
-      // something went wrong
-      });
-      ```
-      @method catch
-      @param {Function} onRejection
-      Useful for tooling.
-      @return {Promise}
-      */
+        return /*#__PURE__*/React__default["default"].cloneElement(children, props);
+      };
+
+      FormItemInner.prototype.render = function () {
+        return this.renderChildren();
+      };
 
+      return FormItemInner;
+    }(React.PureComponent);
 
-      Promise.prototype.catch = function _catch(onRejection) {
-        return this.then(null, onRejection);
+    FormItemInner.contextType = FormItemContext;
+    var Item$1 = /*#__PURE__*/React.forwardRef(function (props, ref) {
+      var _a;
+
+      var label = props.label,
+          field = props.field,
+          _b = props.disabled,
+          disabled = _b === void 0 ? false : _b,
+          itemLayout = props.layout,
+          style = props.style,
+          extra = props.extra,
+          requiredIcon = props.requiredIcon,
+          rules = props.rules,
+          _c = props.className,
+          className = _c === void 0 ? '' : _c,
+          rest = __rest$1(props, ["label", "field", "disabled", "layout", "style", "extra", "requiredIcon", "rules", "className"]);
+
+      var prefixCls = React.useContext(GlobalContext).prefixCls;
+
+      var _d = React.useContext(FormItemContext),
+          layout = _d.layout,
+          propsDisabled = _d.disabled;
+
+      var _e = React.useState(null),
+          errors = _e[0],
+          setErrors = _e[1];
+
+      var _f = React.useState(null),
+          errorTypes = _f[0],
+          setErrorTypes = _f[1];
+
+      var _g = React.useState([]),
+          warnings = _g[0],
+          setWarnings = _g[1];
+
+      var formItemRef = React.useRef(null);
+
+      var onValidateStatusChange = function onValidateStatusChange(validateResult) {
+        var _errors = validateResult.errors,
+            _warnings = validateResult.warnings,
+            _errorTypes = validateResult.errorTypes;
+        setErrors(_errors.length ? _errors[0] : null);
+        setErrorTypes(_errorTypes.length ? _errorTypes[0] : null);
+        setWarnings(_warnings);
       };
 
-      /**
-        `finally` will be invoked regardless of the promise's fate just as native
-        try/catch/finally behaves
-      
-        Synchronous example:
-      
-        ```js
-        findAuthor() {
-          if (Math.random() > 0.5) {
-            throw new Error();
-          }
-          return new Author();
-        }
-      
-        try {
-          return findAuthor(); // succeed or fail
-        } catch(error) {
-          return findOtherAuther();
-        } finally {
-          // always runs
-          // doesn't affect the return value
-        }
-        ```
-      
-        Asynchronous example:
-      
-        ```js
-        findAuthor().catch(function(reason){
-          return findOtherAuther();
-        }).finally(function(){
-          // author was either found, or not
-        });
-        ```
-      
-        @method finally
-        @param {Function} callback
-        @return {Promise}
-      */
+      var getFormItemRef = function getFormItemRef() {
+        return formItemRef.current;
+      };
+
+      var fieldDisabled = disabled || propsDisabled;
+      var fieldRules = (rest === null || rest === void 0 ? void 0 : rest.required) ? __spreadArrays$1([{
+        type: ValidatorType.String,
+        required: true
+      }], rules || []) : rules;
+      var isRequired = isFieldRequired(rules) || (rest === null || rest === void 0 ? void 0 : rest.required);
+      React.useImperativeHandle(ref, function () {
+        return {
+          dom: formItemRef.current
+        };
+      });
+      return /*#__PURE__*/React__default["default"].createElement("div", {
+        className: cls(prefixCls + "-form-item", prefixCls + "-form-item-" + (itemLayout || layout), className, (_a = {
+          disabled: fieldDisabled
+        }, _a[prefixCls + "-form-item-error"] = !!errors, _a[prefixCls + "-form-item-warning"] = Boolean(!errors && warnings), _a[prefixCls + "-form-item-error-" + errorTypes] = errorTypes, _a)),
+        style: style,
+        ref: formItemRef
+      }, /*#__PURE__*/React__default["default"].createElement("div", {
+        className: cls(prefixCls + "-form-label-item")
+      }, isRequired ? requiredIcon || /*#__PURE__*/React__default["default"].createElement("span", {
+        className: cls(prefixCls + "-form-label-item-required-asterisk")
+      }, "*") : null, label), /*#__PURE__*/React__default["default"].createElement("div", {
+        className: cls(prefixCls + "-form-item-control-wrapper")
+      }, /*#__PURE__*/React__default["default"].createElement("div", {
+        className: cls(prefixCls + "-form-item-control")
+      }, /*#__PURE__*/React__default["default"].createElement(FormItemInner, __assign$3({}, rest, {
+        rules: fieldRules,
+        disabled: fieldDisabled,
+        field: field,
+        onValidateStatusChange: onValidateStatusChange,
+        getFormItemRef: getFormItemRef
+      }))), errors && /*#__PURE__*/React__default["default"].createElement("div", {
+        className: cls(prefixCls + "-form-item-message " + prefixCls + "-form-item-error-message")
+      }, errors), (warnings || []).map(function (node, key) {
+        return typeof node === 'string' ? /*#__PURE__*/React__default["default"].createElement("div", {
+          className: cls(prefixCls + "-form-item-message " + prefixCls + "-form-item-warning-message"),
+          key: key
+        }, node) : node;
+      })), extra);
+    });
 
+    var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
+      var _a = props.className,
+          className = _a === void 0 ? '' : _a,
+          style = props.style,
+          _b = props.layout,
+          layout = _b === void 0 ? 'horizontal' : _b,
+          initialValues = props.initialValues,
+          formInstance = props.form,
+          children = props.children,
+          onValuesChange = props.onValuesChange,
+          onSubmit = props.onSubmit,
+          onSubmitFailed = props.onSubmitFailed,
+          disabled = props.disabled;
+      var domRef = React.useRef(null);
+      var initRef = React.useRef(false);
+      var form = useForm(formInstance)[0];
 
-      Promise.prototype.finally = function _finally(callback) {
-        var promise = this;
-        var constructor = promise.constructor;
+      var _c = form.getInternalHooks(),
+          setCallbacks = _c.setCallbacks,
+          setInitialValues = _c.setInitialValues;
 
-        if (isFunction(callback)) {
-          return promise.then(function (value) {
-            return constructor.resolve(callback()).then(function () {
-              return value;
-            });
-          }, function (reason) {
-            return constructor.resolve(callback()).then(function () {
-              throw reason;
-            });
-          });
-        }
+      setCallbacks({
+        onValuesChange: onValuesChange,
+        onSubmit: onSubmit,
+        onSubmitFailed: onSubmitFailed
+      });
 
-        return promise.then(callback, callback);
+      if (!initRef.current) {
+        setInitialValues(initialValues || {});
+        initRef.current = true;
+      }
+
+      React.useImperativeHandle(ref, function () {
+        return {
+          dom: domRef.current,
+          form: form
+        };
+      });
+      var contextValue = {
+        form: form,
+        layout: layout,
+        disabled: disabled
       };
+      return /*#__PURE__*/React__default["default"].createElement(ContextLayout, null, function (_a) {
+        var prefixCls = _a.prefixCls,
+            _b = _a.locale,
+            locale = _b === void 0 ? defaultLocale : _b;
+        return /*#__PURE__*/React__default["default"].createElement("form", {
+          className: prefixCls + "-form " + className,
+          style: style,
+          ref: domRef,
+          onSubmit: function onSubmit(e) {
+            e.preventDefault();
+            e.stopPropagation();
+            form.submit();
+          }
+        }, /*#__PURE__*/React__default["default"].createElement(FormItemContext.Provider, {
+          value: __assign$3(__assign$3({}, contextValue), {
+            validateMessages: (locale === null || locale === void 0 ? void 0 : locale.Form) || {}
+          })
+        }, children));
+      });
+    });
+    /**
+     * 表单组件用于集合数据录入
+     * @en Form, Form for collecting data input
+     * @type 数据录入
+     * @type_en Data Entry
+     * @name 表单
+     * @name_en Form
+     */
 
-      return Promise;
-    }();
+    var index$i = componentWrapper(Form, {
+      Item: Item$1
+    });
 
-    Promise$1.prototype.then = then;
-    Promise$1.all = all;
-    Promise$1.race = race;
-    Promise$1.resolve = resolve$1;
-    Promise$1.reject = reject$1;
-    Promise$1._setScheduler = setScheduler;
-    Promise$1._setAsap = setAsap;
-    Promise$1._asap = asap;
+    /**
+     * 宫格可以在水平方向上把页面分隔成等宽度的区块，用于展示内容或进行页面导航。
+     * @en The grid can divide the page into equal-width blocks in the horizontal direction for displaying content or for page navigation.
+     * @type 布局
+     * @type_en Layout
+     * @name 宫格
+     * @name_en Grid
+     */
 
-    /*global self*/
-    function polyfill() {
-      var local = void 0;
+    var Grid = /*#__PURE__*/React.forwardRef(function (props, ref) {
+      var _a = props.className,
+          className = _a === void 0 ? '' : _a,
+          style = props.style,
+          data = props.data,
+          _b = props.columns,
+          columns = _b === void 0 ? 3 : _b,
+          _c = props.border,
+          border = _c === void 0 ? false : _c,
+          _d = props.gutter,
+          gutter = _d === void 0 ? 0 : _d,
+          _e = props.shape,
+          shape = _e === void 0 ? 'square' : _e,
+          _f = props.direction,
+          direction = _f === void 0 ? 'vertical' : _f,
+          _g = props.isSliding,
+          isSliding = _g === void 0 ? false : _g;
+      var useRtl = React.useContext(GlobalContext).useRtl;
+      var domRef = React.useRef(null);
+      React.useImperativeHandle(ref, function () {
+        return {
+          dom: domRef.current
+        };
+      });
 
-      if (typeof commonjsGlobal !== 'undefined') {
-        local = commonjsGlobal;
-      } else if (typeof self !== 'undefined') {
-        local = self;
-      } else {
-        try {
-          local = Function('return this')();
-        } catch (e) {
-          throw new Error('polyfill failed because global object is unavailable in this environment');
+      var getRows = function getRows(prefix, rowsData, rows, row) {
+        var placeholders = !isSliding && rowsData.length % columns;
+        var renderData = rowsData;
+
+        if (placeholders) {
+          var fakeGrids = new Array(columns - placeholders).fill({
+            img: null,
+            title: ''
+          });
+          renderData = rowsData.concat(fakeGrids);
         }
-      }
 
-      var P = local.Promise;
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: prefix + "-rows",
+          key: row
+        }, renderData.map(function (item, index) {
+          var _a;
 
-      if (P) {
-        var promiseToString = null;
-        try {
-          promiseToString = Object.prototype.toString.call(P.resolve());
-        } catch (e) {
-          // silently ignored
-        }
+          var img = item.img,
+              title = item.title,
+              content = item.content,
+              itemClassName = item.className,
+              _onClick = item.onClick,
+              itemStyle = item.itemStyle,
+              renderGrid = item.renderGrid;
 
-        if (promiseToString === '[object Promise]' && !P.cast) {
-          return;
-        }
-      }
+          if (renderGrid) {
+            return renderGrid(item, index, row);
+          }
 
-      local.Promise = Promise$1;
-    }
+          var marginBottom = row + 1 === rows ? 0 : typeof gutter === 'number' ? gutter : (gutter === null || gutter === void 0 ? void 0 : gutter.y) || 0;
+          var rowLen = renderData.length;
+          var marginValue = index + 1 === rowLen ? 0 : typeof gutter === 'number' ? gutter : (gutter === null || gutter === void 0 ? void 0 : gutter.x) || 0;
+          var marginStyle = (_a = {}, _a[useRtl ? 'marginLeft' : 'marginRight'] = marginValue, _a);
+          return /*#__PURE__*/React__default["default"].createElement("div", {
+            key: index,
+            style: __assign$3(__assign$3({
+              marginBottom: marginBottom
+            }, marginStyle), itemStyle),
+            onClick: function onClick() {
+              _onClick && _onClick(item);
+            },
+            className: cls(prefix + "-rows-item", {
+              horizontal: direction === 'horizontal',
+              border: border && gutter === 0
+            }, itemClassName)
+          }, typeof img === 'string' ? /*#__PURE__*/React__default["default"].createElement("img", {
+            src: img,
+            className: prefix + "-rows-item-icon " + (shape === 'circle' ? 'circle' : '')
+          }) : img, title || content ? /*#__PURE__*/React__default["default"].createElement("div", {
+            className: prefix + "-rows-item-text"
+          }, title ? /*#__PURE__*/React__default["default"].createElement("span", {
+            className: prefix + "-rows-item-title"
+          }, title) : null, content ? /*#__PURE__*/React__default["default"].createElement("span", {
+            className: prefix + "-rows-item-content"
+          }, content) : null) : null, (index + 1) % columns !== 0 ? /*#__PURE__*/React__default["default"].createElement("i", {
+            className: "vertical-border"
+          }) : null, (row + 1) % rows !== 0 ? /*#__PURE__*/React__default["default"].createElement("i", {
+            className: "horizontal-border"
+          }) : null);
+        }));
+      };
 
-    // Strange compat..
-    Promise$1.polyfill = polyfill;
-    Promise$1.Promise = Promise$1;
+      var getGrid = function getGrid(prefix, dataArr) {
+        var rows = dataArr.length || 1;
+        return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, dataArr.map(function (item, index) {
+          return getRows(prefix, item, rows, index);
+        }));
+      };
 
-    return Promise$1;
+      var renderEl = function renderEl(_a) {
+        var prefixCls = _a.prefixCls;
+        var prefix = prefixCls + "-grid";
+        var dataLength = (data === null || data === void 0 ? void 0 : data.length) || 0;
 
-    })));
+        if (dataLength === 0) {
+          return null;
+        }
 
+        var index = 0;
+        var newArr = [];
 
+        while (index < dataLength) {
+          newArr.push(data.slice(index, isSliding ? index += dataLength : index += columns));
+        }
 
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: cls(prefix, className, isSliding ? 'sliding' : ''),
+          style: style,
+          ref: domRef
+        }, getGrid(prefix, newArr));
+      };
 
+      return /*#__PURE__*/React__default["default"].createElement(ContextLayout, null, renderEl);
     });
 
+    function AddIcon() {
+      return /*#__PURE__*/React__default["default"].createElement("svg", {
+        width: "30",
+        height: "30",
+        viewBox: "0 0 30 30",
+        fill: "none"
+      }, /*#__PURE__*/React__default["default"].createElement("path", {
+        fillRule: "evenodd",
+        clipRule: "evenodd",
+        d: "M14.5 0C14.2239 0 14 0.223857 14 0.5V14H0.5C0.223858 14 0 14.2239 0 14.5V15.5C0 15.7761 0.223857 16 0.5 16H14V29.5C14 29.7761 14.2239 30 14.5 30H15.5C15.7761 30 16 29.7761 16 29.5V16H29.5C29.7761 16 30 15.7761 30 15.5V14.5C30 14.2239 29.7761 14 29.5 14H16V0.5C16 0.223858 15.7761 0 15.5 0H14.5Z",
+        fill: "#C9CDD4"
+      }));
+    }
+
     var Upload =
     /** @class */
     function () {