@douyinfe/semi-ui 2.27.0 → 2.27.1

package/dist/umd/semi-ui.js

@@ -60844,15 +60844,18 @@ class dropdownItem_DropdownItem extends baseComponent_BaseComponent {
       type,
       active,
       icon,
-      onKeyDown
+      onKeyDown,
+      showTick,
+      hover
     } = this.props;
     const {
-      showTick
+      showTick: contextShowTick
     } = this.context;
     const itemclass = classnames_default()(className, {
       ["".concat(dropdownItem_prefixCls, "-item")]: true,
       ["".concat(dropdownItem_prefixCls, "-item-disabled")]: disabled,
-      ["".concat(dropdownItem_prefixCls, "-item-withTick")]: showTick,
+      ["".concat(dropdownItem_prefixCls, "-item-hover")]: hover,
+      ["".concat(dropdownItem_prefixCls, "-item-withTick")]: contextShowTick !== null && contextShowTick !== void 0 ? contextShowTick : showTick,
       ["".concat(dropdownItem_prefixCls, "-item-").concat(type)]: type,
       ["".concat(dropdownItem_prefixCls, "-item-active")]: active
     });
@@ -60931,6 +60934,7 @@ dropdownItem_DropdownItem.defaultProps = {
   onMouseLeave: noop_default.a,
   forwardRef: noop_default.a
 };
+dropdownItem_DropdownItem.elementType = 'Dropdown.Item';
 /* harmony default export */ var dropdown_dropdownItem = (dropdownItem_DropdownItem);
 // CONCATENATED MODULE: ./dropdown/dropdownDivider.tsx
 
@@ -100051,7 +100055,8 @@ function withField(Component, opts) {
     const [status, setStatus] = Object(external_root_React_commonjs2_react_commonjs_react_amd_react_["useState"])(validateStatus); // use props.validateStatus to init
 
     const rulesRef = Object(external_root_React_commonjs2_react_commonjs_react_amd_react_["useRef"])(rules);
-    const validateRef = Object(external_root_React_commonjs2_react_commonjs_react_amd_react_["useRef"])(validate); // notNotify is true means that the onChange of the Form does not need to be triggered
+    const validateRef = Object(external_root_React_commonjs2_react_commonjs_react_amd_react_["useRef"])(validate);
+    const validatePromise = Object(external_root_React_commonjs2_react_commonjs_react_amd_react_["useRef"])(null); // notNotify is true means that the onChange of the Form does not need to be triggered
     // notUpdate is true means that this operation does not need to trigger the forceUpdate
 
     const updateTouched = (isTouched, callOpts) => {
@@ -100105,16 +100110,24 @@ function withField(Component, opts) {
       const model = {
         [field]: val
       };
-      return new Promise((resolve, reject) => {
+      const rootPromise = new Promise((resolve, reject) => {
         validator.validate(model, {
           first: stopValidateWithError
         }, // eslint-disable-next-line @typescript-eslint/no-empty-function
         (errors, fields) => {}).then(res => {
-          // validation passed
+          if (validatePromise.current !== rootPromise) {
+            return;
+          } // validation passed
+
+
           setStatus('success');
           updateError(undefined, callOpts);
           resolve({});
         }).catch(err => {
+          if (validatePromise.current !== rootPromise) {
+            return;
+          }
+
           let {
             errors,
             fields
@@ -100143,44 +100156,55 @@ function withField(Component, opts) {
           }
         });
       });
+      validatePromise.current = rootPromise;
+      return rootPromise;
     }; // execute custom validate function
 
 
-    const _validate = (val, values, callOpts) => new Promise(resolve => {
-      let maybePromisedErrors; // let errorThrowSync;
+    const _validate = (val, values, callOpts) => {
+      const rootPromise = new Promise(resolve => {
+        let maybePromisedErrors; // let errorThrowSync;
 
-      try {
-        maybePromisedErrors = validateRef.current(val, values);
-      } catch (err) {
-        // error throw by syncValidate
-        maybePromisedErrors = err;
-      }
+        try {
+          maybePromisedErrors = validateRef.current(val, values);
+        } catch (err) {
+          // error throw by syncValidate
+          maybePromisedErrors = err;
+        }
 
-      if (maybePromisedErrors === undefined) {
-        resolve({});
-        updateError(undefined, callOpts);
-      } else if (isPromise(maybePromisedErrors)) {
-        maybePromisedErrors.then(result => {
-          if (utils_isValid(result)) {
-            // validate success，no need to do anything with result
+        if (maybePromisedErrors === undefined) {
+          resolve({});
+          updateError(undefined, callOpts);
+        } else if (isPromise(maybePromisedErrors)) {
+          maybePromisedErrors.then(result => {
+            // If the async validate is outdated (a newer validate occurs), the result should be discarded
+            if (validatePromise.current !== rootPromise) {
+              return;
+            }
+
+            if (utils_isValid(result)) {
+              // validate success，no need to do anything with result
+              updateError(undefined, callOpts);
+              resolve(null);
+            } else {
+              // validate failed
+              updateError(result, callOpts);
+              resolve(result);
+            }
+          });
+        } else {
+          if (utils_isValid(maybePromisedErrors)) {
             updateError(undefined, callOpts);
             resolve(null);
           } else {
-            // validate failed
-            updateError(result, callOpts);
-            resolve(result);
+            updateError(maybePromisedErrors, callOpts);
+            resolve(maybePromisedErrors);
           }
-        });
-      } else {
-        if (utils_isValid(maybePromisedErrors)) {
-          updateError(undefined, callOpts);
-          resolve(null);
-        } else {
-          updateError(maybePromisedErrors, callOpts);
-          resolve(maybePromisedErrors);
         }
-      }
-    });
+      });
+      validatePromise.current = rootPromise;
+      return rootPromise;
+    };
 
     const fieldValidate = (val, callOpts) => {
       let finalVal = val;