rsuite 5.75.0 → 6.0.0-canary-20241227

package/esm/Cascader/Cascader.js

@@ -1,9 +1,6 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["as", "data", "classPrefix", "childrenKey", "valueKey", "labelKey", "defaultValue", "placeholder", "disabled", "disabledItemValues", "appearance", "cleanable", "locale", "toggleAs", "style", "value", "popupClassName", "popupStyle", "columnHeight", "columnWidth", "searchable", "parentSelectable", "placement", "id", "renderColumn", "renderTreeNode", "renderSearchItem", "renderValue", "renderExtraFooter", "onEntered", "onExited", "onClean", "onChange", "onSelect", "onSearch", "getChildren", "menuClassName", "menuStyle", "menuWidth", "menuHeight", "renderMenuItem", "renderMenu"];
 import React, { useCallback, useMemo } from 'react';
-import PropTypes from 'prop-types';
 import omit from 'lodash/omit';
 import pick from 'lodash/pick';
 import isNil from 'lodash/isNil';
@@ -13,119 +10,104 @@ import SearchView from "../CascadeTree/SearchView.js";
 import { usePaths, useSelect, useSearch } from "../CascadeTree/hooks/index.js";
 import { flattenTree } from "../Tree/utils/index.js";
 import { findNodeOfTree, getParentMap } from "../internals/Tree/utils/index.js";
-import { deprecatePropTypeNew } from "../internals/propTypes/index.js";
 import { useControlled, useClassNames, useEventCallback, useMap } from "../internals/hooks/index.js";
 import { createChainedFunction, mergeRefs, shallowEqual } from "../internals/utils/index.js";
-import { PickerToggle, PickerPopup, PickerToggleTrigger, usePickerClassName, usePickerRef, useToggleKeyDownEvent, useFocusItemValue, pickTriggerPropKeys, omitTriggerPropKeys, listPickerPropTypes } from "../internals/Picker/index.js";
-import { oneOf } from "../internals/propTypes/index.js";
+import { PickerToggle, PickerPopup, PickerToggleTrigger, usePickerClassName, usePickerRef, useToggleKeyDownEvent, useFocusItemValue, pickTriggerPropKeys, omitTriggerPropKeys } from "../internals/Picker/index.js";
 import { useCustom } from "../CustomProvider/index.js";
 import useActive from "./useActive.js";
-var emptyArray = [];
+const emptyArray = [];
 
 /**
  * The `Cascader` component displays a hierarchical list of options.
  * @see https://rsuitejs.com/components/cascader
  */
-var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _useCustom = useCustom('Cascader', props),
-    rtl = _useCustom.rtl,
-    propsWithDefaults = _useCustom.propsWithDefaults;
-  var _propsWithDefaults$as = propsWithDefaults.as,
-    Component = _propsWithDefaults$as === void 0 ? 'div' : _propsWithDefaults$as,
-    _propsWithDefaults$da = propsWithDefaults.data,
-    data = _propsWithDefaults$da === void 0 ? emptyArray : _propsWithDefaults$da,
-    _propsWithDefaults$cl = propsWithDefaults.classPrefix,
-    classPrefix = _propsWithDefaults$cl === void 0 ? 'picker' : _propsWithDefaults$cl,
-    _propsWithDefaults$ch = propsWithDefaults.childrenKey,
-    childrenKey = _propsWithDefaults$ch === void 0 ? 'children' : _propsWithDefaults$ch,
-    _propsWithDefaults$va = propsWithDefaults.valueKey,
-    valueKey = _propsWithDefaults$va === void 0 ? 'value' : _propsWithDefaults$va,
-    _propsWithDefaults$la = propsWithDefaults.labelKey,
-    labelKey = _propsWithDefaults$la === void 0 ? 'label' : _propsWithDefaults$la,
-    defaultValue = propsWithDefaults.defaultValue,
-    placeholder = propsWithDefaults.placeholder,
-    disabled = propsWithDefaults.disabled,
-    _propsWithDefaults$di = propsWithDefaults.disabledItemValues,
-    disabledItemValues = _propsWithDefaults$di === void 0 ? emptyArray : _propsWithDefaults$di,
-    _propsWithDefaults$ap = propsWithDefaults.appearance,
-    appearance = _propsWithDefaults$ap === void 0 ? 'default' : _propsWithDefaults$ap,
-    _propsWithDefaults$cl2 = propsWithDefaults.cleanable,
-    cleanable = _propsWithDefaults$cl2 === void 0 ? true : _propsWithDefaults$cl2,
-    locale = propsWithDefaults.locale,
-    toggleAs = propsWithDefaults.toggleAs,
-    style = propsWithDefaults.style,
-    valueProp = propsWithDefaults.value,
-    popupClassName = propsWithDefaults.popupClassName,
-    popupStyle = propsWithDefaults.popupStyle,
-    columnHeight = propsWithDefaults.columnHeight,
-    columnWidth = propsWithDefaults.columnWidth,
-    _propsWithDefaults$se = propsWithDefaults.searchable,
-    searchable = _propsWithDefaults$se === void 0 ? true : _propsWithDefaults$se,
-    parentSelectable = propsWithDefaults.parentSelectable,
-    _propsWithDefaults$pl = propsWithDefaults.placement,
-    placement = _propsWithDefaults$pl === void 0 ? 'bottomStart' : _propsWithDefaults$pl,
-    id = propsWithDefaults.id,
-    renderColumn = propsWithDefaults.renderColumn,
-    renderTreeNode = propsWithDefaults.renderTreeNode,
-    renderSearchItem = propsWithDefaults.renderSearchItem,
-    renderValue = propsWithDefaults.renderValue,
-    renderExtraFooter = propsWithDefaults.renderExtraFooter,
-    onEntered = propsWithDefaults.onEntered,
-    onExited = propsWithDefaults.onExited,
-    onClean = propsWithDefaults.onClean,
-    onChange = propsWithDefaults.onChange,
-    onSelect = propsWithDefaults.onSelect,
-    onSearch = propsWithDefaults.onSearch,
-    getChildren = propsWithDefaults.getChildren,
-    DEPRECATED_menuClassName = propsWithDefaults.menuClassName,
-    DEPRECATED_menuStyle = propsWithDefaults.menuStyle,
-    DEPRECATED_menuWidth = propsWithDefaults.menuWidth,
-    DEPRECATED_menuHeight = propsWithDefaults.menuHeight,
-    DEPRECATED_renderMenuItem = propsWithDefaults.renderMenuItem,
-    DEPRECATED_renderMenu = propsWithDefaults.renderMenu,
-    rest = _objectWithoutPropertiesLoose(propsWithDefaults, _excluded);
-  var _usePickerRef = usePickerRef(ref),
-    trigger = _usePickerRef.trigger,
-    root = _usePickerRef.root,
-    target = _usePickerRef.target,
-    overlay = _usePickerRef.overlay,
-    searchInput = _usePickerRef.searchInput;
-  var _ref = useControlled(valueProp, defaultValue),
-    value = _ref[0],
-    setValue = _ref[1];
+const Cascader = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    rtl,
+    propsWithDefaults
+  } = useCustom('Cascader', props);
+  const {
+    as: Component = 'div',
+    data = emptyArray,
+    classPrefix = 'picker',
+    childrenKey = 'children',
+    valueKey = 'value',
+    labelKey = 'label',
+    defaultValue,
+    placeholder,
+    disabled,
+    disabledItemValues = emptyArray,
+    appearance = 'default',
+    cleanable = true,
+    locale,
+    toggleAs,
+    style,
+    value: valueProp,
+    popupClassName,
+    popupStyle,
+    columnHeight,
+    columnWidth,
+    searchable = true,
+    parentSelectable,
+    placement = 'bottomStart',
+    id,
+    renderColumn,
+    renderTreeNode,
+    renderSearchItem,
+    renderValue,
+    renderExtraFooter,
+    onEntered,
+    onExited,
+    onClean,
+    onChange,
+    onSelect,
+    onSearch,
+    getChildren,
+    menuClassName: DEPRECATED_menuClassName,
+    menuStyle: DEPRECATED_menuStyle,
+    menuWidth: DEPRECATED_menuWidth,
+    menuHeight: DEPRECATED_menuHeight,
+    renderMenuItem: DEPRECATED_renderMenuItem,
+    renderMenu: DEPRECATED_renderMenu,
+    ...rest
+  } = propsWithDefaults;
+  const {
+    trigger,
+    root,
+    target,
+    overlay,
+    searchInput
+  } = usePickerRef(ref);
+  const [value, setValue] = useControlled(valueProp, defaultValue);
 
   // Store the children of each node
-  var childrenMap = useMap();
+  const childrenMap = useMap();
 
   // Store the parent of each node
-  var parentMap = useMemo(function () {
-    return getParentMap(data, function (item) {
-      var _childrenMap$get;
-      return (_childrenMap$get = childrenMap.get(item)) !== null && _childrenMap$get !== void 0 ? _childrenMap$get : item[childrenKey];
-    });
-  }, [childrenMap, childrenKey, data]);
+  const parentMap = useMemo(() => getParentMap(data, item => {
+    var _childrenMap$get;
+    return (_childrenMap$get = childrenMap.get(item)) !== null && _childrenMap$get !== void 0 ? _childrenMap$get : item[childrenKey];
+  }), [childrenMap, childrenKey, data]);
 
   // Flatten the tree data
-  var flattenedData = useMemo(function () {
-    return flattenTree(data, function (item) {
-      var _childrenMap$get2;
-      return (_childrenMap$get2 = childrenMap.get(item)) !== null && _childrenMap$get2 !== void 0 ? _childrenMap$get2 : item[childrenKey];
-    });
-  }, [childrenMap, childrenKey, data]);
+  const flattenedData = useMemo(() => flattenTree(data, item => {
+    var _childrenMap$get2;
+    return (_childrenMap$get2 = childrenMap.get(item)) !== null && _childrenMap$get2 !== void 0 ? _childrenMap$get2 : item[childrenKey];
+  }), [childrenMap, childrenKey, data]);
 
   // The selected item
-  var selectedItem = flattenedData.find(function (item) {
-    return item[valueKey] === value;
-  });
+  const selectedItem = flattenedData.find(item => item[valueKey] === value);
 
   // Callback function after selecting the node
-  var onSelectCallback = function onSelectCallback(node, event) {
+  const onSelectCallback = (node, event) => {
     var _trigger$current;
-    var isLeafNode = node.isLeafNode,
-      cascadePaths = node.cascadePaths,
-      itemData = node.itemData;
+    const {
+      isLeafNode,
+      cascadePaths,
+      itemData
+    } = node;
     onSelect === null || onSelect === void 0 || onSelect(itemData, cascadePaths, event);
-    var nextValue = itemData[valueKey];
+    const nextValue = itemData[valueKey];
     if (isLeafNode) {
       // Determines whether the option is a leaf node, and if so, closes the picker.
       handleClose();
@@ -142,70 +124,66 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
     // Update menu position
     (_trigger$current = trigger.current) === null || _trigger$current === void 0 || _trigger$current.updatePosition();
   };
-  var _useSelect = useSelect({
-      value: value,
-      valueKey: valueKey,
-      childrenKey: childrenKey,
-      childrenMap: childrenMap,
-      selectedItem: selectedItem,
-      getChildren: getChildren,
-      onChange: onChange,
-      onSelect: onSelectCallback
-    }),
-    activeItem = _useSelect.activeItem,
-    setActiveItem = _useSelect.setActiveItem,
-    loadingItemsSet = _useSelect.loadingItemsSet,
-    handleSelect = _useSelect.handleSelect;
-  var _usePaths = usePaths({
-      data: data,
-      activeItem: activeItem,
-      selectedItem: selectedItem,
-      getParent: function getParent(item) {
-        return parentMap.get(item);
-      },
-      getChildren: function getChildren(item) {
-        var _childrenMap$get3;
-        return (_childrenMap$get3 = childrenMap.get(item)) !== null && _childrenMap$get3 !== void 0 ? _childrenMap$get3 : item[childrenKey];
-      }
-    }),
-    columns = _usePaths.columns,
-    pathTowardsActiveItem = _usePaths.pathTowardsActiveItem,
-    pathTowardsSelectedItem = _usePaths.pathTowardsSelectedItem;
+  const {
+    activeItem,
+    setActiveItem,
+    loadingItemsSet,
+    handleSelect
+  } = useSelect({
+    value,
+    valueKey,
+    childrenKey,
+    childrenMap,
+    selectedItem,
+    getChildren,
+    onChange,
+    onSelect: onSelectCallback
+  });
+  const {
+    columns,
+    pathTowardsActiveItem,
+    pathTowardsSelectedItem
+  } = usePaths({
+    data,
+    activeItem,
+    selectedItem,
+    getParent: item => parentMap.get(item),
+    getChildren: item => {
+      var _childrenMap$get3;
+      return (_childrenMap$get3 = childrenMap.get(item)) !== null && _childrenMap$get3 !== void 0 ? _childrenMap$get3 : item[childrenKey];
+    }
+  });
 
   /**
    * 1.Have a value and the value is valid.
    * 2.Regardless of whether the value is valid, as long as renderValue is set, it is judged to have a value.
    */
-  var hasValue = pathTowardsSelectedItem.length > 0 || !isNil(value) && isFunction(renderValue);
-  var _useClassNames = useClassNames(classPrefix),
-    prefix = _useClassNames.prefix,
-    merge = _useClassNames.merge;
-  var onFocusItemCallback = useCallback(function (value) {
-    setActiveItem(flattenedData.find(function (item) {
-      return item[valueKey] === value;
-    }));
+  let hasValue = pathTowardsSelectedItem.length > 0 || !isNil(value) && isFunction(renderValue);
+  const {
+    prefix,
+    merge
+  } = useClassNames(classPrefix);
+  const onFocusItemCallback = useCallback(value => {
+    setActiveItem(flattenedData.find(item => item[valueKey] === value));
   }, [flattenedData, setActiveItem, valueKey]);
 
   // Used to hover the focuse item  when trigger `onKeydown`
-  var _useFocusItemValue = useFocusItemValue(value, {
-      rtl: rtl,
-      data: flattenedData,
-      valueKey: valueKey,
-      defaultLayer: pathTowardsSelectedItem !== null && pathTowardsSelectedItem !== void 0 && pathTowardsSelectedItem.length ? pathTowardsSelectedItem.length - 1 : 0,
-      target: function target() {
-        return overlay.current;
-      },
-      getParent: function getParent(item) {
-        return parentMap.get(item);
-      },
-      callback: onFocusItemCallback
-    }),
-    focusItemValue = _useFocusItemValue.focusItemValue,
-    setFocusItemValue = _useFocusItemValue.setFocusItemValue,
-    setLayer = _useFocusItemValue.setLayer,
-    setKeys = _useFocusItemValue.setKeys,
-    onFocusItem = _useFocusItemValue.onKeyDown;
-  var onSearchCallback = function onSearchCallback(value, items, event) {
+  const {
+    focusItemValue,
+    setFocusItemValue,
+    setLayer,
+    setKeys,
+    onKeyDown: onFocusItem
+  } = useFocusItemValue(value, {
+    rtl,
+    data: flattenedData,
+    valueKey,
+    defaultLayer: pathTowardsSelectedItem !== null && pathTowardsSelectedItem !== void 0 && pathTowardsSelectedItem.length ? pathTowardsSelectedItem.length - 1 : 0,
+    target: () => overlay.current,
+    getParent: item => parentMap.get(item),
+    callback: onFocusItemCallback
+  });
+  const onSearchCallback = (value, items, event) => {
     onSearch === null || onSearch === void 0 || onSearch(value, event);
     if (!value || items.length === 0) {
       setFocusItemValue(undefined);
@@ -217,46 +195,46 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
       setKeys([]);
     }
   };
-  var _useSearch = useSearch({
-      labelKey: labelKey,
-      childrenKey: childrenKey,
-      parentMap: parentMap,
-      flattenedData: flattenedData,
-      parentSelectable: parentSelectable,
-      onSearch: onSearchCallback
-    }),
-    items = _useSearch.items,
-    searchKeyword = _useSearch.searchKeyword,
-    setSearchKeyword = _useSearch.setSearchKeyword,
-    handleSearch = _useSearch.handleSearch;
-  var _useActive = useActive({
-      onEntered: onEntered,
-      onExited: onExited,
-      target: target,
-      setSearchKeyword: setSearchKeyword
-    }),
-    active = _useActive.active,
-    handleEntered = _useActive.handleEntered,
-    handleExited = _useActive.handleExited;
-  var handleClose = useEventCallback(function () {
+  const {
+    items,
+    searchKeyword,
+    setSearchKeyword,
+    handleSearch
+  } = useSearch({
+    labelKey,
+    childrenKey,
+    parentMap,
+    flattenedData,
+    parentSelectable,
+    onSearch: onSearchCallback
+  });
+  const {
+    active,
+    handleEntered,
+    handleExited
+  } = useActive({
+    onEntered,
+    onExited,
+    target,
+    setSearchKeyword
+  });
+  const handleClose = useEventCallback(() => {
     var _trigger$current2, _target$current, _target$current$focus;
     (_trigger$current2 = trigger.current) === null || _trigger$current2 === void 0 || _trigger$current2.close();
 
     // The focus is on the trigger button after closing
     (_target$current = target.current) === null || _target$current === void 0 || (_target$current$focus = _target$current.focus) === null || _target$current$focus === void 0 || _target$current$focus.call(_target$current);
   });
-  var handleClean = useEventCallback(function (event) {
+  const handleClean = useEventCallback(event => {
     if (disabled || !target.current) {
       return;
     }
     setValue(null);
     onChange === null || onChange === void 0 || onChange(null, event);
   });
-  var handleMenuPressEnter = useEventCallback(function (event) {
-    var focusItem = findNodeOfTree(data, function (item) {
-      return item[valueKey] === focusItemValue;
-    });
-    var isLeafNode = focusItem && !focusItem[childrenKey];
+  const handleMenuPressEnter = useEventCallback(event => {
+    const focusItem = findNodeOfTree(data, item => item[valueKey] === focusItemValue);
+    const isLeafNode = focusItem && !focusItem[childrenKey];
     if (isLeafNode) {
       setValue(focusItemValue);
       if (pathTowardsActiveItem.length) {
@@ -269,33 +247,36 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
       handleClose();
     }
   });
-  var onPickerKeyDown = useToggleKeyDownEvent(_extends({
+  const onPickerKeyDown = useToggleKeyDownEvent({
     toggle: !focusItemValue || !active,
-    trigger: trigger,
-    target: target,
-    overlay: overlay,
-    searchInput: searchInput,
-    active: active,
+    trigger,
+    target,
+    overlay,
+    searchInput,
+    active,
     onExit: handleClean,
     onMenuKeyDown: onFocusItem,
-    onMenuPressEnter: handleMenuPressEnter
-  }, rest));
+    onMenuPressEnter: handleMenuPressEnter,
+    ...rest
+  });
 
   /**
    * The search structure option is processed after being selected.
    */
-  var handleSearchRowSelect = useEventCallback(function (itemData, nodes, event) {
-    var nextValue = itemData[valueKey];
+  const handleSearchRowSelect = useEventCallback((itemData, nodes, event) => {
+    const nextValue = itemData[valueKey];
     handleClose();
     setSearchKeyword('');
     setValue(nextValue);
     onSelect === null || onSelect === void 0 || onSelect(itemData, nodes, event);
     onChange === null || onChange === void 0 || onChange(nextValue, event);
   });
-  var renderCascadeColumn = function renderCascadeColumn(childNodes, column) {
-    var items = column.items,
-      parentItem = column.parentItem,
-      layer = column.layer;
+  const renderCascadeColumn = (childNodes, column) => {
+    const {
+      items,
+      parentItem,
+      layer
+    } = column;
     if (typeof renderColumn === 'function') {
       return renderColumn(childNodes, column);
     } else if (typeof DEPRECATED_renderMenu === 'function') {
@@ -303,23 +284,26 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
     }
     return childNodes;
   };
-  var renderCascadeTreeNode = function renderCascadeTreeNode(node, itemData) {
-    var render = typeof renderTreeNode === 'function' ? renderTreeNode : DEPRECATED_renderMenuItem;
+  const renderCascadeTreeNode = (node, itemData) => {
+    const render = typeof renderTreeNode === 'function' ? renderTreeNode : DEPRECATED_renderMenuItem;
     if (typeof render === 'function') {
       return render(node, itemData);
     }
     return node;
   };
-  var renderTreeView = function renderTreeView(positionProps, speakerRef) {
-    var _ref2 = positionProps || {},
-      left = _ref2.left,
-      top = _ref2.top,
-      className = _ref2.className;
-    var styles = _extends({}, DEPRECATED_menuStyle, popupStyle, {
-      left: left,
-      top: top
-    });
-    var classes = merge(className, DEPRECATED_menuClassName, popupClassName, prefix('popup-cascader'));
+  const renderTreeView = (positionProps, speakerRef) => {
+    const {
+      left,
+      top,
+      className
+    } = positionProps || {};
+    const styles = {
+      ...DEPRECATED_menuStyle,
+      ...popupStyle,
+      left,
+      top
+    };
+    const classes = merge(className, DEPRECATED_menuClassName, popupClassName, prefix('popup-cascader'));
     return /*#__PURE__*/React.createElement(PickerPopup, {
       ref: mergeRefs(overlay, speakerRef),
       className: classes,
@@ -356,18 +340,18 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
       renderTreeNode: renderCascadeTreeNode
     }), renderExtraFooter === null || renderExtraFooter === void 0 ? void 0 : renderExtraFooter());
   };
-  var selectedElement = placeholder;
+  let selectedElement = placeholder;
   if (pathTowardsSelectedItem.length > 0) {
     selectedElement = [];
-    pathTowardsSelectedItem.forEach(function (item, index) {
-      var key = item[valueKey] || item[labelKey];
+    pathTowardsSelectedItem.forEach((item, index) => {
+      const key = item[valueKey] || item[labelKey];
       selectedElement.push(/*#__PURE__*/React.createElement("span", {
         key: key
       }, item[labelKey]));
       if (index < pathTowardsSelectedItem.length - 1) {
         selectedElement.push(/*#__PURE__*/React.createElement("span", {
           className: "separator",
-          key: key + "-separator"
+          key: `${key}-separator`
         }, ' / '));
       }
     });
@@ -379,15 +363,14 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
       hasValue = false;
     }
   }
-  var _usePickerClassName = usePickerClassName(_extends({}, props, {
-      classPrefix: classPrefix,
-      hasValue: hasValue,
-      name: 'cascader',
-      appearance: appearance,
-      cleanable: cleanable
-    })),
-    classes = _usePickerClassName[0],
-    usedClassNamePropKeys = _usePickerClassName[1];
+  const [classes, usedClassNamePropKeys] = usePickerClassName({
+    ...props,
+    classPrefix,
+    hasValue,
+    name: 'cascader',
+    appearance,
+    cleanable
+  });
   return /*#__PURE__*/React.createElement(PickerToggleTrigger, {
     id: id,
     popupType: "tree",
@@ -401,7 +384,7 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
     className: classes,
     style: style,
     ref: root
-  }, /*#__PURE__*/React.createElement(PickerToggle, _extends({}, omit(rest, [].concat(omitTriggerPropKeys, usedClassNamePropKeys)), {
+  }, /*#__PURE__*/React.createElement(PickerToggle, _extends({}, omit(rest, [...omitTriggerPropKeys, ...usedClassNamePropKeys]), {
     ref: target,
     as: toggleAs,
     appearance: appearance,
@@ -417,24 +400,4 @@ var Cascader = /*#__PURE__*/React.forwardRef(function (props, ref) {
   }), selectedElement || (locale === null || locale === void 0 ? void 0 : locale.placeholder))));
 });
 Cascader.displayName = 'Cascader';
-Cascader.propTypes = _extends({}, listPickerPropTypes, {
-  disabledItemValues: PropTypes.array,
-  locale: PropTypes.any,
-  appearance: oneOf(['default', 'subtle']),
-  onSelect: PropTypes.func,
-  onSearch: PropTypes.func,
-  cleanable: PropTypes.bool,
-  renderColumn: PropTypes.func,
-  renderTreeNode: PropTypes.func,
-  renderSearchItem: PropTypes.func,
-  columnWidth: PropTypes.number,
-  columnHeight: PropTypes.number,
-  searchable: PropTypes.bool,
-  parentSelectable: PropTypes.bool,
-  inline: deprecatePropTypeNew(PropTypes.bool, 'Use `<CascadeTree>` instead.'),
-  renderMenu: deprecatePropTypeNew(PropTypes.func, 'Use "renderColumn" property instead.'),
-  renderMenuItem: deprecatePropTypeNew(PropTypes.func, 'Use "renderTreeNode" property instead.'),
-  menuWidth: deprecatePropTypeNew(PropTypes.number, 'Use "columnWidth" property instead.'),
-  menuHeight: deprecatePropTypeNew(PropTypes.number, 'Use "columnHeight" property instead.')
-});
 export default Cascader;

package/esm/Cascader/useActive.js

@@ -1,18 +1,18 @@
 'use client';
 import { useState } from 'react';
 import { useEventCallback } from "../internals/hooks/index.js";
-var useActive = function useActive(props) {
-  var onOpen = props.onOpen,
-    onClose = props.onClose,
-    onEntered = props.onEntered,
-    onExited = props.onExited,
-    target = props.target,
-    setSearchKeyword = props.setSearchKeyword;
+const useActive = props => {
+  const {
+    onOpen,
+    onClose,
+    onEntered,
+    onExited,
+    target,
+    setSearchKeyword
+  } = props;
   // Use component active state to support keyboard events.
-  var _useState = useState(false),
-    active = _useState[0],
-    setActive = _useState[1];
-  var handleEntered = useEventCallback(function (node) {
+  const [active, setActive] = useState(false);
+  const handleEntered = useEventCallback(node => {
     onEntered === null || onEntered === void 0 || onEntered(node);
     if (!target.current) {
       return;
@@ -20,7 +20,7 @@ var useActive = function useActive(props) {
     onOpen === null || onOpen === void 0 || onOpen();
     setActive(true);
   });
-  var handleExited = useEventCallback(function (node) {
+  const handleExited = useEventCallback(node => {
     onExited === null || onExited === void 0 || onExited(node);
     if (!target.current) {
       return;
@@ -30,9 +30,9 @@ var useActive = function useActive(props) {
     setSearchKeyword('');
   });
   return {
-    active: active,
-    handleEntered: handleEntered,
-    handleExited: handleExited
+    active,
+    handleEntered,
+    handleExited
   };
 };
 export default useActive;

package/esm/CheckPicker/CheckPicker.d.ts

@@ -15,7 +15,6 @@ export interface CheckPickerComponent {
         ref?: React.Ref<PickerHandle>;
     }): JSX.Element | null;
     displayName?: string;
-    propTypes?: React.WeakValidationMap<CheckPickerProps<any>>;
 }
 /**
  * A component for selecting checkable items in a dropdown list.