rsuite 5.60.2 → 5.61.0

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

@@ -3,9 +3,27 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import _isUndefined from "lodash/isUndefined";
 import _isNil from "lodash/isNil";
 import { CHECK_STATE } from '../utils';
-import { getChildrenByFlattenNodes, getNodeFormattedRefKey } from '../utils/treeUtils';
+import { formatNodeRefKey } from '../Tree/utils';
 import { attachParent } from '../utils/attachParent';
-export function isEveryChildChecked(nodes, parent) {
+/**
+ * Retrieves the children of a given parent node from a flattened node map.
+ */
+function getChildrenByFlattenNodes(nodes, parent) {
+  if (!_isNil(parent.refKey) && _isNil(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.
+ */
+export function isEveryChildChecked(parent, options) {
+  var nodes = options.nodes,
+    childrenKey = options.childrenKey;
   if (_isNil(parent.refKey) || _isNil(nodes[parent.refKey])) {
     return false;
   }
@@ -15,31 +33,46 @@ export function isEveryChildChecked(nodes, parent) {
     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 !_isNil(child.refKey) && nodes[child.refKey].check;
   });
 }
+
+/**
+ * Checks if any child node is checked.
+ */
 export function isSomeChildChecked(nodes, parent, childrenKey) {
   if (!_isNil(parent.refKey) && _isNil(nodes[parent.refKey])) {
     return false;
   }
   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 !_isNil(child.refKey) && nodes[child.refKey].check;
   });
 }
-export function isSomeNodeHasChildren(data, childrenKey) {
+
+/**
+ * Checks if any node in the data has a grandchild.
+ */
+export 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.
  */
 export function isAllSiblingNodeUncheckable(node, nodes, uncheckableItemValues, valueKey) {
   var list = [];
@@ -62,7 +95,7 @@ export function isAllSiblingNodeUncheckable(node, nodes, uncheckableItemValues,
 }
 
 /**
- * get each first level node uncheckable state
+ * Checks if every first-level node is uncheckable based on the provided criteria.
  */
 export function isEveryFirstLevelNodeUncheckable(nodes, uncheckableItemValues, valueKey) {
   var list = [];
@@ -81,8 +114,7 @@ export function isEveryFirstLevelNodeUncheckable(nodes, uncheckableItemValues, v
 }
 
 /**
- * get node uncheckable state
- * @param {*} node
+ * Checks if a node is uncheckable.
  */
 export function isNodeUncheckable(node, props) {
   var _props$uncheckableIte = props.uncheckableItemValues,
@@ -100,14 +132,12 @@ export function getFormattedTree(nodes, data, props) {
     var curNode = nodes[node.refKey];
     if (curNode) {
       var _node$childrenKey;
-      var checkState = !_isUndefined(cascade) ? getNodeCheckState({
-        node: curNode,
+      var checkState = !_isUndefined(cascade) ? getNodeCheckState(curNode, {
         cascade: cascade,
         nodes: nodes,
         childrenKey: childrenKey
       }) : undefined;
       formatted.check = curNode.check;
-      formatted.expand = curNode.expand;
       formatted.uncheckable = curNode.uncheckable;
       attachParent(formatted, curNode.parent);
       formatted.checkState = checkState;
@@ -118,6 +148,10 @@ export function getFormattedTree(nodes, data, props) {
     return formatted;
   });
 }
+
+/**
+ * Determines the disabled state of a tree node.
+ */
 export function getDisabledState(nodes, node, props) {
   var _props$disabledItemVa = props.disabledItemValues,
     disabledItemValues = _props$disabledItemVa === void 0 ? [] : _props$disabledItemVa,
@@ -129,18 +163,26 @@ export function getDisabledState(nodes, node, props) {
     return node.refKey && nodes[node.refKey][valueKey] === value;
   });
 }
-export function getCheckTreePickerDefaultValue(value, uncheckableItemValues) {
-  if (Array.isArray(value)) {
+
+/**
+ * Returns the default value for the check tree.
+ */
+export 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.
+ */
 export function getSelectedItems(nodes, values) {
   var checkedItems = [];
   values.forEach(function (value) {
-    var refKey = getNodeFormattedRefKey(value);
+    var refKey = formatNodeRefKey(value);
     var node = nodes[refKey];
     if (!_isNil(node)) {
       checkedItems.push(node);
@@ -148,11 +190,16 @@ export function getSelectedItems(nodes, values) {
   });
   return checkedItems;
 }
-export 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.
+ */
+export function getNodeCheckState(node, options) {
+  var nodes = options.nodes,
+    cascade = options.cascade,
+    childrenKey = options.childrenKey;
+  if (node.refKey === undefined) {
+    return CHECK_STATE.UNCHECK;
+  }
   if (_isNil(nodes[node.refKey])) {
     return CHECK_STATE.UNCHECK;
   }
@@ -160,7 +207,10 @@ export function getNodeCheckState(_ref) {
     nodes[node.refKey].checkAll = false;
     return node.check ? CHECK_STATE.CHECK : 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 CHECK_STATE.CHECK;

package/esm/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 { type CheckTreeViewProps } from '../CheckTree/CheckTreeView';
+import { TreeNode } from '../Tree/types';
+import type { FormControlPickerProps, ItemDataType, DeprecatedPickerProps } from '../@types/common';
+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.