rsuite 5.76.0 → 6.0.0-canary-20241227

package/esm/CheckTree/hooks/useTreeCheckState.js

@@ -6,22 +6,25 @@ import { useEventCallback } from "../../internals/hooks/index.js";
 import { useItemDataKeys } from "../../internals/Tree/TreeProvider.js";
 import { isEveryChildChecked } from "../utils.js";
 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;
+  const {
+    cascade,
+    flattenedNodes,
+    uncheckableItemValues
+  } = props;
+  const {
+    valueKey,
+    childrenKey
+  } = useItemDataKeys();
+  const checkParentNode = useEventCallback((nodes, node, checked) => {
+    const 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
+          nodes,
+          childrenKey
         })) {
           currentNode.check = true;
           currentNode.checkAll = true;
@@ -35,8 +38,8 @@ function useTreeCheckState(props) {
       }
     }
   });
-  var checkChildNode = useEventCallback(function (nodes, node, isChecked) {
-    var currentNode = node.refKey ? nodes[node.refKey] : null;
+  const checkChildNode = useEventCallback((nodes, node, isChecked) => {
+    const currentNode = node.refKey ? nodes[node.refKey] : null;
     if (!currentNode) {
       return;
     }
@@ -45,17 +48,17 @@ function useTreeCheckState(props) {
       currentNode.checkAll = false;
     } else {
       currentNode.checkAll = isChecked;
-      currentNode[childrenKey].forEach(function (child) {
+      currentNode[childrenKey].forEach(child => {
         checkChildNode(nodes, child, isChecked);
       });
     }
   });
-  var getCheckedValuesByParent = useCallback(function (nodes) {
-    var values = [];
-    for (var key in nodes) {
-      var currentNode = nodes[key];
+  const getCheckedValuesByParent = useCallback(nodes => {
+    const values = [];
+    for (const key in nodes) {
+      const currentNode = nodes[key];
       if (!isNil(currentNode.parent) && !isNil(currentNode.parent.refKey)) {
-        var parentNode = nodes[currentNode.parent.refKey];
+        const parentNode = nodes[currentNode.parent.refKey];
         if (currentNode.check) {
           if (!(parentNode !== null && parentNode !== void 0 && parentNode.checkAll)) {
             values.push(currentNode[valueKey]);
@@ -69,19 +72,17 @@ function useTreeCheckState(props) {
     }
     return values;
   }, [valueKey]);
-  var getCheckedValues = useEventCallback(function (node, isChecked) {
-    var nodes = cloneDeep(flattenedNodes);
+  const getCheckedValues = useEventCallback((node, isChecked) => {
+    const 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);
-    });
+    const values = getCheckedValuesByParent(nodes);
+    return values.filter(v => !uncheckableItemValues.includes(v));
   });
   return {
-    getCheckedValues: getCheckedValues
+    getCheckedValues
   };
 }
 export default useTreeCheckState;

package/esm/CheckTree/hooks/useTreeNodeProps.js

@@ -4,48 +4,51 @@ import { isAllSiblingNodeUncheckable, getDisabledState, isNodeUncheckable } from
 import { useItemDataKeys } from "../../internals/Tree/TreeProvider.js";
 import Highlight from "../../Highlight/index.js";
 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, {
+  const {
+    valueKey,
+    labelKey
+  } = useItemDataKeys();
+  const {
+    uncheckableItemValues,
+    disabledItemValues,
+    loadingNodeValues,
+    focusItemValue,
+    flattenedNodes,
+    keyword
+  } = props;
+  return useCallback(nodeData => {
+    const {
+      visible,
+      checkState
+    } = nodeData;
+    const value = nodeData[valueKey];
+    const nodeLabel = nodeData[labelKey];
+    const allUncheckable = isAllSiblingNodeUncheckable(nodeData, flattenedNodes, uncheckableItemValues, valueKey);
+    const label = keyword ? /*#__PURE__*/React.createElement(Highlight, {
       as: "span",
       query: keyword
     }, nodeLabel) : nodeLabel;
-    var disabled = getDisabledState(flattenedNodes, nodeData, {
-      disabledItemValues: disabledItemValues,
-      valueKey: valueKey
+    const disabled = getDisabledState(flattenedNodes, nodeData, {
+      disabledItemValues,
+      valueKey
     });
-    var uncheckable = isNodeUncheckable(nodeData, {
-      uncheckableItemValues: uncheckableItemValues,
-      valueKey: valueKey
+    const uncheckable = isNodeUncheckable(nodeData, {
+      uncheckableItemValues,
+      valueKey
     });
-    var loading = loadingNodeValues.some(function (item) {
-      return item === nodeData[valueKey];
-    });
-    var focus = focusItemValue === value;
+    const loading = loadingNodeValues.some(item => item === nodeData[valueKey]);
+    const focus = focusItemValue === value;
     return {
-      value: value,
-      label: label,
-      visible: visible,
-      loading: loading,
-      disabled: disabled,
-      nodeData: nodeData,
-      checkState: checkState,
-      uncheckable: uncheckable,
-      allUncheckable: allUncheckable,
-      focus: focus
+      value,
+      label,
+      visible,
+      loading,
+      disabled,
+      nodeData,
+      checkState,
+      uncheckable,
+      allUncheckable,
+      focus
     };
   }, [valueKey, flattenedNodes, uncheckableItemValues, keyword, labelKey, disabledItemValues, loadingNodeValues, focusItemValue]);
 }

package/esm/CheckTree/hooks/useTreeValue.js

@@ -2,13 +2,12 @@
 import { useControlled, useMount } from "../../internals/hooks/index.js";
 import { getCheckTreeDefaultValue } from "../utils.js";
 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 () {
+  let {
+    defaultValue,
+    uncheckableItemValues
+  } = _ref;
+  const [value, setValue, isControlled] = useControlled(controlledValue, defaultValue);
+  useMount(() => {
     setValue(getCheckTreeDefaultValue(value, uncheckableItemValues));
   });
   return [value, setValue, isControlled];

package/esm/CheckTree/utils.js

@@ -1,5 +1,4 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 import _isUndefined from "lodash/isUndefined";
 import _isNil from "lodash/isNil";
 import { CHECK_STATE } from "../internals/constants/index.js";
@@ -13,7 +12,7 @@ function getChildrenByFlattenNodes(nodes, parent) {
   if (!_isNil(parent.refKey) && _isNil(nodes[parent.refKey])) {
     return [];
   }
-  return Object.values(nodes).filter(function (item) {
+  return Object.values(nodes).filter(item => {
     var _item$parent;
     return (item === null || item === void 0 || (_item$parent = item.parent) === null || _item$parent === void 0 ? void 0 : _item$parent.refKey) === parent.refKey && item.refKey && !nodes[item.refKey].uncheckable;
   });
@@ -23,23 +22,25 @@ function getChildrenByFlattenNodes(nodes, parent) {
  * Checks if every child of a given parent node is checked.
  */
 export function isEveryChildChecked(parent, options) {
-  var nodes = options.nodes,
-    childrenKey = options.childrenKey;
+  const {
+    nodes,
+    childrenKey
+  } = options;
   if (_isNil(parent.refKey) || _isNil(nodes[parent.refKey])) {
     return false;
   }
-  var children = getChildrenByFlattenNodes(nodes, parent);
+  const 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) {
+  return children.every(child => {
     var _child$childrenKey;
     if ((child === null || child === 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
+        nodes,
+        childrenKey
       });
     }
     return !_isNil(child.refKey) && nodes[child.refKey].check;
@@ -53,8 +54,8 @@ 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) {
+  const children = getChildrenByFlattenNodes(nodes, parent);
+  return children.some(child => {
     var _child$childrenKey2;
     if ((child === null || child === void 0 || (_child$childrenKey2 = child[childrenKey]) === null || _child$childrenKey2 === void 0 ? void 0 : _child$childrenKey2.length) > 0) {
       return isSomeChildChecked(nodes, child, childrenKey);
@@ -67,76 +68,73 @@ export function isSomeChildChecked(nodes, parent, 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]);
-  });
+  return data.some(node => Array.isArray(node[childrenKey]));
 }
 
 /**
  * Checks if all sibling nodes of a given node are uncheckable.
  */
 export function isAllSiblingNodeUncheckable(node, nodes, uncheckableItemValues, valueKey) {
-  var list = [];
-  var parentNodeRefKey = node.parent ? node.parent.refKey : '';
-  Object.keys(nodes).forEach(function (refKey) {
+  const list = [];
+  const parentNodeRefKey = node.parent ? node.parent.refKey : '';
+  Object.keys(nodes).forEach(refKey => {
     var _curNode$parent;
-    var curNode = nodes[refKey];
+    const curNode = nodes[refKey];
     if (_isNil(node.parent) && _isNil(curNode.parent)) {
       list.push(curNode);
     } else if (((_curNode$parent = curNode.parent) === null || _curNode$parent === void 0 ? void 0 : _curNode$parent.refKey) === parentNodeRefKey) {
       list.push(curNode);
     }
   });
-  return list.every(function (node) {
-    return isNodeUncheckable(node, {
-      uncheckableItemValues: uncheckableItemValues,
-      valueKey: valueKey
-    });
-  });
+  return list.every(node => isNodeUncheckable(node, {
+    uncheckableItemValues,
+    valueKey
+  }));
 }
 
 /**
  * Checks if every first-level node is uncheckable based on the provided criteria.
  */
 export function isEveryFirstLevelNodeUncheckable(nodes, uncheckableItemValues, valueKey) {
-  var list = [];
-  Object.keys(nodes).forEach(function (refKey) {
-    var curNode = nodes[refKey];
+  const list = [];
+  Object.keys(nodes).forEach(refKey => {
+    const curNode = nodes[refKey];
     if (!curNode.parent) {
       list.push(curNode);
     }
   });
-  return list.every(function (node) {
-    return isNodeUncheckable(node, {
-      uncheckableItemValues: uncheckableItemValues,
-      valueKey: valueKey
-    });
-  });
+  return list.every(node => isNodeUncheckable(node, {
+    uncheckableItemValues,
+    valueKey
+  }));
 }
 
 /**
  * Checks if a node is uncheckable.
  */
 export function isNodeUncheckable(node, props) {
-  var _props$uncheckableIte = props.uncheckableItemValues,
-    uncheckableItemValues = _props$uncheckableIte === void 0 ? [] : _props$uncheckableIte,
-    valueKey = props.valueKey;
-  return uncheckableItemValues.some(function (value) {
-    return node[valueKey] === value;
-  });
+  const {
+    uncheckableItemValues = [],
+    valueKey
+  } = props;
+  return uncheckableItemValues.some(value => node[valueKey] === value);
 }
 export function getFormattedTree(nodes, data, props) {
-  var childrenKey = props.childrenKey,
-    cascade = props.cascade;
-  return data.map(function (node) {
-    var formatted = _extends({}, node);
-    var curNode = nodes[node.refKey];
+  const {
+    childrenKey,
+    cascade
+  } = props;
+  return data.map(node => {
+    const formatted = {
+      ...node
+    };
+    const curNode = nodes[node.refKey];
     if (curNode) {
       var _node$childrenKey;
-      var checkState = !_isUndefined(cascade) ? getNodeCheckState(curNode, {
-        cascade: cascade,
-        nodes: nodes,
-        childrenKey: childrenKey
+      const checkState = !_isUndefined(cascade) ? getNodeCheckState(curNode, {
+        cascade,
+        nodes,
+        childrenKey
       }) : undefined;
       formatted.check = curNode.check;
       formatted.uncheckable = curNode.uncheckable;
@@ -154,15 +152,14 @@ export function getFormattedTree(nodes, data, props) {
  * 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,
-    valueKey = props.valueKey;
+  const {
+    disabledItemValues = [],
+    valueKey
+  } = props;
   if (!_isNil(node.refKey) && _isNil(nodes[node.refKey])) {
     return false;
   }
-  return disabledItemValues.some(function (value) {
-    return node.refKey && nodes[node.refKey][valueKey] === value;
-  });
+  return disabledItemValues.some(value => node.refKey && nodes[node.refKey][valueKey] === value);
 }
 
 /**
@@ -170,9 +167,7 @@ export function getDisabledState(nodes, node, props) {
  */
 export function getCheckTreeDefaultValue(value, uncheckableItemValues) {
   if (Array.isArray(value) && Array.isArray(uncheckableItemValues)) {
-    return value.filter(function (v) {
-      return !uncheckableItemValues.includes(v);
-    });
+    return value.filter(v => !uncheckableItemValues.includes(v));
   }
   return value;
 }
@@ -181,10 +176,10 @@ export function getCheckTreeDefaultValue(value, uncheckableItemValues) {
  * Retrieves the selected items from the given nodes.
  */
 export function getSelectedItems(nodes, values) {
-  var checkedItems = [];
-  values.forEach(function (value) {
-    var refKey = formatNodeRefKey(value);
-    var node = nodes[refKey];
+  const checkedItems = [];
+  values.forEach(value => {
+    const refKey = formatNodeRefKey(value);
+    const node = nodes[refKey];
     if (!_isNil(node)) {
       checkedItems.push(node);
     }
@@ -195,9 +190,11 @@ export function getSelectedItems(nodes, values) {
  * 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;
+  const {
+    nodes,
+    cascade,
+    childrenKey
+  } = options;
   if (node.refKey === undefined) {
     return CHECK_STATE.UNCHECK;
   }
@@ -209,8 +206,8 @@ export function getNodeCheckState(node, options) {
     return node.check ? CHECK_STATE.CHECK : CHECK_STATE.UNCHECK;
   }
   if (isEveryChildChecked(node, {
-    nodes: nodes,
-    childrenKey: childrenKey
+    nodes,
+    childrenKey
   })) {
     nodes[node.refKey].checkAll = true;
     nodes[node.refKey].check = true;