rsuite 5.55.1 → 5.57.0

package/esm/{MultiCascader → MultiCascadeTree}/TreeView.js

@@ -9,15 +9,11 @@ import { useClassNames, shallowEqual, useCustom, useEventCallback } from '../uti
 import { ListCheckItem, useCombobox } from '../internals/Picker';
 import { isSomeParentChecked, isSomeChildChecked } from './utils';
 var emptyArray = [];
-
-/**
- * TODO: reuse Menu from Cascader for consistent behavior
- */
 var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
   var _props$as = props.as,
     Component = _props$as === void 0 ? 'div' : _props$as,
     _props$classPrefix = props.classPrefix,
-    classPrefix = _props$classPrefix === void 0 ? 'menu' : _props$classPrefix,
+    classPrefix = _props$classPrefix === void 0 ? 'tree' : _props$classPrefix,
     className = props.className,
     cascade = props.cascade,
     _props$cascadeData = props.cascadeData,
@@ -28,10 +24,10 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
     childrenKey = _props$childrenKey === void 0 ? 'children' : _props$childrenKey,
     _props$disabledItemVa = props.disabledItemValues,
     disabledItemValues = _props$disabledItemVa === void 0 ? emptyArray : _props$disabledItemVa,
-    _props$menuWidth = props.menuWidth,
-    menuWidth = _props$menuWidth === void 0 ? 156 : _props$menuWidth,
-    _props$menuHeight = props.menuHeight,
-    menuHeight = _props$menuHeight === void 0 ? 200 : _props$menuHeight,
+    _props$columnWidth = props.columnWidth,
+    columnWidth = _props$columnWidth === void 0 ? 156 : _props$columnWidth,
+    _props$columnHeight = props.columnHeight,
+    columnHeight = _props$columnHeight === void 0 ? 200 : _props$columnHeight,
     _props$uncheckableIte = props.uncheckableItemValues,
     uncheckableItemValues = _props$uncheckableIte === void 0 ? emptyArray : _props$uncheckableIte,
     value = props.value,
@@ -40,11 +36,11 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
     _props$labelKey = props.labelKey,
     labelKey = _props$labelKey === void 0 ? 'label' : _props$labelKey,
     style = props.style,
-    renderMenuItem = props.renderMenuItem,
-    renderMenu = props.renderMenu,
+    renderTreeNode = props.renderTreeNode,
+    renderColumn = props.renderColumn,
     _onCheck = props.onCheck,
     onSelect = props.onSelect,
-    rest = _objectWithoutPropertiesLoose(props, ["as", "classPrefix", "className", "cascade", "cascadeData", "cascadePaths", "childrenKey", "disabledItemValues", "menuWidth", "menuHeight", "uncheckableItemValues", "value", "valueKey", "labelKey", "style", "renderMenuItem", "renderMenu", "onCheck", "onSelect"]);
+    rest = _objectWithoutPropertiesLoose(props, ["as", "classPrefix", "className", "cascade", "cascadeData", "cascadePaths", "childrenKey", "disabledItemValues", "columnWidth", "columnHeight", "uncheckableItemValues", "value", "valueKey", "labelKey", "style", "renderTreeNode", "renderColumn", "onCheck", "onSelect"]);
   var _useClassNames = useClassNames(classPrefix),
     merge = _useClassNames.merge,
     prefix = _useClassNames.prefix;
@@ -120,20 +116,21 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
       onCheck: function onCheck(_value, event, checked) {
         return _onCheck === null || _onCheck === void 0 ? void 0 : _onCheck(node, event, checked);
       },
-      checkable: !uncheckable
-    }, renderMenuItem ? renderMenuItem(label, node) : label, children ? /*#__PURE__*/React.createElement(Icon, {
+      checkable: !uncheckable,
+      labelClickable: false
+    }, renderTreeNode ? renderTreeNode(label, node) : label, children ? /*#__PURE__*/React.createElement(Icon, {
       className: prefix('caret'),
       spin: node.loading
     }) : null);
   };
   var columnStyles = {
-    height: menuHeight,
-    width: menuWidth
+    height: columnHeight,
+    width: columnWidth
   };
   var cascadeNodes = cascadeData.map(function (children, layer) {
     var uncheckableCount = 0;
     var onlyKey = layer + "_" + children.length;
-    var menu = /*#__PURE__*/React.createElement(React.Fragment, null, children.map(function (item, index) {
+    var childNodes = /*#__PURE__*/React.createElement(React.Fragment, null, children.map(function (item, index) {
       var uncheckable = uncheckableItemValues.some(function (uncheckableValue) {
         return shallowEqual(uncheckableValue, item[valueKey]);
       });
@@ -150,7 +147,7 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
         size: children.length
       });
     }));
-    var parentNode = cascadePaths[layer - 1];
+    var parentItem = cascadePaths[layer - 1];
     var columnClasses = prefix('column', {
       'column-uncheckable': uncheckableCount === children.length
     });
@@ -160,14 +157,18 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
       className: columnClasses,
       "data-layer": layer,
       style: columnStyles
-    }, renderMenu ? renderMenu(children, menu, parentNode, layer) : menu);
+    }, renderColumn ? renderColumn(childNodes, {
+      items: children,
+      parentItem: parentItem,
+      layer: layer
+    }) : childNodes);
   });
   var styles = _extends({}, style, {
-    width: cascadeData.length * menuWidth
+    width: cascadeData.length * columnWidth
   });
   return /*#__PURE__*/React.createElement(Component, _extends({
     role: "tree",
-    id: id + "-" + popupType,
+    id: id ? id + "-" + popupType : undefined,
     "aria-labelledby": labelId,
     "aria-multiselectable": multiple
   }, rest, {

package/esm/MultiCascadeTree/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { default as useFlattenData } from './useFlattenData';
+export { default as useSelect } from './useSelect';
+export { default as useColumnData } from './useColumnData';
+export { default as useCascadeValue } from './useCascadeValue';
+export { default as useSearch } from './useSearch';

package/esm/MultiCascadeTree/hooks/index.js

@@ -0,0 +1,6 @@
+'use client';
+export { default as useFlattenData } from './useFlattenData';
+export { default as useSelect } from './useSelect';
+export { default as useColumnData } from './useColumnData';
+export { default as useCascadeValue } from './useCascadeValue';
+export { default as useSearch } from './useSearch';

package/esm/MultiCascadeTree/hooks/useCascadeValue.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { MultiCascadeTreeProps, ItemKeys } from '../types';
+import { type ItemType } from '../utils';
+/**
+ * A hook that converts the value into a cascading value
+ * @param props
+ * @param flattenData
+ */
+declare function useCascadeValue<T>(props: Partial<MultiCascadeTreeProps<T>> & ItemKeys, flattenData: ItemType<T>[]): {
+    value: T[];
+    setValue: import("react").Dispatch<import("react").SetStateAction<T[]>>;
+    splitValue: (item: ItemType<T>, checked: boolean, value: T[]) => {
+        value: T[];
+        removedValue: T[];
+    };
+    handleCheck: (...args: any[]) => any;
+};
+export default useCascadeValue;

package/esm/MultiCascadeTree/hooks/useCascadeValue.js

@@ -0,0 +1,197 @@
+'use client';
+import { useState, useEffect, useCallback } from 'react';
+import uniq from 'lodash/uniq';
+import remove from 'lodash/remove';
+import { useEventCallback } from '../../utils';
+import { getParents, removeAllChildrenValue, getOtherItemValuesByUnselectChild } from '../utils';
+
+/**
+ * A hook that converts the value into a cascading value
+ * @param props
+ * @param flattenData
+ */
+function useCascadeValue(props, flattenData) {
+  var valueKey = props.valueKey,
+    childrenKey = props.childrenKey,
+    uncheckableItemValues = props.uncheckableItemValues,
+    cascade = props.cascade,
+    valueProp = props.value,
+    onChange = props.onChange,
+    onCheck = props.onCheck;
+  /**
+   * Get the values of all children
+   */
+  var getChildrenValue = useCallback(function (item) {
+    var values = [];
+    if (!item[childrenKey]) {
+      return values;
+    }
+    item[childrenKey].forEach(function (n) {
+      if (uncheckableItemValues && !uncheckableItemValues.some(function (v) {
+        return v === n[valueKey];
+      })) {
+        values.push(n[valueKey]);
+      }
+      values = values.concat(getChildrenValue(n));
+    });
+    return values;
+  }, [childrenKey, uncheckableItemValues, valueKey]);
+  var splitValue = useCallback(function (item, checked, value) {
+    var itemValue = item[valueKey];
+    var childrenValue = getChildrenValue(item);
+    var parents = getParents(item);
+    var nextValue = [].concat(value);
+    var removedValue = [];
+    if (checked) {
+      nextValue.push(itemValue);
+
+      // Delete all values under the current node
+      removedValue = removedValue.concat(removeAllChildrenValue(nextValue, item, {
+        valueKey: valueKey,
+        childrenKey: childrenKey
+      }) || []);
+
+      // Traverse all ancestor nodes of the current node
+      // Then determine whether all the child nodes of these nodes are selected, and then they themselves must be selected
+      var _loop = function _loop(i) {
+        // Whether the parent node can be selected
+        var isCheckableParent = !(uncheckableItemValues !== null && uncheckableItemValues !== void 0 && uncheckableItemValues.some(function (v) {
+          return v === parents[i][valueKey];
+        }));
+        if (isCheckableParent) {
+          var isCheckAll = parents[i][childrenKey]
+          // Filter out options that are marked as not selectable
+          .filter(function (n) {
+            return !(uncheckableItemValues !== null && uncheckableItemValues !== void 0 && uncheckableItemValues.some(function (v) {
+              return v === n[valueKey];
+            }));
+          })
+          // Check if all nodes are selected
+          .every(function (n) {
+            return nextValue.some(function (v) {
+              return v === n[valueKey];
+            });
+          });
+          if (isCheckAll) {
+            // Add parent node value
+            nextValue.push(parents[i][valueKey]);
+
+            // Delete all values under the parent node
+            removedValue = removedValue.concat(removeAllChildrenValue(nextValue, parents[i], {
+              valueKey: valueKey,
+              childrenKey: childrenKey
+            }) || []);
+          }
+        }
+      };
+      for (var i = 0; i < parents.length; i++) {
+        _loop(i);
+      }
+    } else {
+      var tempValue = childrenValue.concat(parents.map(function (item) {
+        return item[valueKey];
+      }));
+      nextValue = nextValue.concat(getOtherItemValuesByUnselectChild(item, nextValue, {
+        valueKey: valueKey,
+        childrenKey: childrenKey
+      }));
+
+      // Delete related child and parent nodes
+      removedValue = remove(nextValue, function (v) {
+        // Delete yourself
+        if (v === itemValue) {
+          return true;
+        }
+        return tempValue.some(function (n) {
+          return n === v;
+        });
+      });
+    }
+    var uniqValue = uniq(nextValue);
+    var uniqRemovedValue = uniq(removedValue);
+    return {
+      value: uniqValue,
+      removedValue: uniqRemovedValue
+    };
+  }, [valueKey, childrenKey, uncheckableItemValues, getChildrenValue]);
+  var transformValue = useCallback(function (value) {
+    if (value === void 0) {
+      value = [];
+    }
+    if (!cascade) {
+      return value;
+    }
+    var tempRemovedValue = [];
+    var nextValue = [];
+    var _loop2 = function _loop2(i) {
+      // If the value in the current value is already in the deleted list, it will not be processed
+      if (tempRemovedValue.some(function (v) {
+        return v === value[i];
+      })) {
+        return "continue";
+      }
+      var item = flattenData.find(function (v) {
+        return v[valueKey] === value[i];
+      });
+      if (!item) {
+        return "continue";
+      }
+      var sv = splitValue(item, true, value);
+      tempRemovedValue = uniq(tempRemovedValue.concat(sv.removedValue));
+
+      // Get all relevant values
+      nextValue = uniq(nextValue.concat(sv.value));
+    };
+    for (var i = 0; i < value.length; i++) {
+      var _ret = _loop2(i);
+      if (_ret === "continue") continue;
+    }
+
+    // Finally traverse all nextValue, and delete if its parent node is also nextValue
+    return nextValue.filter(function (v) {
+      var item = flattenData.find(function (n) {
+        return n[valueKey] === v;
+      });
+      if (item !== null && item !== void 0 && item.parent && nextValue.some(function (v) {
+        var _item$parent;
+        return v === ((_item$parent = item.parent) === null || _item$parent === void 0 ? void 0 : _item$parent[valueKey]);
+      })) {
+        return false;
+      }
+      return true;
+    });
+  }, [cascade, flattenData, splitValue, valueKey]);
+  var _useState = useState(transformValue(valueProp) || []),
+    value = _useState[0],
+    setValue = _useState[1];
+  useEffect(function () {
+    // Update value when valueProp is updated.
+    setValue(transformValue(valueProp) || []);
+  }, [transformValue, valueProp]);
+  var handleCheck = useEventCallback(function (node, event, checked) {
+    var nodeValue = node[valueKey];
+    var nextValue = [];
+    if (cascade) {
+      nextValue = splitValue(node, checked, value).value;
+    } else {
+      nextValue = [].concat(value);
+      if (checked) {
+        nextValue.push(nodeValue);
+      } else {
+        nextValue = nextValue.filter(function (n) {
+          return n !== nodeValue;
+        });
+      }
+    }
+    setValue(nextValue);
+    onChange === null || onChange === void 0 ? void 0 : onChange(nextValue, event);
+    onCheck === null || onCheck === void 0 ? void 0 : onCheck(nextValue, node, checked, event);
+  });
+  return {
+    value: value,
+    setValue: setValue,
+    splitValue: splitValue,
+    handleCheck: handleCheck
+  };
+}
+export default useCascadeValue;

package/esm/MultiCascadeTree/hooks/useColumnData.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+declare type MayHasParent<T extends Record<string, unknown>> = T & {
+    parent?: MayHasParent<T>;
+};
+/**
+ * A hook for column data
+ * @param flattenData
+ */
+declare function useColumnData<T extends MayHasParent<Record<string, unknown>>>(flattenData: T[]): {
+    columnData: (readonly T[])[];
+    addColumn: (column: T[], index: number) => void;
+    removeColumnByIndex: (index: number) => void;
+    setColumnData: import("react").Dispatch<import("react").SetStateAction<(readonly T[])[]>>;
+    enforceUpdateColumnData: (nextData: T[]) => void;
+};
+export default useColumnData;

package/esm/MultiCascadeTree/hooks/useColumnData.js

@@ -0,0 +1,46 @@
+'use client';
+import { useState } from 'react';
+import slice from 'lodash/slice';
+import { UNSAFE_flattenTree } from '../../utils/treeUtils';
+/**
+ * A hook for column data
+ * @param flattenData
+ */
+function useColumnData(flattenData) {
+  // The columns displayed in the cascading panel.
+  var _useState = useState([flattenData.filter(function (item) {
+      return !item.parent;
+    })]),
+    columnData = _useState[0],
+    setColumnData = _useState[1];
+  /**
+   * Add a list of options to the cascading panel. Used for lazy loading options.
+   * @param column
+   * @param index The index of the current column.
+   */
+  function addColumn(column, index) {
+    setColumnData([].concat(slice(columnData, 0, index), [column]));
+  }
+
+  /**
+   * Remove subsequent columns of the specified column
+   * @param index
+   */
+  function removeColumnByIndex(index) {
+    setColumnData([].concat(slice(columnData, 0, index)));
+  }
+  function enforceUpdateColumnData(nextData) {
+    var nextFlattenData = UNSAFE_flattenTree(nextData);
+    setColumnData([nextFlattenData.filter(function (item) {
+      return !item.parent;
+    })]);
+  }
+  return {
+    columnData: columnData,
+    addColumn: addColumn,
+    removeColumnByIndex: removeColumnByIndex,
+    setColumnData: setColumnData,
+    enforceUpdateColumnData: enforceUpdateColumnData
+  };
+}
+export default useColumnData;

package/esm/MultiCascadeTree/hooks/useFlattenData.d.ts

@@ -0,0 +1,9 @@
+import { ItemKeys } from '../types';
+/**
+ * A hook to flatten tree structure data
+ */
+declare function useFlattenData<T>(data: T[], itemKeys: ItemKeys): {
+    addFlattenData: (children: T[], parent: T) => void;
+    flattenData: T[];
+};
+export default useFlattenData;

package/esm/MultiCascadeTree/hooks/useFlattenData.js

@@ -0,0 +1,28 @@
+'use client';
+import { useState, useCallback, useEffect } from 'react';
+import { UNSAFE_flattenTree } from '../../utils/treeUtils';
+import { attachParent } from '../../utils/attachParent';
+/**
+ * A hook to flatten tree structure data
+ */
+function useFlattenData(data, itemKeys) {
+  var childrenKey = itemKeys.childrenKey;
+  var _useState = useState(UNSAFE_flattenTree(data, itemKeys.childrenKey)),
+    flattenData = _useState[0],
+    setFlattenData = _useState[1];
+  var addFlattenData = useCallback(function (children, parent) {
+    var nodes = children.map(function (child) {
+      return attachParent(child, parent);
+    });
+    parent[childrenKey] = nodes;
+    setFlattenData([].concat(flattenData, nodes));
+  }, [childrenKey, flattenData]);
+  useEffect(function () {
+    setFlattenData(UNSAFE_flattenTree(data, itemKeys.childrenKey));
+  }, [data, itemKeys.childrenKey]);
+  return {
+    addFlattenData: addFlattenData,
+    flattenData: flattenData
+  };
+}
+export default useFlattenData;

package/esm/MultiCascadeTree/hooks/useSearch.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { ItemDataType } from '../../@types/common';
+interface SearchPanelProps<T> {
+    labelKey: string;
+    valueKey: string;
+    childrenKey: string;
+    flattenedData: ItemDataType<T>[];
+    uncheckableItemValues?: any[];
+    onSearch?: (value: string, event: React.SyntheticEvent) => void;
+}
+declare function useSearch<T>(props: SearchPanelProps<T>): {
+    searchKeyword: string;
+    setSearchKeyword: import("react").Dispatch<import("react").SetStateAction<string>>;
+    items: ItemDataType<T>[];
+    handleSearch: (...args: any[]) => any;
+};
+export default useSearch;

package/esm/MultiCascadeTree/hooks/useSearch.js

@@ -0,0 +1,47 @@
+'use client';
+import { useState } from 'react';
+import { getSafeRegExpString, useEventCallback } from '../../utils';
+function useSearch(props) {
+  var _useState = useState(''),
+    searchKeyword = _useState[0],
+    setSearchKeyword = _useState[1];
+  var labelKey = props.labelKey,
+    valueKey = props.valueKey,
+    flattenedData = props.flattenedData,
+    uncheckableItemValues = props.uncheckableItemValues,
+    onSearch = props.onSearch;
+  var getSearchResult = function getSearchResult() {
+    var items = [];
+    var result = flattenedData.filter(function (item) {
+      if (uncheckableItemValues !== null && uncheckableItemValues !== void 0 && uncheckableItemValues.some(function (value) {
+        return item[valueKey] === value;
+      })) {
+        return false;
+      }
+      if (item[labelKey].match(new RegExp(getSafeRegExpString(searchKeyword), 'i'))) {
+        return true;
+      }
+      return false;
+    });
+    for (var i = 0; i < result.length; i++) {
+      items.push(result[i]);
+
+      // A maximum of 100 search results are returned.
+      if (i === 99) {
+        return items;
+      }
+    }
+    return items;
+  };
+  var handleSearch = useEventCallback(function (value, event) {
+    setSearchKeyword(value);
+    onSearch === null || onSearch === void 0 ? void 0 : onSearch(value, event);
+  });
+  return {
+    searchKeyword: searchKeyword,
+    setSearchKeyword: setSearchKeyword,
+    items: getSearchResult(),
+    handleSearch: handleSearch
+  };
+}
+export default useSearch;

package/esm/MultiCascadeTree/hooks/useSelect.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { type ItemDataType } from '../../@types/common';
+export interface UseSelectProps<T> {
+    data: ItemDataType<T>[];
+    childrenKey: string;
+    labelKey: string;
+    valueKey: string;
+    onSelect?: (node: ItemDataType<T>, cascadePaths: ItemDataType<T>[], event: React.SyntheticEvent) => void;
+    getChildren?: (node: ItemDataType<T>) => ItemDataType<T>[] | Promise<ItemDataType<T>[]>;
+}
+declare const useSelect: <T>(props: UseSelectProps<T>) => {
+    columnData: (readonly ItemDataType<T>[])[];
+    setColumnData: React.Dispatch<React.SetStateAction<(readonly ItemDataType<T>[])[]>>;
+    flattenData: ItemDataType<T>[];
+    selectedPaths: ItemDataType<T>[] | undefined;
+    setSelectedPaths: React.Dispatch<React.SetStateAction<ItemDataType<T>[] | undefined>>;
+    handleSelect: (...args: any[]) => any;
+};
+export default useSelect;

package/esm/MultiCascadeTree/hooks/useSelect.js

@@ -0,0 +1,77 @@
+'use client';
+import { useState } from 'react';
+import { useEventCallback, useUpdateEffect, useIsMounted } from '../../utils';
+import useFlattenData from './useFlattenData';
+import useColumnData from './useColumnData';
+var useSelect = function useSelect(props) {
+  var data = props.data,
+    childrenKey = props.childrenKey,
+    labelKey = props.labelKey,
+    valueKey = props.valueKey,
+    onSelect = props.onSelect,
+    getChildren = props.getChildren;
+  var itemKeys = {
+    childrenKey: childrenKey,
+    labelKey: labelKey,
+    valueKey: valueKey
+  };
+  var _useFlattenData = useFlattenData(data, itemKeys),
+    flattenData = _useFlattenData.flattenData,
+    addFlattenData = _useFlattenData.addFlattenData; // The columns displayed in the cascading panel.
+  var _useColumnData = useColumnData(flattenData),
+    columnData = _useColumnData.columnData,
+    addColumn = _useColumnData.addColumn,
+    setColumnData = _useColumnData.setColumnData,
+    removeColumnByIndex = _useColumnData.removeColumnByIndex,
+    enforceUpdateColumnData = _useColumnData.enforceUpdateColumnData;
+  useUpdateEffect(function () {
+    enforceUpdateColumnData(data);
+  }, [data]);
+  var isMounted = useIsMounted();
+
+  // The path after cascading data selection.
+  var _useState = useState(),
+    selectedPaths = _useState[0],
+    setSelectedPaths = _useState[1];
+  var handleSelect = useEventCallback(function (node, cascadePaths, event) {
+    var _node$childrenKey, _node$childrenKey2;
+    setSelectedPaths(cascadePaths);
+    var columnIndex = cascadePaths.length;
+
+    // Lazy load node's children
+    if (typeof getChildren === 'function' && ((_node$childrenKey = node[childrenKey]) === null || _node$childrenKey === void 0 ? void 0 : _node$childrenKey.length) === 0) {
+      node.loading = true;
+      var children = getChildren(node);
+      if (children instanceof Promise) {
+        children.then(function (data) {
+          node.loading = false;
+          node[childrenKey] = data;
+          if (isMounted()) {
+            addFlattenData(data, node);
+            addColumn(data, columnIndex);
+          }
+        });
+      } else {
+        node.loading = false;
+        node[childrenKey] = children;
+        addFlattenData(children, node);
+        addColumn(children, columnIndex);
+      }
+    } else if ((_node$childrenKey2 = node[childrenKey]) !== null && _node$childrenKey2 !== void 0 && _node$childrenKey2.length) {
+      addColumn(node[childrenKey], columnIndex);
+    } else {
+      // Removes subsequent columns of the current column when the clicked node is a leaf node.
+      removeColumnByIndex(columnIndex);
+    }
+    onSelect === null || onSelect === void 0 ? void 0 : onSelect(node, cascadePaths, event);
+  });
+  return {
+    columnData: columnData,
+    setColumnData: setColumnData,
+    flattenData: flattenData,
+    selectedPaths: selectedPaths,
+    setSelectedPaths: setSelectedPaths,
+    handleSelect: handleSelect
+  };
+};
+export default useSelect;

package/esm/MultiCascadeTree/index.d.ts

@@ -0,0 +1,4 @@
+import MultiCascadeTree from './MultiCascadeTree';
+export type { ItemDataType } from '../@types/common';
+export type { MultiCascadeTreeProps } from './types';
+export default MultiCascadeTree;

package/esm/MultiCascadeTree/index.js

@@ -0,0 +1,3 @@
+'use client';
+import MultiCascadeTree from './MultiCascadeTree';
+export default MultiCascadeTree;

package/esm/MultiCascadeTree/types.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { CascadeTreeProps } from '../CascadeTree/types';
+import type { ItemDataType, ToArray, WithAsProps } from '../@types/common';
+export interface ItemKeys {
+    valueKey: string;
+    labelKey: string;
+    childrenKey: string;
+}
+export interface MultiCascadeTreeProps<T, V = T[]> extends WithAsProps, CascadeTreeProps<T, V> {
+    /**
+     * When set to true, selecting a child node will update the state of the parent node.
+     */
+    cascade?: boolean;
+    /**
+     * Disabled items
+     */
+    disabledItemValues?: ToArray<NonNullable<T>>;
+    /**
+     * Set the option value for the check box not to be rendered
+     */
+    uncheckableItemValues?: T[];
+    /**
+     * Called after the checkbox state changes.
+     */
+    onCheck?: (value: T[], node: ItemDataType<T>, checked: boolean, event: React.SyntheticEvent) => void;
+}

package/esm/MultiCascadeTree/types.js

@@ -0,0 +1 @@
+'use client';