rsuite 5.56.0 → 5.57.0

package/cjs/MultiCascadeTree/hooks/useCascadeValue.js

@@ -0,0 +1,202 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _uniq = _interopRequireDefault(require("lodash/uniq"));
+var _remove = _interopRequireDefault(require("lodash/remove"));
+var _utils = require("../../utils");
+var _utils2 = require("../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 = (0, _react.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 = (0, _react.useCallback)(function (item, checked, value) {
+    var itemValue = item[valueKey];
+    var childrenValue = getChildrenValue(item);
+    var parents = (0, _utils2.getParents)(item);
+    var nextValue = [].concat(value);
+    var removedValue = [];
+    if (checked) {
+      nextValue.push(itemValue);
+
+      // Delete all values under the current node
+      removedValue = removedValue.concat((0, _utils2.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((0, _utils2.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((0, _utils2.getOtherItemValuesByUnselectChild)(item, nextValue, {
+        valueKey: valueKey,
+        childrenKey: childrenKey
+      }));
+
+      // Delete related child and parent nodes
+      removedValue = (0, _remove.default)(nextValue, function (v) {
+        // Delete yourself
+        if (v === itemValue) {
+          return true;
+        }
+        return tempValue.some(function (n) {
+          return n === v;
+        });
+      });
+    }
+    var uniqValue = (0, _uniq.default)(nextValue);
+    var uniqRemovedValue = (0, _uniq.default)(removedValue);
+    return {
+      value: uniqValue,
+      removedValue: uniqRemovedValue
+    };
+  }, [valueKey, childrenKey, uncheckableItemValues, getChildrenValue]);
+  var transformValue = (0, _react.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 = (0, _uniq.default)(tempRemovedValue.concat(sv.removedValue));
+
+      // Get all relevant values
+      nextValue = (0, _uniq.default)(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 = (0, _react.useState)(transformValue(valueProp) || []),
+    value = _useState[0],
+    setValue = _useState[1];
+  (0, _react.useEffect)(function () {
+    // Update value when valueProp is updated.
+    setValue(transformValue(valueProp) || []);
+  }, [transformValue, valueProp]);
+  var handleCheck = (0, _utils.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
+  };
+}
+var _default = useCascadeValue;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/hooks/useColumnData.js

@@ -0,0 +1,52 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _slice = _interopRequireDefault(require("lodash/slice"));
+var _treeUtils = require("../../utils/treeUtils");
+/**
+ * A hook for column data
+ * @param flattenData
+ */
+function useColumnData(flattenData) {
+  // The columns displayed in the cascading panel.
+  var _useState = (0, _react.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((0, _slice.default)(columnData, 0, index), [column]));
+  }
+
+  /**
+   * Remove subsequent columns of the specified column
+   * @param index
+   */
+  function removeColumnByIndex(index) {
+    setColumnData([].concat((0, _slice.default)(columnData, 0, index)));
+  }
+  function enforceUpdateColumnData(nextData) {
+    var nextFlattenData = (0, _treeUtils.UNSAFE_flattenTree)(nextData);
+    setColumnData([nextFlattenData.filter(function (item) {
+      return !item.parent;
+    })]);
+  }
+  return {
+    columnData: columnData,
+    addColumn: addColumn,
+    removeColumnByIndex: removeColumnByIndex,
+    setColumnData: setColumnData,
+    enforceUpdateColumnData: enforceUpdateColumnData
+  };
+}
+var _default = useColumnData;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/hooks/useFlattenData.js

@@ -0,0 +1,33 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _treeUtils = require("../../utils/treeUtils");
+var _attachParent = require("../../utils/attachParent");
+/**
+ * A hook to flatten tree structure data
+ */
+function useFlattenData(data, itemKeys) {
+  var childrenKey = itemKeys.childrenKey;
+  var _useState = (0, _react.useState)((0, _treeUtils.UNSAFE_flattenTree)(data, itemKeys.childrenKey)),
+    flattenData = _useState[0],
+    setFlattenData = _useState[1];
+  var addFlattenData = (0, _react.useCallback)(function (children, parent) {
+    var nodes = children.map(function (child) {
+      return (0, _attachParent.attachParent)(child, parent);
+    });
+    parent[childrenKey] = nodes;
+    setFlattenData([].concat(flattenData, nodes));
+  }, [childrenKey, flattenData]);
+  (0, _react.useEffect)(function () {
+    setFlattenData((0, _treeUtils.UNSAFE_flattenTree)(data, itemKeys.childrenKey));
+  }, [data, itemKeys.childrenKey]);
+  return {
+    addFlattenData: addFlattenData,
+    flattenData: flattenData
+  };
+}
+var _default = useFlattenData;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/hooks/useSearch.js

@@ -0,0 +1,52 @@
+'use client';
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _utils = require("../../utils");
+function useSearch(props) {
+  var _useState = (0, _react.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((0, _utils.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 = (0, _utils.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
+  };
+}
+var _default = useSearch;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/hooks/useSelect.js

@@ -0,0 +1,83 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _react = require("react");
+var _utils = require("../../utils");
+var _useFlattenData2 = _interopRequireDefault(require("./useFlattenData"));
+var _useColumnData2 = _interopRequireDefault(require("./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 = (0, _useFlattenData2.default)(data, itemKeys),
+    flattenData = _useFlattenData.flattenData,
+    addFlattenData = _useFlattenData.addFlattenData; // The columns displayed in the cascading panel.
+  var _useColumnData = (0, _useColumnData2.default)(flattenData),
+    columnData = _useColumnData.columnData,
+    addColumn = _useColumnData.addColumn,
+    setColumnData = _useColumnData.setColumnData,
+    removeColumnByIndex = _useColumnData.removeColumnByIndex,
+    enforceUpdateColumnData = _useColumnData.enforceUpdateColumnData;
+  (0, _utils.useUpdateEffect)(function () {
+    enforceUpdateColumnData(data);
+  }, [data]);
+  var isMounted = (0, _utils.useIsMounted)();
+
+  // The path after cascading data selection.
+  var _useState = (0, _react.useState)(),
+    selectedPaths = _useState[0],
+    setSelectedPaths = _useState[1];
+  var handleSelect = (0, _utils.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
+  };
+};
+var _default = useSelect;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/index.js

@@ -0,0 +1,9 @@
+'use client';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _MultiCascadeTree = _interopRequireDefault(require("./MultiCascadeTree"));
+var _default = _MultiCascadeTree.default;
+exports.default = _default;

package/cjs/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/cjs/MultiCascadeTree/types.js

@@ -0,0 +1,2 @@
+'use client';
+"use strict";

package/cjs/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 {};