rsuite 5.56.0 → 5.57.0

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';

package/esm/MultiCascadeTree/utils.d.ts

@@ -0,0 +1,37 @@
+import { ItemDataType } from '../@types/common';
+export interface ItemType<T = any> extends ItemDataType<T> {
+    parent?: ItemType<T>;
+}
+interface ItemKeys {
+    valueKey: string;
+    labelKey: string;
+    childrenKey: string;
+}
+declare type MayHasParent<T extends Record<string, unknown>> = T & {
+    parent?: MayHasParent<T>;
+};
+/**
+ * Get all parents of a node
+ * @param node
+ */
+export declare const getParents: <T extends Record<string, unknown>>(node: MayHasParent<T>) => MayHasParent<T>[];
+/**
+ * Check if any child nodes are selected.
+ * @param node
+ * @param value
+ * @param itemKeys
+ */
+export declare const isSomeChildChecked: <T extends Record<string, unknown>>(node: T, value: T[], itemKeys: Omit<ItemKeys, 'labelKey'>) => any;
+/**
+ * Check if the parent is selected.
+ * @param node
+ * @param value
+ * @param itemKeys
+ */
+export declare const isSomeParentChecked: <T extends Record<string, unknown>>(node: MayHasParent<T>, value: T[], itemKeys: Pick<ItemKeys, 'valueKey'>) => any;
+export declare const getOtherItemValuesByUnselectChild: <T>(itemNode: ItemType, value: any, itemKeys: Omit<ItemKeys, 'labelKey'>) => T[];
+/**
+ * Remove the values of all children.
+ */
+export declare const removeAllChildrenValue: <T>(value: T[], item: ItemType, itemKeys: Omit<ItemKeys, 'labelKey'>) => T[] | undefined;
+export {};

package/esm/MultiCascadeTree/utils.js

@@ -0,0 +1,130 @@
+'use client';
+import remove from 'lodash/remove';
+/**
+ * Get all parents of a node
+ * @param node
+ */
+export var getParents = function getParents(node) {
+  var parents = [];
+  if (!node.parent) {
+    return parents;
+  }
+  parents.push(node.parent);
+  parents = parents.concat(getParents(node.parent));
+  return parents;
+};
+
+/**
+ * Check if any child nodes are selected.
+ * @param node
+ * @param value
+ * @param itemKeys
+ */
+export var isSomeChildChecked = function isSomeChildChecked(node, value, itemKeys) {
+  var childrenKey = itemKeys.childrenKey,
+    valueKey = itemKeys.valueKey;
+  if (!node[childrenKey] || !value) {
+    return false;
+  }
+  return node[childrenKey].some(function (child) {
+    var _child$childrenKey;
+    if (value.some(function (n) {
+      return n === child[valueKey];
+    })) {
+      return true;
+    }
+    if ((_child$childrenKey = child[childrenKey]) !== null && _child$childrenKey !== void 0 && _child$childrenKey.length) {
+      return isSomeChildChecked(child, value, itemKeys);
+    }
+    return false;
+  });
+};
+
+/**
+ * Check if the parent is selected.
+ * @param node
+ * @param value
+ * @param itemKeys
+ */
+export var isSomeParentChecked = function isSomeParentChecked(node, value, itemKeys) {
+  var valueKey = itemKeys.valueKey;
+  if (!value) {
+    return false;
+  }
+  if (value.some(function (n) {
+    return n === node[valueKey];
+  })) {
+    return true;
+  }
+  if (node.parent) {
+    return isSomeParentChecked(node.parent, value, itemKeys);
+  }
+  return false;
+};
+export var getOtherItemValuesByUnselectChild = function getOtherItemValuesByUnselectChild(itemNode, value, itemKeys) {
+  var valueKey = itemKeys.valueKey,
+    childrenKey = itemKeys.childrenKey;
+  var parentValues = [];
+  var itemValues = [];
+
+  // Find the parent node of the current node by value
+  function findParent(item) {
+    parentValues.push(item[valueKey]);
+    if (value.some(function (v) {
+      return v === item[valueKey];
+    })) {
+      return item;
+    }
+    if (item.parent) {
+      var p = findParent(item.parent);
+      if (p) {
+        return p;
+      }
+    }
+    return null;
+  }
+
+  // Get child nodes through parent node
+  function pushChildValue(item) {
+    if (!item[childrenKey]) {
+      return;
+    }
+    item[childrenKey].forEach(function (n) {
+      // Determine whether it is a direct parent
+      if (parentValues.some(function (v) {
+        return v === n[valueKey];
+      }) && n[childrenKey]) {
+        pushChildValue(n);
+      } else if (n[valueKey] !== itemNode[valueKey]) {
+        itemValues.push(n[valueKey]);
+      }
+    });
+  }
+  var parent = findParent(itemNode);
+  if (!parent) {
+    return [];
+  }
+  pushChildValue(parent);
+  return itemValues;
+};
+
+/**
+ * Remove the values of all children.
+ */
+export var removeAllChildrenValue = function removeAllChildrenValue(value, item, itemKeys) {
+  var valueKey = itemKeys.valueKey,
+    childrenKey = itemKeys.childrenKey;
+  var removedValue = [];
+  if (!item[childrenKey]) {
+    return;
+  }
+  item[childrenKey].forEach(function (n) {
+    removedValue = removedValue.concat(remove(value, function (v) {
+      return v === n[valueKey];
+    }));
+    if (n[childrenKey]) {
+      removeAllChildrenValue(value, n, itemKeys);
+    }
+  });
+  return removedValue;
+};

package/esm/MultiCascader/MultiCascader.d.ts

@@ -1,42 +1,70 @@
 import React from 'react';
 import { PickerLocale } from '../locales';
 import { PickerComponent, PickerToggleProps } from '../internals/Picker';
-import { FormControlPickerProps, ItemDataType } from '../@types/common';
-export declare type ValueType = (number | string)[];
-export interface MultiCascaderProps<T = ValueType> extends FormControlPickerProps<T, PickerLocale, ItemDataType>, Pick<PickerToggleProps, 'loading'> {
-    cascade?: boolean;
-    /** A picker that can be counted */
+import { FormControlPickerProps, ItemDataType, DataItemValue } from '../@types/common';
+import type { MultiCascadeTreeProps } from '../MultiCascadeTree';
+export interface MultiCascaderProps<T extends DataItemValue> extends FormControlPickerProps<T[], PickerLocale, ItemDataType<T>, T>, MultiCascadeTreeProps<T, T[]>, Pick<PickerToggleProps, 'loading'> {
+    /**
+     * A picker that can be counted
+     */
     countable?: boolean;
-    /** Sets the width of the menu */
+    /**
+     * Sets the width of the menu.
+     *
+     * @deprecated Use columnWidth instead
+     */
     menuWidth?: number;
-    /** Sets the height of the menu */
-    menuHeight?: number | string;
-    /** Set the option value for the check box not to be rendered */
-    uncheckableItemValues?: T;
-    /** Whether dispaly search input box */
-    searchable?: boolean;
-    /** The menu is displayed directly when the component is initialized */
+    /**
+     * Sets the height of the menu
+     * @deprecated Use columnHeight instead
+     */
+    menuHeight?: number;
+    /**
+     * Custom menu class name
+     * @deprecated Use popupClassName instead
+     */
+    menuClassName?: string;
+    /**
+     * Custom menu style
+     * @deprecated Use popupStyle instead
+     */
+    menuStyle?: React.CSSProperties;
+    /**
+     * Custom popup style
+     */
+    popupStyle?: React.CSSProperties;
+    /**
+     * Custom popup style
+     */
+    popupClassName?: string;
+    /**
+     * The panel is displayed directly when the component is initialized
+     * @deprecated Use MultiCascadeTree instead
+     * @see MultiCascadeTree https://rsuitejs.com/components/multi-cascade-tree
+     */
     inline?: boolean;
-    /** Custom render menu */
-    renderMenu?: (items: readonly ItemDataType[], menu: React.ReactNode, parentNode?: any, layer?: number) => React.ReactNode;
-    /** Custom render menu items */
-    renderMenuItem?: (itemLabel: React.ReactNode, item: any) => React.ReactNode;
-    /** Custom render selected items */
-    renderValue?: (value: T, selectedItems: ItemDataType[], selectedElement: React.ReactNode) => React.ReactNode;
-    /** Called when the option is selected */
-    onSelect?: (node: ItemDataType, cascadePaths: ItemDataType[], event: React.SyntheticEvent) => void;
-    /** Called after the checkbox state changes */
-    onCheck?: (value: ValueType, node: ItemDataType, checked: boolean, event: React.SyntheticEvent) => void;
-    /** Called when clean */
+    /**
+     * Custom render menu
+     * @deprecated Use renderColumn instead
+     */
+    renderMenu?: (items: readonly ItemDataType<T>[], menu: React.ReactNode, parentNode?: any, layer?: number) => React.ReactNode;
+    /**
+     * Custom render menu item
+     * @deprecated Use renderTreeNode instead
+     */
+    renderMenuItem?: (node: React.ReactNode, item: ItemDataType<T>) => React.ReactNode;
+    /**
+     * Custom render selected items
+     */
+    renderValue?: (value: T[], selectedItems: ItemDataType<T>[], selectedElement: React.ReactNode) => React.ReactNode;
+    /**
+     * Called when clean
+     */
     onClean?: (event: React.SyntheticEvent) => void;
-    /** Called when searching */
-    onSearch?: (searchKeyword: string, event: React.SyntheticEvent) => void;
-    /** Asynchronously load the children of the tree node. */
-    getChildren?: (node: ItemDataType) => ItemDataType[] | Promise<ItemDataType[]>;
 }
 /**
  * The `MultiCascader` component is used to select multiple values from cascading options.
  * @see https://rsuitejs.com/components/multi-cascader/
  */
-declare const MultiCascader: PickerComponent<MultiCascaderProps>;
+declare const MultiCascader: PickerComponent<MultiCascaderProps<DataItemValue>>;
 export default MultiCascader;