@douyinfe/semi-foundation 2.93.0 → 2.94.1

package/aiChatInput/foundation.ts

@@ -375,7 +375,9 @@ export default class AIChatInputFoundation extends BaseFoundation<AIChatInputAda
     }
 
     handRichTextArealKeyDown = (view: any, event: KeyboardEvent) => {
-        // console.log('outer key down handle');
+        if (view.composing) {
+            return false;
+        }
         const { sendHotKey } = this.getProps();
         const { suggestionVisible, skillVisible } = this.getStates();
         /**

package/autoComplete/foundation.ts

@@ -18,7 +18,8 @@ export interface DataItem {
 
 export interface StateOptionItem extends DataItem {
     show?: boolean;
-    key?: string | number
+    key?: string | number;
+    _renderedLabel?: any; // Internal property to store the rendered label from renderItem
 }
 
 export type AutoCompleteData = Array<DataItem | string>;
@@ -144,7 +145,7 @@ class AutoCompleteFoundation<P = Record<string, any>, S = Record<string, any>> e
                     option = { show: true, ...item };
                 }
                 if (renderItem && typeof renderItem === 'function') {
-                    option.label = renderItem(item);
+                    option._renderedLabel = renderItem(item);
                 }
                 options.push(option);
             });

package/cascader/foundation.ts

@@ -166,6 +166,7 @@ export interface BasicCascaderProps {
     disableStrictly?: boolean;
     leafOnly?: boolean;
     enableLeafClick?: boolean;
+    clickToSelect?: boolean;
     preventScroll?: boolean;
     virtualizeInSearch?: Virtualize;
     checkRelation?: string;
@@ -734,7 +735,7 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
     }
 
     handleSingleSelect(e: any, item: BasicEntity | BasicData) {
-        const { changeOnSelect: allowChange, filterLeafOnly, multiple, enableLeafClick } = this.getProps();
+        const { changeOnSelect: allowChange, filterLeafOnly, multiple, enableLeafClick, clickToSelect } = this.getProps();
         const { keyEntities, selectedKeys, isSearching } = this.getStates();
         const filterable = this._isFilterable();
         const { data, key } = item;
@@ -745,14 +746,18 @@ export default class CascaderFoundation extends BaseFoundation<CascaderAdapter,
         const selectedKey = [key];
         const hasChanged = key !== [...selectedKeys][0];
 
-        if (!isLeaf && !allowChange && !isSearching) {
+        // When clickToSelect is enabled in multiple mode, allow clicking non-leaf nodes to select
+        // In single mode, changeOnSelect (allowChange) controls this behavior
+        if (!isLeaf && !allowChange && !isSearching && !(multiple && clickToSelect)) {
             this._adapter.updateStates({ activeKeys: new Set(activeKeys) });
             this.notifyIfLoadData(item);
             return;
         }
         if (multiple) {
             this._adapter.updateStates({ activeKeys: new Set(activeKeys) });
-            if (isLeaf && enableLeafClick) {
+            // clickToSelect: click any node to select (takes precedence over enableLeafClick)
+            // enableLeafClick: click leaf node to select
+            if (clickToSelect || (isLeaf && enableLeafClick)) {
                 this.onItemCheckboxClick(item);
             }
         } else {

package/collapsible/foundation.ts

@@ -6,6 +6,7 @@ export interface CollapsibleFoundationProps {
     keepDOM?: boolean;
     className?: string;
     collapseHeight?: number;
+    collapseHeightAdaptive?: boolean;
     reCalcKey?: number | string;
     id?: string;
     fade?: boolean

package/datePicker/datePicker.scss

@@ -937,11 +937,11 @@ $module-list: #{$prefix}-scrolllist;
                     height: fit-content;
                     border: none;
 
-                    &:active  {
+                    &:active:not(#neverExistElement) {
                         background-color: transparent;
                     }
 
-                    &:hover {
+                    &:hover:not(#neverExistElement) {
                         background-color: transparent;
                     }
                 }

package/descriptions/foundation.ts

@@ -12,9 +12,11 @@ export default class DescriptionsFoundation<P = Record<string, any>, S = Record<
     getHorizontalList() {
         const { column, data, children } = this.getProps();
         const columns = this._adapter.getColumns();
+        // Filter out hidden items before grouping
+        const visibleColumns = columns.filter(item => !item.hidden);
         const horizontalList = [];
         const curSpan = { totalSpan: 0, itemList: [] };
-        for (const item of columns) {
+        for (const item of visibleColumns) {
             curSpan.totalSpan += item.span || 1;
             curSpan.itemList.push(item);
             if (curSpan.totalSpan >= column) {

package/form/foundation.ts

@@ -5,7 +5,7 @@ import { isValid } from './utils';
 import { isUndefined, isFunction, toPath } from 'lodash';
 import scrollIntoView, { Options as ScrollIntoViewOptions } from 'scroll-into-view-if-needed';
 
-import { BaseFormAdapter, FormState, CallOpts, FieldState, FieldStaff, ComponentProps, setValuesConfig, ArrayFieldStaff } from './interface';
+import { BaseFormAdapter, FormState, CallOpts, FieldState, FieldStaff, ComponentProps, setValuesConfig, ArrayFieldStaff, ValidateOptions } from './interface';
 
 export type { BaseFormAdapter };
 
@@ -157,17 +157,32 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
         this.registeredArrayField.set(arrayField, mergeVal);
     }
 
-    validate(fieldPaths?: Array<string>): Promise<unknown> {
+    validate(fieldPaths?: Array<string> | ValidateOptions): Promise<unknown> {
         const { validateFields } = this.getProps();
+        
+        // Parse options
+        let fields: Array<string> | undefined;
+        let silent = false;
+        
+        if (fieldPaths && !Array.isArray(fieldPaths)) {
+            // It's a ValidateOptions object
+            const options = fieldPaths as ValidateOptions;
+            fields = options.fields as Array<string> | undefined;
+            silent = options.silent || false;
+        } else {
+            // It's an array of fields (or undefined)
+            fields = fieldPaths as Array<string> | undefined;
+        }
+        
         if (validateFields && isFunction(validateFields)) {
-            return this._formValidate();
+            return this._formValidate(silent);
         } else {
-            return this._fieldsValidate(fieldPaths);
+            return this._fieldsValidate(fields, silent);
         }
     }
 
     // form level validate
-    _formValidate(): Promise<unknown> {
+    _formValidate(silent: boolean = false): Promise<unknown> {
         const { values } = this.data;
         const { validateFields } = this.getProps();
 
@@ -182,7 +197,9 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
             if (!maybePromisedErrors) {
                 const _values = this._adapter.cloneDeep(values);
                 resolve(_values);
-                this.injectErrorToField({});
+                if (!silent) {
+                    this.injectErrorToField({});
+                }
             } else if (isPromise(maybePromisedErrors)) {
                 maybePromisedErrors.then(
                     (result: any) => {
@@ -190,39 +207,45 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
                         if (!result) {
                             const _values = this._adapter.cloneDeep(values);
                             resolve(_values);
-                            this.injectErrorToField({});
+                            if (!silent) {
+                                this.injectErrorToField({});
+                            }
                         } else {
-                            this.data.errors = result;
-                            this._adapter.notifyChange(this.data);
-
-                            this.injectErrorToField(result);
-                            this._adapter.forceUpdate();
-                            this._autoScroll(100);
+                            if (!silent) {
+                                this.data.errors = result;
+                                this._adapter.notifyChange(this.data);
+                                this.injectErrorToField(result);
+                                this._adapter.forceUpdate();
+                                this._autoScroll(100);
+                            }
                             reject(result);
                         }
                     },
                     (errors: any) => {
                         // validate failed
-                        // this._adapter.notifyChange(this.data);
-                        this._autoScroll(100);
+                        if (!silent) {
+                            // this._adapter.notifyChange(this.data);
+                            this._autoScroll(100);
+                        }
                         reject(errors);
                     }
                 );
             } else {
                 // TODO: current design, returning an empty object will be considered a checksum failure and will be rejected. Only returning an empty string will be considered a success, consider resetting it in 1.0?
-                this.data.errors = maybePromisedErrors;
-                this.injectErrorToField(maybePromisedErrors);
-                this._adapter.notifyChange(this.data);
-
-                this._adapter.forceUpdate();
-                this._autoScroll(100);
+                if (!silent) {
+                    this.data.errors = maybePromisedErrors;
+                    this.injectErrorToField(maybePromisedErrors);
+                    this._adapter.notifyChange(this.data);
+                    this._adapter.forceUpdate();
+                    this._autoScroll(100);
+                }
                 reject(maybePromisedErrors);
             }
         });
     }
 
     // field level validate
-    _fieldsValidate(fieldPaths: Array<string>): Promise<unknown> {
+    _fieldsValidate(fieldPaths: Array<string>, silent: boolean = false): Promise<unknown> {
         const { values } = this.data;
         // When there is no custom validation function at Form level, perform validation of each Field
         return new Promise((resolve, reject) => {
@@ -232,25 +255,34 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
                 // Call each fieldApi for verification
                 const fieldValue = this.getValue(fieldPath);
                 // When centralized verification, no need to trigger forceUpdate and notify
-                const opts = {
+                // Each field skips individual updates; a single forceUpdate fires after all resolve.
+                const opts: CallOpts = {
                     notNotify: true,
                     notUpdate: true,
+                    silent,
                 };
                 const validateResult = field.fieldApi.validate(fieldValue, opts);
                 promiseSet.push(validateResult);
-                field.fieldApi.setTouched(true, opts);
+                // Only set touched when not in silent mode
+                if (!silent) {
+                    field.fieldApi.setTouched(true, { notNotify: true, notUpdate: true });
+                }
             });
             Promise.all(promiseSet).then(() => {
                 // After the centralized verification is completed, trigger notify and forceUpdate once.
-                this._adapter.notifyChange(this.data);
-
-                this._adapter.forceUpdate();
+                // But skip UI updates in silent mode
+                if (!silent) {
+                    this._adapter.notifyChange(this.data);
+                    this._adapter.forceUpdate();
+                }
                 const errors = this.getError();
                 if (this._isValid(targetFields)) {
                     const _values = this._adapter.cloneDeep(values);
                     resolve(_values);
                 } else {
-                    this._autoScroll();
+                    if (!silent) {
+                        this._autoScroll();
+                    }
                     reject(errors);
                 }
             });
@@ -620,7 +652,7 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
         return {
             ...fieldSetterApi,
             reset: (fields?: Array<string>) => this.reset(fields),
-            validate: (fields?: Array<string>) => this.validate(fields),
+            validate: (fields?: Array<string> | ValidateOptions) => this.validate(fields),
             getValue: (field?: string) => this.getValue(field, { needClone: true }),
             getValues: () => this.getValue(undefined, { needClone: true }),
             getFormState: () => this.getFormState(true),

package/form/interface.ts

@@ -70,6 +70,13 @@ export type ScrollToErrorOptions<K> = {
     scrollOpts?: ScrollIntoViewOptions
 }
 
+export interface ValidateOptions<K extends keyof any = keyof any> {
+    /** Fields to validate, if not specified, validate all fields */
+    fields?: Array<K>;
+    /** Whether to validate silently (without updating UI or setting touched state) */
+    silent?: boolean;
+}
+
 // use object replace Record<string, any>, fix issue 933
 export interface BaseFormApi<T extends object = any> {
     /** get value of field */
@@ -94,8 +101,8 @@ export interface BaseFormApi<T extends object = any> {
     submitForm: () => void;
     /** reset form manual */
     reset: (fields?: Array<string>) => void;
-    /** trigger validate  manual */
-    validate: <K extends keyof T, Params extends Array<K>, V extends Params[number]>(fields?: Params) => Promise<{ [R in V]: T[R] }>;
+    /** trigger validate manual */
+    validate: <K extends keyof T, Params extends Array<K>, V extends Params[number]>(fields?: Params | ValidateOptions<K>) => Promise<{ [R in V]: T[R] }>;
     getInitValue: <K extends keyof T>(field: K) => any;
     getInitValues: () => any;
     getValues: () => T;

package/input/textareaFoundation.ts

@@ -28,7 +28,9 @@ export interface TextAreaAdapter extends Partial<DefaultAdapter>, Partial<TextAr
     setMinLength(length: number): void;
     notifyPressEnter(e: any): void;
     getRef(): HTMLInputElement;
-    notifyHeightUpdate(e: any): void
+    notifyHeightUpdate(e: any): void;
+    focusInput(): void;
+    isEventTarget(e: any): boolean
 }
 
 export default class TextAreaFoundation extends BaseFoundation<TextAreaAdapter> {
@@ -281,4 +283,35 @@ export default class TextAreaFoundation extends BaseFoundation<TextAreaAdapter>
         this._adapter.notifyClear(e);
         this.stopPropagation(e);
     }
+
+    /**
+     * trigger when click textarea wrapper
+     * @param {Event} e
+     */
+    handleClick(e: any) {
+        const { disabled, readonly } = this._adapter.getProps();
+        const { isFocus } = this._adapter.getStates();
+        if (disabled || readonly || isFocus) {
+            return;
+        }
+        // do not handle bubbling up events
+        if (this._adapter.isEventTarget(e)) {
+            this._adapter.focusInput();
+            this._adapter.toggleFocusing(true);
+        }
+    }
+
+    /**
+     * trigger when click textarea counter
+     * @param {Event} e
+     */
+    handleCounterClick(e: any) {
+        const { disabled, readonly } = this._adapter.getProps();
+        const { isFocus } = this._adapter.getStates();
+        if (disabled || readonly || isFocus) {
+            return;
+        }
+        this._adapter.focusInput();
+        this._adapter.toggleFocusing(true);
+    }
 }

package/lib/cjs/aiChatInput/foundation.js

@@ -360,7 +360,9 @@ class AIChatInputFoundation extends _foundation.default {
     };
     this.handRichTextArealKeyDown = (view, event) => {
       var _a;
-      // console.log('outer key down handle');
+      if (view.composing) {
+        return false;
+      }
       const {
         sendHotKey
       } = this.getProps();

package/lib/cjs/autoComplete/foundation.d.ts

@@ -13,6 +13,7 @@ export interface DataItem {
 export interface StateOptionItem extends DataItem {
     show?: boolean;
     key?: string | number;
+    _renderedLabel?: any;
 }
 export type AutoCompleteData = Array<DataItem | string>;
 export interface AutoCompleteAdapter<P = Record<string, any>, S = Record<string, any>> extends KeyboardAdapter<P, S> {

package/lib/cjs/autoComplete/foundation.js

@@ -119,7 +119,7 @@ class AutoCompleteFoundation extends _foundation.default {
           }, item);
         }
         if (renderItem && typeof renderItem === 'function') {
-          option.label = renderItem(item);
+          option._renderedLabel = renderItem(item);
         }
         options.push(option);
       });

package/lib/cjs/cascader/foundation.d.ts

@@ -110,6 +110,7 @@ export interface BasicCascaderProps {
     disableStrictly?: boolean;
     leafOnly?: boolean;
     enableLeafClick?: boolean;
+    clickToSelect?: boolean;
     preventScroll?: boolean;
     virtualizeInSearch?: Virtualize;
     checkRelation?: string;

package/lib/cjs/cascader/foundation.js

@@ -555,7 +555,8 @@ class CascaderFoundation extends _foundation.default {
       changeOnSelect: allowChange,
       filterLeafOnly,
       multiple,
-      enableLeafClick
+      enableLeafClick,
+      clickToSelect
     } = this.getProps();
     const {
       keyEntities,
@@ -571,7 +572,9 @@ class CascaderFoundation extends _foundation.default {
     const activeKeys = keyEntities[key].path;
     const selectedKey = [key];
     const hasChanged = key !== [...selectedKeys][0];
-    if (!isLeaf && !allowChange && !isSearching) {
+    // When clickToSelect is enabled in multiple mode, allow clicking non-leaf nodes to select
+    // In single mode, changeOnSelect (allowChange) controls this behavior
+    if (!isLeaf && !allowChange && !isSearching && !(multiple && clickToSelect)) {
       this._adapter.updateStates({
         activeKeys: new Set(activeKeys)
       });
@@ -582,7 +585,9 @@ class CascaderFoundation extends _foundation.default {
       this._adapter.updateStates({
         activeKeys: new Set(activeKeys)
       });
-      if (isLeaf && enableLeafClick) {
+      // clickToSelect: click any node to select (takes precedence over enableLeafClick)
+      // enableLeafClick: click leaf node to select
+      if (clickToSelect || isLeaf && enableLeafClick) {
         this.onItemCheckboxClick(item);
       }
     } else {

package/lib/cjs/collapsible/foundation.d.ts

@@ -5,6 +5,7 @@ export interface CollapsibleFoundationProps {
     keepDOM?: boolean;
     className?: string;
     collapseHeight?: number;
+    collapseHeightAdaptive?: boolean;
     reCalcKey?: number | string;
     id?: string;
     fade?: boolean;

package/lib/cjs/datePicker/datePicker.css

@@ -624,10 +624,10 @@
   height: fit-content;
   border: none;
 }
-.semi-datepicker-range-input-wrapper .semi-input-wrapper:active {
+.semi-datepicker-range-input-wrapper .semi-input-wrapper:active:not(#neverExistElement) {
   background-color: transparent;
 }
-.semi-datepicker-range-input-wrapper .semi-input-wrapper:hover {
+.semi-datepicker-range-input-wrapper .semi-input-wrapper:hover:not(#neverExistElement) {
   background-color: transparent;
 }
 .semi-datepicker-range-input-wrapper-focus {

package/lib/cjs/datePicker/datePicker.scss

@@ -937,11 +937,11 @@ $module-list: #{$prefix}-scrolllist;
                     height: fit-content;
                     border: none;
 
-                    &:active  {
+                    &:active:not(#neverExistElement) {
                         background-color: transparent;
                     }
 
-                    &:hover {
+                    &:hover:not(#neverExistElement) {
                         background-color: transparent;
                     }
                 }

package/lib/cjs/descriptions/foundation.js

@@ -17,12 +17,14 @@ class DescriptionsFoundation extends _foundation.default {
       children
     } = this.getProps();
     const columns = this._adapter.getColumns();
+    // Filter out hidden items before grouping
+    const visibleColumns = columns.filter(item => !item.hidden);
     const horizontalList = [];
     const curSpan = {
       totalSpan: 0,
       itemList: []
     };
-    for (const item of columns) {
+    for (const item of visibleColumns) {
       curSpan.totalSpan += item.span || 1;
       curSpan.itemList.push(item);
       if (curSpan.totalSpan >= column) {

package/lib/cjs/form/foundation.d.ts

@@ -1,6 +1,6 @@
 import BaseFoundation from '../base/foundation';
 import { Options as ScrollIntoViewOptions } from 'scroll-into-view-if-needed';
-import { BaseFormAdapter, FormState, CallOpts, FieldState, FieldStaff, ComponentProps, setValuesConfig, ArrayFieldStaff } from './interface';
+import { BaseFormAdapter, FormState, CallOpts, FieldState, FieldStaff, ComponentProps, setValuesConfig, ArrayFieldStaff, ValidateOptions } from './interface';
 export type { BaseFormAdapter };
 type ScrollToErrorOpts = {
     field?: string;
@@ -21,9 +21,9 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
     unRegisterArrayField(arrayField: string): void;
     getArrayField(arrayField: string): ArrayFieldStaff;
     updateArrayField(arrayField: string, updateValue: any): void;
-    validate(fieldPaths?: Array<string>): Promise<unknown>;
-    _formValidate(): Promise<unknown>;
-    _fieldsValidate(fieldPaths: Array<string>): Promise<unknown>;
+    validate(fieldPaths?: Array<string> | ValidateOptions): Promise<unknown>;
+    _formValidate(silent?: boolean): Promise<unknown>;
+    _fieldsValidate(fieldPaths: Array<string>, silent?: boolean): Promise<unknown>;
     submit(e?: any): void;
     /**
      * Case A：
@@ -77,7 +77,7 @@ export default class FormFoundation extends BaseFoundation<BaseFormAdapter> {
     };
     getFormApi(): {
         reset: (fields?: Array<string>) => void;
-        validate: (fields?: Array<string>) => Promise<unknown>;
+        validate: (fields?: Array<string> | ValidateOptions) => Promise<unknown>;
         getValue: (field?: string) => any;
         getValues: () => any;
         getFormState: () => FormState<any>;

package/lib/cjs/form/foundation.js

@@ -138,14 +138,27 @@ class FormFoundation extends _foundation.default {
     const {
       validateFields
     } = this.getProps();
+    // Parse options
+    let fields;
+    let silent = false;
+    if (fieldPaths && !Array.isArray(fieldPaths)) {
+      // It's a ValidateOptions object
+      const options = fieldPaths;
+      fields = options.fields;
+      silent = options.silent || false;
+    } else {
+      // It's an array of fields (or undefined)
+      fields = fieldPaths;
+    }
     if (validateFields && (0, _isFunction2.default)(validateFields)) {
-      return this._formValidate();
+      return this._formValidate(silent);
     } else {
-      return this._fieldsValidate(fieldPaths);
+      return this._fieldsValidate(fields, silent);
     }
   }
   // form level validate
   _formValidate() {
+    let silent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     const {
       values
     } = this.data;
@@ -163,41 +176,52 @@ class FormFoundation extends _foundation.default {
       if (!maybePromisedErrors) {
         const _values = this._adapter.cloneDeep(values);
         resolve(_values);
-        this.injectErrorToField({});
+        if (!silent) {
+          this.injectErrorToField({});
+        }
       } else if ((0, _isPromise.default)(maybePromisedErrors)) {
         maybePromisedErrors.then(result => {
           // validate success，clear error
           if (!result) {
             const _values = this._adapter.cloneDeep(values);
             resolve(_values);
-            this.injectErrorToField({});
+            if (!silent) {
+              this.injectErrorToField({});
+            }
           } else {
-            this.data.errors = result;
-            this._adapter.notifyChange(this.data);
-            this.injectErrorToField(result);
-            this._adapter.forceUpdate();
-            this._autoScroll(100);
+            if (!silent) {
+              this.data.errors = result;
+              this._adapter.notifyChange(this.data);
+              this.injectErrorToField(result);
+              this._adapter.forceUpdate();
+              this._autoScroll(100);
+            }
             reject(result);
           }
         }, errors => {
           // validate failed
-          // this._adapter.notifyChange(this.data);
-          this._autoScroll(100);
+          if (!silent) {
+            // this._adapter.notifyChange(this.data);
+            this._autoScroll(100);
+          }
           reject(errors);
         });
       } else {
         // TODO: current design, returning an empty object will be considered a checksum failure and will be rejected. Only returning an empty string will be considered a success, consider resetting it in 1.0?
-        this.data.errors = maybePromisedErrors;
-        this.injectErrorToField(maybePromisedErrors);
-        this._adapter.notifyChange(this.data);
-        this._adapter.forceUpdate();
-        this._autoScroll(100);
+        if (!silent) {
+          this.data.errors = maybePromisedErrors;
+          this.injectErrorToField(maybePromisedErrors);
+          this._adapter.notifyChange(this.data);
+          this._adapter.forceUpdate();
+          this._autoScroll(100);
+        }
         reject(maybePromisedErrors);
       }
     });
   }
   // field level validate
   _fieldsValidate(fieldPaths) {
+    let silent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       values
     } = this.data;
@@ -209,24 +233,37 @@ class FormFoundation extends _foundation.default {
         // Call each fieldApi for verification
         const fieldValue = this.getValue(fieldPath);
         // When centralized verification, no need to trigger forceUpdate and notify
+        // Each field skips individual updates; a single forceUpdate fires after all resolve.
         const opts = {
           notNotify: true,
-          notUpdate: true
+          notUpdate: true,
+          silent
         };
         const validateResult = field.fieldApi.validate(fieldValue, opts);
         promiseSet.push(validateResult);
-        field.fieldApi.setTouched(true, opts);
+        // Only set touched when not in silent mode
+        if (!silent) {
+          field.fieldApi.setTouched(true, {
+            notNotify: true,
+            notUpdate: true
+          });
+        }
       });
       Promise.all(promiseSet).then(() => {
         // After the centralized verification is completed, trigger notify and forceUpdate once.
-        this._adapter.notifyChange(this.data);
-        this._adapter.forceUpdate();
+        // But skip UI updates in silent mode
+        if (!silent) {
+          this._adapter.notifyChange(this.data);
+          this._adapter.forceUpdate();
+        }
         const errors = this.getError();
         if (this._isValid(targetFields)) {
           const _values = this._adapter.cloneDeep(values);
           resolve(_values);
         } else {
-          this._autoScroll();
+          if (!silent) {
+            this._autoScroll();
+          }
           reject(errors);
         }
       });