rsuite 5.60.1 → 5.61.0

package/esm/CheckTree/CheckTreeView.js

@@ -0,0 +1,304 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React, { useEffect, useMemo } from 'react';
+import isNil from 'lodash/isNil';
+import { List, AutoSizer, defaultItemSize } from '../internals/Windowing';
+import CheckTreeNode from './CheckTreeNode';
+import IndentLine from '../Tree/IndentLine';
+import { useCustom, useClassNames, useEventCallback } from '../utils';
+import { getPathTowardsItem, getKeyParentMap } from '../internals/Tree/utils';
+import { onMenuKeyDown } from '../internals/Picker';
+import { TreeView } from '../internals/Tree';
+import SearchBox from '../internals/SearchBox';
+import { hasGrandchild, isEveryFirstLevelNodeUncheckable, getFormattedTree, isNodeUncheckable } from './utils';
+import { hasVisibleChildren, getActiveItem, isExpand } from '../Tree/utils';
+import useTreeSearch from '../Tree/hooks/useTreeSearch';
+import useFocusTree from '../Tree/hooks/useFocusTree';
+import useVirtualizedTreeData from '../Tree/hooks/useVirtualizedTreeData';
+import useTreeCheckState from './hooks/useTreeCheckState';
+import useTreeNodeProps from './hooks/useTreeNodeProps';
+import { useItemDataKeys } from '../Tree/TreeProvider';
+
+/**
+ * Props for the CheckTreeView component.
+ */
+
+var CheckTreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _merge2;
+  var _props$as = props.as,
+    Component = _props$as === void 0 ? 'div' : _props$as,
+    className = props.className,
+    _props$classPrefix = props.classPrefix,
+    classPrefix = _props$classPrefix === void 0 ? 'check-tree' : _props$classPrefix,
+    _props$cascade = props.cascade,
+    cascade = _props$cascade === void 0 ? true : _props$cascade,
+    _props$data = props.data,
+    data = _props$data === void 0 ? [] : _props$data,
+    _props$disabledItemVa = props.disabledItemValues,
+    disabledItemValues = _props$disabledItemVa === void 0 ? [] : _props$disabledItemVa,
+    _props$expandItemValu = props.expandItemValues,
+    expandItemValues = _props$expandItemValu === void 0 ? [] : _props$expandItemValu,
+    _props$height = props.height,
+    height = _props$height === void 0 ? 360 : _props$height,
+    overrideLocale = props.locale,
+    listProps = props.listProps,
+    listRef = props.listRef,
+    style = props.style,
+    searchKeyword = props.searchKeyword,
+    showIndentLine = props.showIndentLine,
+    searchable = props.searchable,
+    searchInputRef = props.searchInputRef,
+    _props$uncheckableIte = props.uncheckableItemValues,
+    uncheckableItemValues = _props$uncheckableIte === void 0 ? [] : _props$uncheckableIte,
+    _props$virtualized = props.virtualized,
+    virtualized = _props$virtualized === void 0 ? false : _props$virtualized,
+    _props$loadingNodeVal = props.loadingNodeValues,
+    loadingNodeValues = _props$loadingNodeVal === void 0 ? [] : _props$loadingNodeVal,
+    _props$flattenedNodes = props.flattenedNodes,
+    flattenedNodes = _props$flattenedNodes === void 0 ? {} : _props$flattenedNodes,
+    searchBy = props.searchBy,
+    onChange = props.onChange,
+    onSearch = props.onSearch,
+    onSelect = props.onSelect,
+    onSelectItem = props.onSelectItem,
+    onScroll = props.onScroll,
+    onExpand = props.onExpand,
+    onFocusItem = props.onFocusItem,
+    rest = _objectWithoutPropertiesLoose(props, ["as", "className", "classPrefix", "cascade", "data", "disabledItemValues", "expandItemValues", "height", "locale", "listProps", "listRef", "style", "searchKeyword", "showIndentLine", "searchable", "searchInputRef", "uncheckableItemValues", "virtualized", "loadingNodeValues", "flattenedNodes", "searchBy", "onChange", "onSearch", "onSelect", "onSelectItem", "onScroll", "onExpand", "onFocusItem"]);
+  var _useCustom = useCustom('Picker', overrideLocale),
+    locale = _useCustom.locale;
+  var _useItemDataKeys = useItemDataKeys(),
+    childrenKey = _useItemDataKeys.childrenKey,
+    valueKey = _useItemDataKeys.valueKey;
+  var _useClassNames = useClassNames(classPrefix),
+    prefix = _useClassNames.prefix,
+    merge = _useClassNames.merge,
+    withClassPrefix = _useClassNames.withClassPrefix;
+  var _useTreeCheckState = useTreeCheckState({
+      cascade: cascade,
+      flattenedNodes: flattenedNodes,
+      uncheckableItemValues: uncheckableItemValues
+    }),
+    getCheckedValues = _useTreeCheckState.getCheckedValues;
+  var handleSearchCallback = function handleSearchCallback(value, _data, event) {
+    onSearch === null || onSearch === void 0 ? void 0 : onSearch(value, event);
+  };
+  var _useTreeSearch = useTreeSearch({
+      callback: handleSearchCallback,
+      data: data,
+      searchKeyword: searchKeyword,
+      searchBy: searchBy
+    }),
+    filteredData = _useTreeSearch.filteredData,
+    keyword = _useTreeSearch.keyword,
+    setFilteredData = _useTreeSearch.setFilteredData,
+    handleSearch = _useTreeSearch.handleSearch;
+  var _useFocusTree = useFocusTree({
+      filteredData: filteredData,
+      disabledItemValues: disabledItemValues,
+      expandItemValues: expandItemValues,
+      searchKeyword: keyword,
+      flattenedNodes: flattenedNodes,
+      onFocused: onFocusItem,
+      onExpand: onExpand
+    }),
+    focusItemValue = _useFocusTree.focusItemValue,
+    setFocusItemValue = _useFocusTree.setFocusItemValue,
+    onTreeKeydown = _useFocusTree.onTreeKeydown,
+    saveTreeNodeRef = _useFocusTree.saveTreeNodeRef;
+  var transformation = useVirtualizedTreeData(flattenedNodes, filteredData, {
+    cascade: cascade,
+    expandItemValues: expandItemValues,
+    searchKeyword: keyword
+  });
+
+  /**
+   * Get formatted nodes for render tree
+   * @params render - renderNode function. only used when virtualized setting false
+   */
+  var getFormattedNodes = function getFormattedNodes(render) {
+    if (virtualized) {
+      return transformation().filter(function (item) {
+        return item.visible;
+      });
+    }
+    return getFormattedTree(flattenedNodes, filteredData, {
+      childrenKey: childrenKey,
+      cascade: cascade
+    }).map(function (node) {
+      return render === null || render === void 0 ? void 0 : render(node, 1);
+    }).filter(function (item) {
+      return item;
+    });
+  };
+  var getTreeNodeProps = useTreeNodeProps({
+    uncheckableItemValues: uncheckableItemValues,
+    disabledItemValues: disabledItemValues,
+    loadingNodeValues: loadingNodeValues,
+    focusItemValue: focusItemValue,
+    flattenedNodes: flattenedNodes,
+    keyword: keyword
+  });
+  useEffect(function () {
+    setFilteredData(data, keyword);
+  }, [data, keyword, setFilteredData]);
+
+  // TODO-Doma
+  // Replace `getKeyParentMap` with `getParentMap`
+  var itemParentMap = useMemo(function () {
+    return getKeyParentMap(data, function (node) {
+      return node[valueKey];
+    }, function (node) {
+      return node[childrenKey];
+    });
+  }, [childrenKey, data, valueKey]);
+  var handleSelect = useEventCallback(function (node, event) {
+    var currentNode = node.refKey ? flattenedNodes[node.refKey] : null;
+    if (!node || !currentNode) {
+      return;
+    }
+    var checkedValues = getCheckedValues(node, !currentNode.check);
+    var path = getPathTowardsItem(node, function (item) {
+      return itemParentMap.get(item[valueKey]);
+    });
+    setFocusItemValue(node[valueKey]);
+    onChange === null || onChange === void 0 ? void 0 : onChange(checkedValues, event);
+    onSelect === null || onSelect === void 0 ? void 0 : onSelect(node, checkedValues, event);
+    onSelectItem === null || onSelectItem === void 0 ? void 0 : onSelectItem(node, path);
+  });
+  var selectActiveItem = function selectActiveItem(event) {
+    if (isNil(focusItemValue)) return;
+    var activeItem = getActiveItem(focusItemValue, flattenedNodes, valueKey);
+    if (!isNodeUncheckable(activeItem, {
+      uncheckableItemValues: uncheckableItemValues,
+      valueKey: valueKey
+    }) && activeItem !== null) {
+      handleSelect(activeItem, event);
+    }
+  };
+  var handleTreeKeyDown = useEventCallback(function (event) {
+    onTreeKeydown(event);
+    onMenuKeyDown(event, {
+      enter: selectActiveItem
+    });
+  });
+  var renderNode = function renderNode(node, layer) {
+    var visible = node.visible,
+      refKey = node.refKey,
+      parent = node.parent; // when searching, all nodes should be expand
+    var expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
+    if (!visible) {
+      return null;
+    }
+    var children = node[childrenKey];
+    var hasChildren = keyword ? hasVisibleChildren(node, childrenKey) : Boolean(children);
+    var treeNodeProps = _extends({}, getTreeNodeProps(_extends({}, node, {
+      parent: parent
+    })), {
+      layer: layer,
+      expanded: expanded,
+      hasChildren: hasChildren,
+      onSelect: handleSelect,
+      onExpand: onExpand
+    });
+    if (hasChildren) {
+      var _merge;
+      layer += 1;
+      var childClassName = merge(prefix('node-children'), (_merge = {}, _merge[prefix('node-expanded')] = expanded, _merge));
+      var nodes = children || [];
+      return /*#__PURE__*/React.createElement("div", {
+        className: childClassName,
+        key: node[valueKey]
+      }, /*#__PURE__*/React.createElement(CheckTreeNode, _extends({}, treeNodeProps, {
+        treeItemRef: function treeItemRef(ref) {
+          return saveTreeNodeRef(ref, refKey);
+        }
+      })), /*#__PURE__*/React.createElement("div", {
+        className: prefix('group'),
+        role: "group"
+      }, nodes.map(function (child) {
+        return renderNode(child, layer);
+      }), showIndentLine && /*#__PURE__*/React.createElement(IndentLine, null)));
+    }
+    return /*#__PURE__*/React.createElement(CheckTreeNode, _extends({
+      key: node[valueKey],
+      treeItemRef: function treeItemRef(ref) {
+        return saveTreeNodeRef(ref, refKey);
+      }
+    }, treeNodeProps));
+  };
+  var renderVirtualListNode = function renderVirtualListNode(_ref) {
+    var index = _ref.index,
+      style = _ref.style,
+      data = _ref.data;
+    var node = data[index];
+    var layer = node.layer,
+      refKey = node.refKey,
+      visible = node.visible,
+      hasChildren = node.hasChildren,
+      parent = node.parent;
+    var expanded = isExpand(keyword, expandItemValues.includes(node[valueKey]));
+    var treeNodeProps = _extends({}, getTreeNodeProps(_extends({}, node, {
+      parent: parent
+    })), {
+      onSelect: handleSelect,
+      onExpand: onExpand,
+      expanded: expanded,
+      layer: layer,
+      hasChildren: hasChildren
+    });
+    return visible && /*#__PURE__*/React.createElement(CheckTreeNode, _extends({
+      style: style,
+      ref: function ref(_ref2) {
+        return saveTreeNodeRef(_ref2, refKey);
+      }
+    }, treeNodeProps));
+  };
+  var classes = merge(className, withClassPrefix({
+    'without-children': !hasGrandchild(data, childrenKey),
+    virtualized: virtualized
+  }));
+  var formattedNodes = getFormattedNodes(renderNode);
+  var treeNodesClass = merge(prefix('root'), (_merge2 = {}, _merge2[prefix('all-uncheckable')] = isEveryFirstLevelNodeUncheckable(flattenedNodes, uncheckableItemValues, valueKey), _merge2));
+  return /*#__PURE__*/React.createElement(Component, {
+    ref: ref,
+    className: classes,
+    style: style
+  }, searchable ? /*#__PURE__*/React.createElement(SearchBox, {
+    placeholder: locale.searchPlaceholder,
+    onChange: handleSearch,
+    value: keyword,
+    inputRef: searchInputRef
+  }) : null, keyword && formattedNodes.length === 0 ? /*#__PURE__*/React.createElement("div", {
+    className: prefix('empty')
+  }, locale.noResultsText) : null, /*#__PURE__*/React.createElement(TreeView, _extends({}, rest, {
+    multiselectable: true,
+    treeRootClassName: treeNodesClass,
+    className: prefix('view'),
+    onScroll: onScroll,
+    onKeyDown: handleTreeKeyDown,
+    style: virtualized ? undefined : {
+      height: height
+    }
+  }), virtualized ? /*#__PURE__*/React.createElement(AutoSizer, {
+    defaultHeight: height,
+    style: {
+      width: 'auto',
+      height: 'auto'
+    },
+    className: prefix('virt-auto-sizer')
+  }, function (_ref3) {
+    var height = _ref3.height;
+    return /*#__PURE__*/React.createElement(List, _extends({
+      ref: listRef,
+      height: height,
+      itemSize: defaultItemSize,
+      itemCount: formattedNodes.length,
+      itemData: formattedNodes,
+      className: prefix('virt-list')
+    }, listProps), renderVirtualListNode);
+  }) : formattedNodes));
+});
+CheckTreeView.displayName = 'CheckTreeView';
+export default CheckTreeView;

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

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

package/esm/CheckTree/hooks/useTreeCheckState.js

@@ -0,0 +1,87 @@
+'use client';
+import { useCallback } from 'react';
+import isNil from 'lodash/isNil';
+import cloneDeep from 'lodash/cloneDeep';
+import { useItemDataKeys } from '../../Tree/TreeProvider';
+import { useEventCallback } from '../../utils';
+import { isEveryChildChecked } from '../utils';
+function useTreeCheckState(props) {
+  var cascade = props.cascade,
+    flattenedNodes = props.flattenedNodes,
+    uncheckableItemValues = props.uncheckableItemValues;
+  var _useItemDataKeys = useItemDataKeys(),
+    valueKey = _useItemDataKeys.valueKey,
+    childrenKey = _useItemDataKeys.childrenKey;
+  var checkParentNode = 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 (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 = 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 = useCallback(function (nodes) {
+    var values = [];
+    for (var key in nodes) {
+      var currentNode = nodes[key];
+      if (!isNil(currentNode.parent) && !isNil(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 = useEventCallback(function (node, isChecked) {
+    var nodes = cloneDeep(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
+  };
+}
+export default useTreeCheckState;

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

@@ -0,0 +1,22 @@
+import type { TreeNode } from '../../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("../../utils").CheckStateType | undefined;
+    uncheckable: boolean;
+    allUncheckable: boolean;
+    focus: boolean;
+};
+export default useTreeNodeProps;

package/esm/CheckTree/hooks/useTreeNodeProps.js

@@ -0,0 +1,52 @@
+'use client';
+import React, { useCallback } from 'react';
+import { isAllSiblingNodeUncheckable, getDisabledState, isNodeUncheckable } from '../utils';
+import { useItemDataKeys } from '../../Tree/TreeProvider';
+import Highlight from '../../Highlight';
+function useTreeNodeProps(props) {
+  var _useItemDataKeys = 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 useCallback(function (nodeData) {
+    var visible = nodeData.visible,
+      checkState = nodeData.checkState;
+    var value = nodeData[valueKey];
+    var nodeLabel = nodeData[labelKey];
+    var allUncheckable = isAllSiblingNodeUncheckable(nodeData, flattenedNodes, uncheckableItemValues, valueKey);
+    var label = keyword ? /*#__PURE__*/React.createElement(Highlight, {
+      as: "span",
+      query: keyword
+    }, nodeLabel) : nodeLabel;
+    var disabled = getDisabledState(flattenedNodes, nodeData, {
+      disabledItemValues: disabledItemValues,
+      valueKey: valueKey
+    });
+    var uncheckable = 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]);
+}
+export default useTreeNodeProps;

package/esm/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/esm/CheckTree/hooks/useTreeValue.js

@@ -0,0 +1,16 @@
+'use client';
+import { useControlled, useMount } from '../../utils';
+import { getCheckTreeDefaultValue } from '../utils';
+function useTreeValue(controlledValue, _ref) {
+  var defaultValue = _ref.defaultValue,
+    uncheckableItemValues = _ref.uncheckableItemValues;
+  var _useControlled = useControlled(controlledValue, defaultValue),
+    value = _useControlled[0],
+    setValue = _useControlled[1],
+    isControlled = _useControlled[2];
+  useMount(function () {
+    setValue(getCheckTreeDefaultValue(value, uncheckableItemValues));
+  });
+  return [value, setValue, isControlled];
+}
+export default useTreeValue;

package/esm/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/esm/CheckTree/index.js

@@ -1,23 +1,3 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
-import React, { useMemo } from 'react';
-import CheckTreePicker from '../CheckTreePicker';
-import TreeContext from '../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.forwardRef(function (props, ref) {
-  var contextValue = useMemo(function () {
-    return {
-      inline: true
-    };
-  }, []);
-  return /*#__PURE__*/React.createElement(TreeContext.Provider, {
-    value: contextValue
-  }, /*#__PURE__*/React.createElement(CheckTreePicker, _extends({
-    ref: ref
-  }, props)));
-});
-CheckTree.displayName = 'CheckTree';
+import CheckTree from './CheckTree';
 export default CheckTree;

package/esm/CheckTree/utils.d.ts

@@ -0,0 +1,53 @@
+import { CheckTreeProps, ValueType } from './CheckTree';
+import { CheckStateType } from '../utils';
+import { TreeNode, TreeNodeMap } from '../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 {};