@douyinfe/semi-foundation 2.93.0 → 2.94.1

package/lib/es/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/es/cascader/foundation.js

@@ -548,7 +548,8 @@ export default class CascaderFoundation extends BaseFoundation {
       changeOnSelect: allowChange,
       filterLeafOnly,
       multiple,
-      enableLeafClick
+      enableLeafClick,
+      clickToSelect
     } = this.getProps();
     const {
       keyEntities,
@@ -564,7 +565,9 @@ export default class CascaderFoundation extends BaseFoundation {
     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)
       });
@@ -575,7 +578,9 @@ export default class CascaderFoundation extends BaseFoundation {
       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/es/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/es/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/es/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/es/descriptions/foundation.js

@@ -10,12 +10,14 @@ export default class DescriptionsFoundation extends BaseFoundation {
       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/es/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/es/form/foundation.js

@@ -129,14 +129,27 @@ export default class FormFoundation extends BaseFoundation {
     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 && _isFunction(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;
@@ -154,41 +167,52 @@ export default class FormFoundation extends BaseFoundation {
       if (!maybePromisedErrors) {
         const _values = this._adapter.cloneDeep(values);
         resolve(_values);
-        this.injectErrorToField({});
+        if (!silent) {
+          this.injectErrorToField({});
+        }
       } else if (isPromise(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;
@@ -200,24 +224,37 @@ export default class FormFoundation extends BaseFoundation {
         // 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);
         }
       });

package/lib/es/form/interface.d.ts

@@ -42,6 +42,12 @@ export type ScrollToErrorOptions<K> = {
     index?: number;
     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;
+}
 export interface BaseFormApi<T extends object = any> {
     /** get value of field */
     getValue: <P extends FieldPath<T>>(field?: P) => FieldPathValue<T, P>;
@@ -65,8 +71,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<{
+    /** 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;

package/lib/es/input/textareaFoundation.d.ts

@@ -18,6 +18,8 @@ export interface TextAreaAdapter extends Partial<DefaultAdapter>, Partial<TextAr
     notifyPressEnter(e: any): void;
     getRef(): HTMLInputElement;
     notifyHeightUpdate(e: any): void;
+    focusInput(): void;
+    isEventTarget(e: any): boolean;
 }
 export default class TextAreaFoundation extends BaseFoundation<TextAreaAdapter> {
     static get textAreaDefaultAdapter(): {
@@ -67,4 +69,14 @@ export default class TextAreaFoundation extends BaseFoundation<TextAreaAdapter>
     handleMouseLeave(e: any): void;
     isAllowClear(): boolean;
     handleClear(e: any): void;
+    /**
+     * trigger when click textarea wrapper
+     * @param {Event} e
+     */
+    handleClick(e: any): void;
+    /**
+     * trigger when click textarea counter
+     * @param {Event} e
+     */
+    handleCounterClick(e: any): void;
 }

package/lib/es/input/textareaFoundation.js

@@ -270,4 +270,43 @@ export default class TextAreaFoundation extends BaseFoundation {
     this._adapter.notifyClear(e);
     this.stopPropagation(e);
   }
+  /**
+   * trigger when click textarea wrapper
+   * @param {Event} e
+   */
+  handleClick(e) {
+    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) {
+    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/es/modal/modalFoundation.d.ts

@@ -61,10 +61,16 @@ export interface ModalState {
     onCancelReturnPromiseStatus?: "pending" | "fulfilled" | "rejected";
 }
 export default class ModalFoundation extends BaseFoundation<ModalAdapter> {
+    private _debouncedOk;
+    private _debouncedCancel;
+    private _lastCancelTarget;
+    private _lastOkTarget;
     constructor(adapter: ModalAdapter);
     destroy(): void;
     handleCancel(e: any): void;
     handleOk(e: any): void;
+    private _invokeCancel;
+    private _invokeOk;
     beforeShow(): void;
     afterHide(): void;
     enabledBodyScroll(): void;

package/lib/es/modal/modalFoundation.js

@@ -1,19 +1,51 @@
+import _debounce from "lodash/debounce";
 import BaseFoundation from '../base/foundation';
 import isPromise from "../utils/isPromise";
 export default class ModalFoundation extends BaseFoundation {
   constructor(adapter) {
     super(Object.assign({}, adapter));
-    // afterClose() {
-    //     this._adapter.notifyClose();
-    // }
+    this._debouncedOk = _debounce(e => {
+      this._invokeOk(e);
+    }, 100, {
+      leading: true,
+      trailing: false
+    });
+    this._debouncedCancel = _debounce(e => {
+      this._invokeCancel(e);
+    }, 100, {
+      leading: true,
+      trailing: false
+    });
+    this._lastCancelTarget = null;
+    this._lastOkTarget = null;
     this.toggleDisplayNone = (displayNone, callback) => {
       this._adapter.toggleDisplayNone(displayNone, callback);
     };
   }
   destroy() {
+    this._debouncedOk.cancel();
+    this._debouncedCancel.cancel();
     this.afterHide();
   }
   handleCancel(e) {
+    var _a, _b;
+    const target = (_b = (_a = e === null || e === void 0 ? void 0 : e.currentTarget) !== null && _a !== void 0 ? _a : e === null || e === void 0 ? void 0 : e.target) !== null && _b !== void 0 ? _b : null;
+    if (target !== this._lastCancelTarget) {
+      this._debouncedCancel.cancel();
+    }
+    this._lastCancelTarget = target;
+    this._debouncedCancel(e);
+  }
+  handleOk(e) {
+    var _a, _b;
+    const target = (_b = (_a = e === null || e === void 0 ? void 0 : e.currentTarget) !== null && _a !== void 0 ? _a : e === null || e === void 0 ? void 0 : e.target) !== null && _b !== void 0 ? _b : null;
+    if (target !== this._lastOkTarget) {
+      this._debouncedOk.cancel();
+    }
+    this._lastOkTarget = target;
+    this._debouncedOk(e);
+  }
+  _invokeCancel(e) {
     var _a;
     const result = this._adapter.notifyCancel(e);
     if (isPromise(result)) {
@@ -32,7 +64,7 @@ export default class ModalFoundation extends BaseFoundation {
       });
     }
   }
-  handleOk(e) {
+  _invokeOk(e) {
     var _a;
     const result = this._adapter.notifyOk(e);
     if (isPromise(result)) {

package/lib/es/pagination/foundation.js

@@ -48,7 +48,13 @@ class PaginationFoundation extends BaseFoundation {
       prevIsDisabled = false;
       nextIsDisabled = true;
     }
-    this._adapter.setDisabled(prevIsDisabled, nextIsDisabled);
+    const {
+      prevDisabled: currentPrevDisabled,
+      nextDisabled: currentNextDisabled
+    } = this.getStates();
+    if (prevIsDisabled !== currentPrevDisabled || nextIsDisabled !== currentNextDisabled) {
+      this._adapter.setDisabled(prevIsDisabled, nextIsDisabled);
+    }
   }
   goPage(targetPageIndex) {
     if (targetPageIndex === '...') {
@@ -92,9 +98,17 @@ class PaginationFoundation extends BaseFoundation {
       total,
       pageSize
     });
-    this._adapter.updateTotal(total);
-    this._adapter.setCurrentPage(targetPageIndex);
-    this._adapter.updatePageSize(pageSize);
+    // Only call setState when value actually changed to avoid unnecessary re-renders
+    // that can cause infinite loops in React 18's concurrent batching
+    if (total !== this.getState('total')) {
+      this._adapter.updateTotal(total);
+    }
+    if (targetPageIndex !== this.getState('currentPage')) {
+      this._adapter.setCurrentPage(targetPageIndex);
+    }
+    if (pageSize !== this.getState('pageSize')) {
+      this._adapter.updatePageSize(pageSize);
+    }
   }
   updateAllPageNumbers(total, pageSize) {
     // only need to update in small size
@@ -230,9 +244,16 @@ class PaginationFoundation extends BaseFoundation {
       total,
       currentPage
     } = this.getStates();
-    // After converting the switching page capacity, which page is the current page
-    const currentPageFirstItemIndex = (currentPage - 1) * pageSize + 1;
-    const newCurrentPage = Math.ceil(currentPageFirstItemIndex / newPageSize);
+    // Check if we should prevent page change when pageSize changes
+    const {
+      preventPageChangeOnPageSizeChange
+    } = this.getProps();
+    let newCurrentPage = currentPage;
+    if (!preventPageChangeOnPageSizeChange) {
+      // After converting the switching page capacity, which page is the current page
+      const currentPageFirstItemIndex = (currentPage - 1) * pageSize + 1;
+      newCurrentPage = Math.ceil(currentPageFirstItemIndex / newPageSize);
+    }
     this.updatePage(newCurrentPage, total, newPageSize);
     if (currentPage !== newCurrentPage) {
       this._adapter.notifyPageChange(newCurrentPage);

package/lib/es/pincode/foundation.d.ts

@@ -3,7 +3,7 @@ export interface PinCodeBaseProps {
     disabled?: boolean;
     value?: string;
     format?: "number" | "mixed" | RegExp | ((value: string) => boolean);
-    onChange: (value: string) => void;
+    onChange?: (value: string) => void;
     defaultValue?: string;
     count?: number;
     autoFocus?: boolean;

package/lib/es/resizable/resizable.css

@@ -9,7 +9,7 @@
 .semi-resizable-resizableHandler {
   position: absolute;
   user-select: none;
-  z-index: 2000;
+  z-index: 10;
 }
 .semi-resizable-resizableHandler-top {
   width: 100%;
@@ -91,7 +91,7 @@
 }
 .semi-resizable-handler {
   user-select: none;
-  z-index: 2000;
+  z-index: 10;
   display: flex;
   align-items: center;
   justify-content: center;
@@ -114,7 +114,7 @@
   height: 100%;
   width: 100%;
   inset: 0;
-  z-index: 2010;
+  z-index: 20;
   opacity: 0;
   position: fixed;
 }

package/lib/es/resizable/variables.scss

@@ -1,5 +1,5 @@
-$z-resizable_handler: 2000 !default; // 伸缩框组件中handler的z-index
-$z-resizable_background: 2010; // 伸缩框组件中背景的z-index
+$z-resizable_handler: 10 !default; // 伸缩框组件中handler的z-index，保持较低层级避免覆盖弹出层组件
+$z-resizable_background: 20; // 伸缩框组件中背景的z-index，保持略高于handler
 
 $height-row-handler: 10px; // 单个伸缩框中上下handler的高度
 $width-col-handler: 10px;  // 单个伸缩框中左右handler的宽度

package/lib/es/select/foundation.d.ts

@@ -54,7 +54,7 @@ export default class SelectFoundation extends BaseFoundation<SelectAdapter> {
     constructor(adapter: SelectAdapter);
     _keydownHandler: (...arg: any[]) => void | null;
     init(): void;
-    focus(): void;
+    focus(optionsForOpen?: BasicOptionProps[]): void;
     _focusTrigger(): void;
     destroy(): void;
     _setDropdownWidth(): void;

package/lib/es/select/foundation.js

@@ -34,20 +34,31 @@ export default class SelectFoundation extends BaseFoundation {
     }
     const autoFocus = this.getProp('autoFocus');
     if (autoFocus) {
-      this.focus();
+      this.focus(originalOptions);
     }
   }
-  focus() {
+  focus(optionsForOpen) {
     const isFilterable = this._isFilterable();
     const isMultiple = this._isMultiple();
+    const {
+      isOpen
+    } = this.getStates();
     this._adapter.updateFocusState(true);
     this._adapter.setIsFocusInContainer(false);
-    if (isFilterable && isMultiple) {
-      // when filter and multiple, only focus input
-      this.focusInput();
-    } else if (isFilterable && !isMultiple) {
-      // when filter and not multiple, only show input and focus input
-      this.toggle2SearchInput(true);
+    if (isFilterable) {
+      if (isMultiple) {
+        // when filter and multiple, focus input and open dropdown
+        this.focusInput();
+        if (!isOpen) {
+          this.open(undefined, optionsForOpen);
+        }
+      } else {
+        // when filter and not multiple, show input, focus it and open dropdown
+        this.toggle2SearchInput(true);
+        if (!isOpen) {
+          this.open(undefined, optionsForOpen);
+        }
+      }
     } else {
       this._focusTrigger();
     }

package/lib/es/steps/bacisSteps.scss

@@ -69,11 +69,17 @@ $basicType: #{$module}-basic;
 
             .#{$item}-title {
                 max-width: $width-steps_basic_item_title-maxWidth;
+                min-height: $height-steps_basic_item_left-icon;
+                display: inline-flex;
+                align-items: center;
                 
                 .#{$item}-title-text {
                     @include text-overflow-hidden;
-                    transition: color $transition_duration-steps_item_title-text $transition_function-steps_item_title-text $transition_delay-steps_item_title-text
-                       
+                    transition: color $transition_duration-steps_item_title-text $transition_function-steps_item_title-text $transition_delay-steps_item_title-text;
+
+                    &-empty {
+                        width: 0;
+                    }
                 }
             }
 

package/lib/es/steps/steps.css

@@ -193,6 +193,9 @@
 }
 .semi-steps-basic.semi-steps-horizontal .semi-steps-item .semi-steps-item-title {
   max-width: 80%;
+  min-height: 24px;
+  display: inline-flex;
+  align-items: center;
 }
 .semi-steps-basic.semi-steps-horizontal .semi-steps-item .semi-steps-item-title .semi-steps-item-title-text {
   overflow: hidden;
@@ -200,6 +203,9 @@
   white-space: nowrap;
   transition: color var(--semi-transition_duration-none) var(--semi-transition_function-easeIn) var(--semi-transition_delay-none);
 }
+.semi-steps-basic.semi-steps-horizontal .semi-steps-item .semi-steps-item-title .semi-steps-item-title-text-empty {
+  width: 0;
+}
 .semi-steps-basic.semi-steps-vertical {
   display: flex;
   flex-flow: column nowrap;

package/lib/es/upload/foundation.d.ts

@@ -74,8 +74,10 @@ export interface UploadAdapter<P = Record<string, any>, S = Record<string, any>>
     notifyPreviewClick: (file: any) => void;
     notifyDrop: (e: any, files: Array<File>, fileList: Array<BaseFileItem>) => void;
     notifyAcceptInvalid: (invalidFiles: Array<File>) => void;
-    registerPastingHandler: (cb?: (params?: any) => void) => void;
+    registerPastingHandler: (cb?: (params?: KeyboardEvent | ClipboardEvent) => void) => void;
     unRegisterPastingHandler: () => void;
+    registerPasteEventHandler: (cb?: (params?: ClipboardEvent) => void) => void;
+    unRegisterPasteEventHandler: () => void;
     isMac: () => boolean;
     notifyPastingError: (error: Error | PermissionStatus) => void;
 }
@@ -87,6 +89,11 @@ declare class UploadFoundation<P = Record<string, any>, S = Record<string, any>>
      * when _createURL is called multiple times in a sync loop.
      */
     _localUrls: Record<string, string>;
+    /**
+     * Flag to prevent duplicate handling of paste events.
+     * When paste event is successfully handled, we ignore the subsequent keydown event.
+     */
+    _pasteHandled: boolean;
     constructor(adapter: UploadAdapter<P, S>);
     init(): void;
     /**