rsuite 5.56.0 → 5.58.0

package/esm/MultiCascadeTree/SearchView.js

@@ -0,0 +1,111 @@
+'use client';
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import { useClassNames, useCustom } from '../utils';
+import { getNodeParents } from '../utils/treeUtils';
+import SearchBox from '../internals/SearchBox';
+import Checkbox from '../Checkbox';
+import { isSomeChildChecked } from './utils';
+import { highlightLabel } from '../CascadeTree/utils';
+function SearchView(props) {
+  var _props$as = props.as,
+    Component = _props$as === void 0 ? 'div' : _props$as,
+    _props$classPrefix = props.classPrefix,
+    classPrefix = _props$classPrefix === void 0 ? 'cascade-search-view' : _props$classPrefix,
+    className = props.className,
+    searchKeyword = props.searchKeyword,
+    childrenKey = props.childrenKey,
+    labelKey = props.labelKey,
+    valueKey = props.valueKey,
+    value = props.value,
+    data = props.data,
+    disabledItemValues = props.disabledItemValues,
+    inputRef = props.inputRef,
+    cascade = props.cascade,
+    onSearch = props.onSearch,
+    onCheck = props.onCheck,
+    rest = _objectWithoutPropertiesLoose(props, ["as", "classPrefix", "className", "searchKeyword", "childrenKey", "labelKey", "valueKey", "value", "data", "disabledItemValues", "inputRef", "cascade", "onSearch", "onCheck"]);
+  var _useClassNames = useClassNames(classPrefix),
+    merge = _useClassNames.merge,
+    prefix = _useClassNames.prefix,
+    withClassPrefix = _useClassNames.withClassPrefix,
+    rootPrefix = _useClassNames.rootPrefix;
+  var classes = merge(className, withClassPrefix());
+  var _useCustom = useCustom('Picker'),
+    locale = _useCustom.locale;
+  var renderSearchRow = function renderSearchRow(item, key) {
+    var _extends2;
+    var nodes = getNodeParents(item);
+    var label = highlightLabel({
+      item: item,
+      labelKey: labelKey,
+      searchKeyword: searchKeyword,
+      render: function render(patch, index) {
+        return /*#__PURE__*/React.createElement("span", {
+          key: index,
+          className: prefix('match')
+        }, patch);
+      }
+    });
+    nodes.push(_extends({}, item, (_extends2 = {}, _extends2[labelKey] = label, _extends2)));
+    var active = value.some(function (value) {
+      if (cascade) {
+        return nodes.some(function (node) {
+          return node[valueKey] === value;
+        });
+      }
+      return item[valueKey] === value;
+    });
+    var disabled = disabledItemValues.some(function (value) {
+      return nodes.some(function (node) {
+        return node[valueKey] === value;
+      });
+    });
+    var rowClasses = prefix('row', {
+      'row-disabled': disabled
+    });
+    var indeterminate = cascade && !active && isSomeChildChecked(item, value, {
+      valueKey: valueKey,
+      childrenKey: childrenKey
+    });
+    var handleChange = function handleChange(_value, checked, event) {
+      onCheck === null || onCheck === void 0 ? void 0 : onCheck(item, event, checked);
+    };
+    return /*#__PURE__*/React.createElement("div", {
+      role: "treeitem",
+      "aria-disabled": disabled,
+      key: key,
+      className: rowClasses,
+      "data-key": item[valueKey]
+    }, /*#__PURE__*/React.createElement(Checkbox, {
+      disabled: disabled,
+      checked: active,
+      value: item[valueKey],
+      indeterminate: indeterminate,
+      onChange: handleChange
+    }, /*#__PURE__*/React.createElement("span", {
+      className: prefix('col-group')
+    }, nodes.map(function (node, index) {
+      return /*#__PURE__*/React.createElement("span", {
+        key: "col-" + index,
+        className: prefix('col')
+      }, node[labelKey]);
+    }))));
+  };
+  return /*#__PURE__*/React.createElement(Component, _extends({
+    className: classes
+  }, rest), /*#__PURE__*/React.createElement(SearchBox, {
+    placeholder: locale === null || locale === void 0 ? void 0 : locale.searchPlaceholder,
+    onChange: onSearch,
+    value: searchKeyword,
+    inputRef: inputRef
+  }), searchKeyword !== '' && /*#__PURE__*/React.createElement("div", {
+    className: prefix('panel'),
+    "data-layer": 0,
+    role: "tree"
+  }, data.length ? data.map(renderSearchRow) : /*#__PURE__*/React.createElement("div", {
+    className: merge(prefix('none'), rootPrefix('picker-none'))
+  }, locale.noResultsText)));
+}
+export default SearchView;

package/esm/MultiCascadeTree/TreeView.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { ItemDataType, WithAsProps, RsRefForwardingComponent } from '../@types/common';
+import type { CascadeColumn } from '../CascadeTree/types';
+export interface TreeViewProps<T = any> extends WithAsProps {
+    disabledItemValues?: T[];
+    value: T[];
+    childrenKey: string;
+    valueKey: string;
+    labelKey: string;
+    columnWidth?: number;
+    columnHeight?: number | string;
+    cascade?: boolean;
+    cascadeData: (readonly ItemDataType<T>[])[];
+    cascadePaths?: ItemDataType<T>[];
+    uncheckableItemValues: T[];
+    renderTreeNode?: (node: React.ReactNode, item: ItemDataType<T>) => React.ReactNode;
+    renderColumn?: (childNodes: React.ReactNode, column: CascadeColumn<T>) => React.ReactNode;
+    onCheck?: (node: ItemDataType<T>, event: React.SyntheticEvent, checked: boolean) => void;
+    onSelect?: (node: ItemDataType<T>, cascadePaths: ItemDataType<T>[], event: React.SyntheticEvent) => void;
+}
+declare const TreeView: RsRefForwardingComponent<'div', TreeViewProps>;
+export default TreeView;

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;
@@ -122,19 +118,19 @@ var TreeView = /*#__PURE__*/React.forwardRef(function (props, ref) {
       },
       checkable: !uncheckable,
       labelClickable: false
-    }, renderMenuItem ? renderMenuItem(label, node) : label, children ? /*#__PURE__*/React.createElement(Icon, {
+    }, 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]);
       });
@@ -151,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
     });
@@ -161,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;