rsuite 5.60.2 → 5.62.0

package/cjs/CheckTree/hooks/useTreeCheckState.d.ts

@@ -0,0 +1,10 @@
+import type { TreeNodeMap } from '@/internals/Tree/types';
+interface Props {
+    cascade?: boolean;
+    flattenedNodes: TreeNodeMap;
+    uncheckableItemValues: (string | number)[];
+}
+declare function useTreeCheckState(props: Props): {
+    getCheckedValues: (...args: any[]) => any;
+};
+export default useTreeCheckState;

package/cjs/CheckTree/hooks/useTreeCheckState.js

@@ -0,0 +1,93 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+var _hooks = require("../../internals/hooks");
+var _TreeProvider = require("../../internals/Tree/TreeProvider");
+var _utils = require("../utils");
+function useTreeCheckState(props) {
+  var cascade = props.cascade,
+    flattenedNodes = props.flattenedNodes,
+    uncheckableItemValues = props.uncheckableItemValues;
+  var _useItemDataKeys = (0, _TreeProvider.useItemDataKeys)(),
+    valueKey = _useItemDataKeys.valueKey,
+    childrenKey = _useItemDataKeys.childrenKey;
+  var checkParentNode = (0, _hooks.useEventCallback)(function (nodes, node, checked) {
+    var currentNode = node.refKey ? nodes[node.refKey] : null;
+    if (cascade && currentNode) {
+      if (!checked) {
+        currentNode.check = checked;
+        currentNode.checkAll = checked;
+      } else {
+        if ((0, _utils.isEveryChildChecked)(currentNode, {
+          nodes: nodes,
+          childrenKey: childrenKey
+        })) {
+          currentNode.check = true;
+          currentNode.checkAll = true;
+        } else {
+          currentNode.check = false;
+          currentNode.checkAll = false;
+        }
+      }
+      if (currentNode.parent) {
+        checkParentNode(nodes, currentNode.parent, checked);
+      }
+    }
+  });
+  var checkChildNode = (0, _hooks.useEventCallback)(function (nodes, node, isChecked) {
+    var currentNode = node.refKey ? nodes[node.refKey] : null;
+    if (!currentNode) {
+      return;
+    }
+    currentNode.check = isChecked;
+    if (!currentNode[childrenKey] || !currentNode[childrenKey].length || !cascade) {
+      currentNode.checkAll = false;
+    } else {
+      currentNode.checkAll = isChecked;
+      currentNode[childrenKey].forEach(function (child) {
+        checkChildNode(nodes, child, isChecked);
+      });
+    }
+  });
+  var getCheckedValuesByParent = (0, _react.useCallback)(function (nodes) {
+    var values = [];
+    for (var key in nodes) {
+      var currentNode = nodes[key];
+      if (!(0, _isNil.default)(currentNode.parent) && !(0, _isNil.default)(currentNode.parent.refKey)) {
+        var parentNode = nodes[currentNode.parent.refKey];
+        if (currentNode.check) {
+          if (!(parentNode !== null && parentNode !== void 0 && parentNode.checkAll)) {
+            values.push(currentNode[valueKey]);
+          } else if (parentNode !== null && parentNode !== void 0 && parentNode.uncheckable) {
+            values.push(currentNode[valueKey]);
+          }
+        }
+      } else if (currentNode.check) {
+        values.push(currentNode[valueKey]);
+      }
+    }
+    return values;
+  }, [valueKey]);
+  var getCheckedValues = (0, _hooks.useEventCallback)(function (node, isChecked) {
+    var nodes = (0, _cloneDeep.default)(flattenedNodes);
+    checkChildNode(nodes, node, isChecked);
+    if (node.parent) {
+      checkParentNode(nodes, node.parent, isChecked);
+    }
+    var values = getCheckedValuesByParent(nodes);
+    return values.filter(function (v) {
+      return !uncheckableItemValues.includes(v);
+    });
+  });
+  return {
+    getCheckedValues: getCheckedValues
+  };
+}
+var _default = useTreeCheckState;
+exports.default = _default;

package/cjs/CheckTree/hooks/useTreeNodeProps.d.ts

@@ -0,0 +1,22 @@
+import type { TreeNode } from '@/internals/Tree/types';
+interface Props {
+    uncheckableItemValues: any[];
+    disabledItemValues: any[];
+    loadingNodeValues: any[];
+    focusItemValue: any;
+    flattenedNodes: any;
+    keyword: string;
+}
+declare function useTreeNodeProps(props: Props): (nodeData: TreeNode) => {
+    value: any;
+    label: any;
+    visible: boolean | undefined;
+    loading: boolean;
+    disabled: boolean;
+    nodeData: TreeNode;
+    checkState: import("../../internals/constants").CheckStateType | undefined;
+    uncheckable: boolean;
+    allUncheckable: boolean;
+    focus: boolean;
+};
+export default useTreeNodeProps;

package/cjs/CheckTree/hooks/useTreeNodeProps.js

@@ -0,0 +1,59 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _utils = require("../utils");
+var _TreeProvider = require("../../internals/Tree/TreeProvider");
+var _Highlight = _interopRequireDefault(require("../../Highlight"));
+function useTreeNodeProps(props) {
+  var _useItemDataKeys = (0, _TreeProvider.useItemDataKeys)(),
+    valueKey = _useItemDataKeys.valueKey,
+    labelKey = _useItemDataKeys.labelKey;
+  var uncheckableItemValues = props.uncheckableItemValues,
+    disabledItemValues = props.disabledItemValues,
+    loadingNodeValues = props.loadingNodeValues,
+    focusItemValue = props.focusItemValue,
+    flattenedNodes = props.flattenedNodes,
+    keyword = props.keyword;
+  return (0, _react.useCallback)(function (nodeData) {
+    var visible = nodeData.visible,
+      checkState = nodeData.checkState;
+    var value = nodeData[valueKey];
+    var nodeLabel = nodeData[labelKey];
+    var allUncheckable = (0, _utils.isAllSiblingNodeUncheckable)(nodeData, flattenedNodes, uncheckableItemValues, valueKey);
+    var label = keyword ? /*#__PURE__*/_react.default.createElement(_Highlight.default, {
+      as: "span",
+      query: keyword
+    }, nodeLabel) : nodeLabel;
+    var disabled = (0, _utils.getDisabledState)(flattenedNodes, nodeData, {
+      disabledItemValues: disabledItemValues,
+      valueKey: valueKey
+    });
+    var uncheckable = (0, _utils.isNodeUncheckable)(nodeData, {
+      uncheckableItemValues: uncheckableItemValues,
+      valueKey: valueKey
+    });
+    var loading = loadingNodeValues.some(function (item) {
+      return item === nodeData[valueKey];
+    });
+    var focus = focusItemValue === value;
+    return {
+      value: value,
+      label: label,
+      visible: visible,
+      loading: loading,
+      disabled: disabled,
+      nodeData: nodeData,
+      checkState: checkState,
+      uncheckable: uncheckable,
+      allUncheckable: allUncheckable,
+      focus: focus
+    };
+  }, [valueKey, flattenedNodes, uncheckableItemValues, keyword, labelKey, disabledItemValues, loadingNodeValues, focusItemValue]);
+}
+var _default = useTreeNodeProps;
+exports.default = _default;

package/cjs/CheckTree/hooks/useTreeValue.d.ts

@@ -0,0 +1,5 @@
+declare function useTreeValue(controlledValue: any, { defaultValue, uncheckableItemValues }: {
+    defaultValue: any;
+    uncheckableItemValues: any;
+}): any[];
+export default useTreeValue;

package/cjs/CheckTree/hooks/useTreeValue.js

@@ -0,0 +1,21 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _hooks = require("../../internals/hooks");
+var _utils = require("../utils");
+function useTreeValue(controlledValue, _ref) {
+  var defaultValue = _ref.defaultValue,
+    uncheckableItemValues = _ref.uncheckableItemValues;
+  var _useControlled = (0, _hooks.useControlled)(controlledValue, defaultValue),
+    value = _useControlled[0],
+    setValue = _useControlled[1],
+    isControlled = _useControlled[2];
+  (0, _hooks.useMount)(function () {
+    setValue((0, _utils.getCheckTreeDefaultValue)(value, uncheckableItemValues));
+  });
+  return [value, setValue, isControlled];
+}
+var _default = useTreeValue;
+exports.default = _default;

package/cjs/CheckTree/index.d.ts

@@ -1,15 +1,3 @@
-import { FormControlPickerProps, RsRefForwardingComponent } from '../@types/common';
-import { ValueType } from '../CheckTreePicker';
-import { TreeBaseProps } from '../Tree/Tree';
-export interface CheckTreeProps extends TreeBaseProps<ValueType>, FormControlPickerProps<ValueType> {
-    /** Tree node cascade */
-    cascade?: boolean;
-    /** Set the option value for the check box not to be rendered */
-    uncheckableItemValues?: ValueType;
-}
-/**
- * The `CheckTree` component is used for selecting multiple options which are organized in a tree structure.
- * @see https://rsuitejs.com/components/check-tree
- */
-declare const CheckTree: RsRefForwardingComponent<'div', CheckTreeProps>;
+import CheckTree from './CheckTree';
+export type { CheckTreeProps, ValueType } from './CheckTree';
 export default CheckTree;

package/cjs/CheckTree/index.js

@@ -1,30 +1,9 @@
 'use client';
 "use strict";
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 exports.__esModule = true;
 exports.default = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _react = _interopRequireWildcard(require("react"));
-var _CheckTreePicker = _interopRequireDefault(require("../CheckTreePicker"));
-var _TreeContext = _interopRequireDefault(require("../Tree/TreeContext"));
-/**
- * The `CheckTree` component is used for selecting multiple options which are organized in a tree structure.
- * @see https://rsuitejs.com/components/check-tree
- */
-var CheckTree = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {
-  var contextValue = (0, _react.useMemo)(function () {
-    return {
-      inline: true
-    };
-  }, []);
-  return /*#__PURE__*/_react.default.createElement(_TreeContext.default.Provider, {
-    value: contextValue
-  }, /*#__PURE__*/_react.default.createElement(_CheckTreePicker.default, (0, _extends2.default)({
-    ref: ref
-  }, props)));
-});
-CheckTree.displayName = 'CheckTree';
-var _default = CheckTree;
+var _CheckTree = _interopRequireDefault(require("./CheckTree"));
+var _default = _CheckTree.default;
 exports.default = _default;

package/cjs/CheckTree/utils.d.ts

@@ -0,0 +1,53 @@
+import { CheckTreeProps, ValueType } from './CheckTree';
+import { CheckStateType } from '@/internals/constants';
+import { TreeNode, TreeNodeMap } from '@/internals/Tree/types';
+/**
+ * Checks if every child of a given parent node is checked.
+ */
+export declare function isEveryChildChecked(parent: TreeNode, options: {
+    nodes: TreeNodeMap;
+    childrenKey: string;
+}): boolean;
+/**
+ * Checks if any child node is checked.
+ */
+export declare function isSomeChildChecked(nodes: TreeNodeMap, parent: TreeNode, childrenKey: string): boolean;
+/**
+ * Checks if any node in the data has a grandchild.
+ */
+export declare function hasGrandchild(data: any[], childrenKey: string): boolean;
+/**
+ * Checks if all sibling nodes of a given node are uncheckable.
+ */
+export declare function isAllSiblingNodeUncheckable(node: TreeNode, nodes: TreeNodeMap, uncheckableItemValues: (string | number)[], valueKey: string): boolean;
+/**
+ * Checks if every first-level node is uncheckable based on the provided criteria.
+ */
+export declare function isEveryFirstLevelNodeUncheckable(nodes: TreeNodeMap, uncheckableItemValues: (string | number)[], valueKey: string): boolean;
+/**
+ * Checks if a node is uncheckable.
+ */
+export declare function isNodeUncheckable(node: any, props: Required<Pick<CheckTreeProps, 'uncheckableItemValues' | 'valueKey'>>): boolean;
+export declare function getFormattedTree(nodes: TreeNodeMap, data: any[], props: Required<Pick<CheckTreeProps, 'childrenKey' | 'cascade'>>): any[];
+/**
+ * Determines the disabled state of a tree node.
+ */
+export declare function getDisabledState(nodes: TreeNodeMap, node: TreeNode, props: Required<Pick<CheckTreeProps, 'disabledItemValues' | 'valueKey'>>): boolean;
+/**
+ * Returns the default value for the check tree.
+ */
+export declare function getCheckTreeDefaultValue<T = any>(value: T, uncheckableItemValues: T): any[];
+/**
+ * Retrieves the selected items from the given nodes.
+ */
+export declare function getSelectedItems(nodes: TreeNodeMap, values: ValueType): TreeNode[];
+interface NodeCheckStateOptions {
+    nodes: TreeNodeMap;
+    cascade: boolean;
+    childrenKey: string;
+}
+/**
+ * Calculates the check state of a node in a check tree.
+ */
+export declare function getNodeCheckState(node: TreeNode, options: NodeCheckStateOptions): CheckStateType;
+export {};

package/cjs/{CheckTreePicker → CheckTree}/utils.js

@@ -5,56 +5,89 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 exports.__esModule = true;
 exports.isEveryChildChecked = isEveryChildChecked;
 exports.isSomeChildChecked = isSomeChildChecked;
-exports.isSomeNodeHasChildren = isSomeNodeHasChildren;
+exports.hasGrandchild = hasGrandchild;
 exports.isAllSiblingNodeUncheckable = isAllSiblingNodeUncheckable;
 exports.isEveryFirstLevelNodeUncheckable = isEveryFirstLevelNodeUncheckable;
 exports.isNodeUncheckable = isNodeUncheckable;
 exports.getFormattedTree = getFormattedTree;
 exports.getDisabledState = getDisabledState;
-exports.getCheckTreePickerDefaultValue = getCheckTreePickerDefaultValue;
+exports.getCheckTreeDefaultValue = getCheckTreeDefaultValue;
 exports.getSelectedItems = getSelectedItems;
 exports.getNodeCheckState = getNodeCheckState;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
 var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
-var _utils = require("../utils");
-var _treeUtils = require("../utils/treeUtils");
-var _attachParent = require("../utils/attachParent");
-function isEveryChildChecked(nodes, parent) {
+var _constants = require("../internals/constants");
+var _utils = require("../internals/utils");
+var _utils2 = require("../Tree/utils");
+/**
+ * Retrieves the children of a given parent node from a flattened node map.
+ */
+function getChildrenByFlattenNodes(nodes, parent) {
+  if (!(0, _isNil2.default)(parent.refKey) && (0, _isNil2.default)(nodes[parent.refKey])) {
+    return [];
+  }
+  return Object.values(nodes).filter(function (item) {
+    var _item$parent;
+    return (item === null || item === void 0 ? void 0 : (_item$parent = item.parent) === null || _item$parent === void 0 ? void 0 : _item$parent.refKey) === parent.refKey && item.refKey && !nodes[item.refKey].uncheckable;
+  });
+}
+
+/**
+ * Checks if every child of a given parent node is checked.
+ */
+function isEveryChildChecked(parent, options) {
+  var nodes = options.nodes,
+    childrenKey = options.childrenKey;
   if ((0, _isNil2.default)(parent.refKey) || (0, _isNil2.default)(nodes[parent.refKey])) {
     return false;
   }
-  var children = (0, _treeUtils.getChildrenByFlattenNodes)(nodes, parent);
+  var children = getChildrenByFlattenNodes(nodes, parent);
   if (!children.length) {
     var _nodes$parent$refKey$;
     return (_nodes$parent$refKey$ = nodes[parent.refKey].check) !== null && _nodes$parent$refKey$ !== void 0 ? _nodes$parent$refKey$ : false;
   }
   return children.every(function (child) {
+    var _child$childrenKey;
+    if ((child === null || child === void 0 ? void 0 : (_child$childrenKey = child[childrenKey]) === null || _child$childrenKey === void 0 ? void 0 : _child$childrenKey.length) > 0) {
+      // fix: #3559
+      return isEveryChildChecked(child, {
+        nodes: nodes,
+        childrenKey: childrenKey
+      });
+    }
     return !(0, _isNil2.default)(child.refKey) && nodes[child.refKey].check;
   });
 }
+
+/**
+ * Checks if any child node is checked.
+ */
 function isSomeChildChecked(nodes, parent, childrenKey) {
   if (!(0, _isNil2.default)(parent.refKey) && (0, _isNil2.default)(nodes[parent.refKey])) {
     return false;
   }
-  var children = (0, _treeUtils.getChildrenByFlattenNodes)(nodes, parent);
+  var children = getChildrenByFlattenNodes(nodes, parent);
   return children.some(function (child) {
-    var _child$childrenKey;
-    if ((child === null || child === void 0 ? void 0 : (_child$childrenKey = child[childrenKey]) === null || _child$childrenKey === void 0 ? void 0 : _child$childrenKey.length) > 0) {
+    var _child$childrenKey2;
+    if ((child === null || child === void 0 ? void 0 : (_child$childrenKey2 = child[childrenKey]) === null || _child$childrenKey2 === void 0 ? void 0 : _child$childrenKey2.length) > 0) {
       return isSomeChildChecked(nodes, child, childrenKey);
     }
     return !(0, _isNil2.default)(child.refKey) && nodes[child.refKey].check;
   });
 }
-function isSomeNodeHasChildren(data, childrenKey) {
+
+/**
+ * Checks if any node in the data has a grandchild.
+ */
+function hasGrandchild(data, childrenKey) {
   return data.some(function (node) {
     return Array.isArray(node[childrenKey]);
   });
 }
 
 /**
- * is all siblings nodes is uncheckable
- * @param {*} node
+ * Checks if all sibling nodes of a given node are uncheckable.
  */
 function isAllSiblingNodeUncheckable(node, nodes, uncheckableItemValues, valueKey) {
   var list = [];
@@ -77,7 +110,7 @@ function isAllSiblingNodeUncheckable(node, nodes, uncheckableItemValues, valueKe
 }
 
 /**
- * get each first level node uncheckable state
+ * Checks if every first-level node is uncheckable based on the provided criteria.
  */
 function isEveryFirstLevelNodeUncheckable(nodes, uncheckableItemValues, valueKey) {
   var list = [];
@@ -96,8 +129,7 @@ function isEveryFirstLevelNodeUncheckable(nodes, uncheckableItemValues, valueKey
 }
 
 /**
- * get node uncheckable state
- * @param {*} node
+ * Checks if a node is uncheckable.
  */
 function isNodeUncheckable(node, props) {
   var _props$uncheckableIte = props.uncheckableItemValues,
@@ -115,16 +147,14 @@ function getFormattedTree(nodes, data, props) {
     var curNode = nodes[node.refKey];
     if (curNode) {
       var _node$childrenKey;
-      var checkState = !(0, _isUndefined2.default)(cascade) ? getNodeCheckState({
-        node: curNode,
+      var checkState = !(0, _isUndefined2.default)(cascade) ? getNodeCheckState(curNode, {
         cascade: cascade,
         nodes: nodes,
         childrenKey: childrenKey
       }) : undefined;
       formatted.check = curNode.check;
-      formatted.expand = curNode.expand;
       formatted.uncheckable = curNode.uncheckable;
-      (0, _attachParent.attachParent)(formatted, curNode.parent);
+      (0, _utils.attachParent)(formatted, curNode.parent);
       formatted.checkState = checkState;
       if (((_node$childrenKey = node[childrenKey]) === null || _node$childrenKey === void 0 ? void 0 : _node$childrenKey.length) > 0) {
         formatted[childrenKey] = getFormattedTree(nodes, formatted[childrenKey], props);
@@ -133,6 +163,10 @@ function getFormattedTree(nodes, data, props) {
     return formatted;
   });
 }
+
+/**
+ * Determines the disabled state of a tree node.
+ */
 function getDisabledState(nodes, node, props) {
   var _props$disabledItemVa = props.disabledItemValues,
     disabledItemValues = _props$disabledItemVa === void 0 ? [] : _props$disabledItemVa,
@@ -144,18 +178,26 @@ function getDisabledState(nodes, node, props) {
     return node.refKey && nodes[node.refKey][valueKey] === value;
   });
 }
-function getCheckTreePickerDefaultValue(value, uncheckableItemValues) {
-  if (Array.isArray(value)) {
+
+/**
+ * Returns the default value for the check tree.
+ */
+function getCheckTreeDefaultValue(value, uncheckableItemValues) {
+  if (Array.isArray(value) && Array.isArray(uncheckableItemValues)) {
     return value.filter(function (v) {
       return !uncheckableItemValues.includes(v);
     });
   }
   return [];
 }
+
+/**
+ * Retrieves the selected items from the given nodes.
+ */
 function getSelectedItems(nodes, values) {
   var checkedItems = [];
   values.forEach(function (value) {
-    var refKey = (0, _treeUtils.getNodeFormattedRefKey)(value);
+    var refKey = (0, _utils2.formatNodeRefKey)(value);
     var node = nodes[refKey];
     if (!(0, _isNil2.default)(node)) {
       checkedItems.push(node);
@@ -163,26 +205,34 @@ function getSelectedItems(nodes, values) {
   });
   return checkedItems;
 }
-function getNodeCheckState(_ref) {
-  var nodes = _ref.nodes,
-    node = _ref.node,
-    cascade = _ref.cascade,
-    childrenKey = _ref.childrenKey;
+/**
+ * Calculates the check state of a node in a check tree.
+ */
+function getNodeCheckState(node, options) {
+  var nodes = options.nodes,
+    cascade = options.cascade,
+    childrenKey = options.childrenKey;
+  if (node.refKey === undefined) {
+    return _constants.CHECK_STATE.UNCHECK;
+  }
   if ((0, _isNil2.default)(nodes[node.refKey])) {
-    return _utils.CHECK_STATE.UNCHECK;
+    return _constants.CHECK_STATE.UNCHECK;
   }
   if (!node[childrenKey] || !node[childrenKey].length || !cascade) {
     nodes[node.refKey].checkAll = false;
-    return node.check ? _utils.CHECK_STATE.CHECK : _utils.CHECK_STATE.UNCHECK;
+    return node.check ? _constants.CHECK_STATE.CHECK : _constants.CHECK_STATE.UNCHECK;
   }
-  if (isEveryChildChecked(nodes, node)) {
+  if (isEveryChildChecked(node, {
+    nodes: nodes,
+    childrenKey: childrenKey
+  })) {
     nodes[node.refKey].checkAll = true;
     nodes[node.refKey].check = true;
-    return _utils.CHECK_STATE.CHECK;
+    return _constants.CHECK_STATE.CHECK;
   }
   if (isSomeChildChecked(nodes, node, childrenKey)) {
     nodes[node.refKey].checkAll = false;
-    return _utils.CHECK_STATE.INDETERMINATE;
+    return _constants.CHECK_STATE.INDETERMINATE;
   }
-  return _utils.CHECK_STATE.UNCHECK;
+  return _constants.CHECK_STATE.UNCHECK;
 }

package/cjs/CheckTreePicker/CheckTreePicker.d.ts

@@ -1,20 +1,38 @@
 import React from 'react';
 import { PickerLocale } from '../locales';
-import { PickerComponent, PickerToggleProps } from '../internals/Picker';
-import { TreeBaseProps } from '../Tree/Tree';
-import { FormControlPickerProps, ItemDataType } from '../@types/common';
+import { PickerComponent, PickerToggleProps } from '@/internals/Picker';
+import { type CheckTreeViewProps } from '../CheckTree/CheckTreeView';
+import type { TreeNode } from '@/internals/Tree/types';
+import type { FormControlPickerProps, ItemDataType, DeprecatedPickerProps } from '@/internals/types';
+import type { TreeExtraProps } from '../Tree/types';
 export declare type ValueType = (string | number)[];
-export interface CheckTreePickerProps<T = ValueType> extends TreeBaseProps<T, ItemDataType>, FormControlPickerProps<T, PickerLocale, ItemDataType>, Pick<PickerToggleProps, 'caretAs' | 'loading'> {
-    /** Tree node cascade */
-    cascade?: boolean;
-    /** A picker that can be counted */
+export interface CheckTreePickerProps<V = ValueType> extends Omit<CheckTreeViewProps<V>, 'value' | 'onChange' | 'data'>, TreeExtraProps, DeprecatedPickerProps, FormControlPickerProps<V, PickerLocale, ItemDataType>, Pick<PickerToggleProps, 'caretAs' | 'loading'> {
+    /**
+     * A picker that can be counted
+     */
     countable?: boolean;
-    /** Set the option value for the check box not to be rendered */
-    uncheckableItemValues?: T;
-    /** Custom render selected items */
-    renderValue?: (value: any[], selectedItems: any[], selectedElement: React.ReactNode) => React.ReactNode;
-    /** Called when scrolling */
-    onScroll?: (event: React.SyntheticEvent) => void;
+    /**
+     * Custom popup style
+     */
+    popupClassName?: string;
+    /**
+     * Custom popup style
+     */
+    popupStyle?: React.CSSProperties;
+    /**
+     * The height of the tree
+     */
+    treeHeight?: number;
+    /**
+     * Popup auto width
+     *
+     * @default true
+     */
+    popupAutoWidth?: boolean;
+    /**
+     * Custom render selected items
+     */
+    renderValue?: (value: V, selectedNodes: TreeNode[], selectedElement: React.ReactNode) => React.ReactNode;
 }
 /**
  * The `CheckTreePicker` component is used for selecting multiple options which are organized in a tree structure.