@qsxy/element-plus-react 1.0.0-next.1

package/dist/Cascader/Cascader.js

@@ -0,0 +1,630 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Cascader/Cascader.tsx
+var Cascader_exports = {};
+__export(Cascader_exports, {
+  default: () => Cascader_default
+});
+module.exports = __toCommonJS(Cascader_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_find = __toESM(require("lodash/find"));
+var import_get = __toESM(require("lodash/get"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+var import_last = __toESM(require("lodash/last"));
+var import_max = __toESM(require("lodash/max"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_reverse = __toESM(require("lodash/reverse"));
+var import_trim = __toESM(require("lodash/trim"));
+var import_react = __toESM(require("react"));
+var import_Divider = require("../Divider");
+var import_Icon = require("../Icon");
+var import_Input = require("../Input");
+var import_Popper = require("../Popper");
+var import_Tag = require("../Tag");
+var import_Tooltip = require("../Tooltip");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_CascaderContext = require("./CascaderContext");
+var import_CascaderDropdown = __toESM(require("./CascaderDropdown"));
+var import_CascaderMenu = __toESM(require("./CascaderMenu"));
+var import_Utils = require("./Utils");
+var import_useCascader = require("./useCascader");
+var Cascader = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    var _a;
+    const {
+      classPrefix = "cascader",
+      options,
+      separator,
+      filterable,
+      clearable,
+      showAllLevels,
+      required,
+      collapseTags,
+      maxCollapseTags,
+      collapseTagsTooltip,
+      collapseTips,
+      filterMethod,
+      onChange,
+      onEnter,
+      afterEnter,
+      afterLeave,
+      props: menuProps,
+      treeMenuProps,
+      shouldSelect,
+      labelFormatter,
+      error,
+      warning,
+      ...rest
+    } = props;
+    const { multiple, valueKey = "value", labelKey = "label", childrenKey = "children", lazy, lazyLoad } = menuProps;
+    const { valueKey: treeValueKey = "key" } = treeMenuProps;
+    const { e, b, m, is } = (0, import_hooks.useClassNames)(classPrefix);
+    const disabled = (0, import_hooks.useDisabled)(props.disabled);
+    const size = (0, import_hooks.useSize)(props.size);
+    const [htmlInputProps] = (0, import_hooks.partitionHTMLProps)(rest);
+    const [transitionProps] = (0, import_hooks.partitionAnimationProps)(rest);
+    const [popperProps] = (0, import_hooks.partitionPopperPropsUtils)(rest);
+    const [treeProps] = (0, import_hooks.partitionTreePropsUtils)(rest);
+    const containerRef = (0, import_react.useRef)();
+    const popperInstRef = (0, import_react.useRef)();
+    const inputRef = (0, import_react.useRef)(null);
+    const searchInstance = (0, import_react.useRef)(null);
+    const menuRefs = (0, import_react.useRef)({});
+    const wrapperRef = (0, import_react.useRef)(null);
+    const stopLazyRef = (0, import_react.useRef)(false);
+    const lastValueRef = (0, import_react.useRef)(props.value === void 0 ? void 0 : (0, import_Utils.toArray)(props.value, separator));
+    const [controlledValue, setControlledValue, isControlled] = (0, import_hooks.useControlled)(
+      props.value === void 0 ? void 0 : (0, import_Utils.toArray)(props.value, separator),
+      (0, import_Utils.toArray)(props.defaultValue, separator) ?? []
+    );
+    const [unControlledValue, setUnControlledValue] = (0, import_react.useState)(() => controlledValue);
+    (0, import_react.useEffect)(() => {
+      if (!(0, import_isEqual.default)(controlledValue, unControlledValue)) {
+        setUnControlledValue(controlledValue);
+      }
+    }, [controlledValue]);
+    const value = (0, import_react.useMemo)(() => isControlled ? unControlledValue : controlledValue, [controlledValue, isControlled, unControlledValue]);
+    const setValue = (0, import_react.useMemo)(() => isControlled ? setUnControlledValue : setControlledValue, [isControlled, setControlledValue]);
+    const {
+      allLevel,
+      storeOptionData,
+      getSelectedValue,
+      getValueOfLevel,
+      getSelectedNode,
+      setSelectedNode,
+      getSelectedLabel,
+      setCheckedNode,
+      getCheckedLabel,
+      getCheckedValue,
+      getCheckedNodes,
+      getOptions,
+      clearSelected,
+      setNodeLeaf,
+      getDataType,
+      getTreeData,
+      getExpandedKeys,
+      setExpandedKeys,
+      setSelectedValue,
+      handleSearch,
+      resetNodes
+    } = (0, import_useCascader.useCascader)(options, props, value);
+    const [level, setLevel] = (0, import_react.useState)((0, import_max.default)([value.length - 1, 0]));
+    const [loading, setLoading] = (0, import_react.useState)(null);
+    const [forceUpdate, setForceUpdate] = (0, import_react.useState)(false);
+    const [filterList, setFilterList] = (0, import_react.useState)([]);
+    (0, import_react.useEffect)(() => {
+      if (multiple && value.length > 0) {
+        setLevel((0, import_max.default)([value[0].length - 1, 0]));
+      } else {
+        setLevel((0, import_max.default)([value.length - 1, 0]));
+      }
+    }, [multiple, value, value.length]);
+    const multiValue = (0, import_react.useMemo)(() => {
+      if (multiple) {
+        if (value instanceof Array) {
+          return value;
+        } else if (typeof value === "string") {
+          return [value];
+        }
+      }
+      return [];
+    }, [multiple, value]);
+    const [label, setLabel] = (0, import_hooks.useControlled)(props.lable, "");
+    const [searchText, setSearchText] = (0, import_react.useState)("");
+    const [visible, setVisible] = (0, import_react.useState)(false);
+    const [inputHeight, setInputHeight] = (0, import_react.useState)(32);
+    const placeholder = (0, import_react.useMemo)(() => {
+      return multiple && (0, import_Util.isNotEmpty)(multiValue) ? "" : props.placeholder;
+    }, [multiValue, multiple, props.placeholder]);
+    (0, import_react.useEffect)(() => {
+      if (visible && filterable) {
+        searchInstance.current.focus();
+      }
+    }, [visible]);
+    const multiLabel = (0, import_react.useCallback)(() => {
+      var _a2;
+      if (multiple) {
+        return (_a2 = getCheckedLabel()) == null ? void 0 : _a2.map((item) => item.join(separator));
+      }
+      return [];
+    }, [getCheckedLabel, multiple, separator]);
+    const checkedNodes = (0, import_react.useCallback)(() => {
+      if (multiple) {
+        return getCheckedNodes() ?? [];
+      }
+      return [];
+    }, [getCheckedNodes, multiple]);
+    const handleAfterLeave = (0, import_react.useCallback)(() => {
+      setSearchText("");
+      afterLeave == null ? void 0 : afterLeave();
+    }, [afterLeave]);
+    const onClick = (0, import_react.useCallback)(
+      (event) => {
+        event == null ? void 0 : event.stopPropagation();
+        if (disabled) {
+          setVisible(false);
+          return;
+        }
+        setVisible(!visible);
+      },
+      [disabled, visible]
+    );
+    const onCloseTag = (0, import_react.useCallback)(
+      (item) => {
+        const node = (0, import_last.default)(item);
+        setCheckedNode(node.__level, node, false);
+        const _value = getCheckedValue() ?? [];
+        onChange == null ? void 0 : onChange(_value, node.__level, multiLabel(), getSelectedNode());
+        setValue(_value);
+      },
+      [getCheckedValue, getSelectedNode, multiLabel, onChange, setCheckedNode, setValue]
+    );
+    const onClear = (0, import_react.useCallback)(() => {
+      lastValueRef.current = [];
+      setValue([]);
+      setLabel("");
+      setLevel(0);
+      clearSelected();
+      onChange == null ? void 0 : onChange([], allLevel, "", null);
+    }, [allLevel, clearSelected, onChange, setLabel, setValue]);
+    const onClearSearch = (0, import_react.useCallback)((event) => {
+      event == null ? void 0 : event.stopPropagation();
+      setSearchText("");
+    }, []);
+    const onSearch = (0, import_react.useCallback)(
+      (val) => {
+        const keywords = (0, import_trim.default)(val);
+        if (keywords === searchText) {
+          return;
+        } else if ((0, import_Util.isEmpty)(keywords)) {
+          setSearchText("");
+        }
+        setSearchText(keywords);
+      },
+      [searchText]
+    );
+    const loopGetExpandedKeys = (0, import_react.useCallback)(
+      (nodeList, node, expandedKeys = []) => {
+        if (Object.prototype.hasOwnProperty.call(node, "parent")) {
+          const key = (0, import_get.default)(node, `parent.${treeValueKey}`);
+          const parent = (0, import_find.default)(nodeList, { [valueKey]: key });
+          if (parent) {
+            expandedKeys.push(key);
+            loopGetExpandedKeys(nodeList, parent, expandedKeys);
+          }
+        }
+        return expandedKeys;
+      },
+      [treeValueKey, valueKey]
+    );
+    const onSelect = (0, import_react.useCallback)(
+      (_level, node) => {
+        if (lazy && lazyLoad && node.__leaf !== true && !node[childrenKey]) {
+          setSelectedNode(_level, node);
+          new Promise((resolve, reject) => {
+            setLoading(node.__id);
+            lazyLoad({ ...node, level: _level + 1 }, resolve, reject);
+          }).then(({ nodes, isTree }) => {
+            storeOptionData(nodes, _level + 1, node, { isTree });
+            setLoading(null);
+            if (shouldSelect(node, _level)) {
+              setLevel(_level + 1);
+            }
+          }).catch(() => {
+            setNodeLeaf(node, true);
+            setLoading(null);
+            if (shouldSelect(node, _level)) {
+              storeOptionData([], _level + 1, node, { isTree: false });
+              const _label = getSelectedLabel(labelFormatter == null ? void 0 : labelFormatter.bind(void 0, _level));
+              lastValueRef.current = getSelectedValue();
+              setValue(lastValueRef.current);
+              setLabel(_label);
+              onChange == null ? void 0 : onChange(getSelectedValue(), _level, getSelectedLabel(), getSelectedNode());
+              setVisible(false);
+            }
+          });
+        } else {
+          if (shouldSelect(node, _level)) {
+            setForceUpdate(!forceUpdate);
+            if (node.__leaf) {
+              if (menuProps == null ? void 0 : menuProps.multiple) {
+                return;
+              }
+              setSelectedNode(_level, node);
+              const _label = getSelectedLabel(labelFormatter == null ? void 0 : labelFormatter.bind(void 0, _level));
+              setLabel(_label);
+              setVisible(false);
+              lastValueRef.current = getSelectedValue();
+              setValue(lastValueRef.current);
+              onChange == null ? void 0 : onChange(getSelectedValue(), _level, getSelectedLabel(), getSelectedNode());
+            } else {
+              setSelectedNode(_level, node);
+              if (menuProps == null ? void 0 : menuProps.multiple) {
+                setLevel(_level + 1);
+                return;
+              }
+              setLevel(_level + 1);
+              const _val = getSelectedValue();
+              const notMatch = _val.some((item, i) => item !== (value == null ? void 0 : value[i]));
+              if (!notMatch) {
+                value.forEach((item, i) => {
+                  setSelectedValue(i, item);
+                });
+              }
+            }
+          }
+        }
+      },
+      [
+        lazy,
+        lazyLoad,
+        childrenKey,
+        setSelectedNode,
+        storeOptionData,
+        shouldSelect,
+        setNodeLeaf,
+        getSelectedLabel,
+        labelFormatter,
+        getSelectedValue,
+        setValue,
+        setLabel,
+        onChange,
+        getSelectedNode,
+        forceUpdate,
+        menuProps == null ? void 0 : menuProps.multiple,
+        value,
+        setSelectedValue
+      ]
+    );
+    const onCheckedChange = (_level, node, checked) => {
+      setCheckedNode(_level, node, checked);
+      const _value = getCheckedValue() ?? [];
+      setValue(_value);
+      onChange == null ? void 0 : onChange(_value, _level, multiLabel(), getCheckedNodes());
+    };
+    const stopLazy = (0, import_react.useCallback)(() => {
+      if (stopLazyRef.current === true) {
+        stopLazyRef.current = false;
+        return true;
+      }
+      return false;
+    }, []);
+    const loopLazyLoad = (0, import_react.useCallback)(
+      (l, parent, _value, { isCover }) => {
+        const loopCore = (nodes, _l) => {
+          if (stopLazy()) {
+            return;
+          }
+          const curNode = (0, import_find.default)(nodes, { [valueKey]: _value[_l] });
+          if (curNode) {
+            const expandedKeys = loopGetExpandedKeys(nodes, curNode);
+            setExpandedKeys(_l, (0, import_reverse.default)(expandedKeys));
+            setSelectedNode(_l, curNode);
+            setLabel(getSelectedLabel(labelFormatter == null ? void 0 : labelFormatter.bind(void 0, showAllLevels ? _value.length : allLevel)));
+            loopLazyLoad(_l + 1, curNode, _value, { isCover });
+          }
+        };
+        if (stopLazy()) {
+          return;
+        }
+        if ((0, import_Util.isNotEmpty)(_value[l])) {
+          const cacheNodes = getOptions(l);
+          if ((cacheNodes == null ? void 0 : cacheNodes.length) > 0) {
+            loopCore(cacheNodes, l);
+          } else {
+            new Promise((resolve, reject) => {
+              lazyLoad({ ...parent, level: l }, resolve, reject);
+            }).then(({ nodes, isTree }) => {
+              const newNodes = storeOptionData(nodes, l, parent, { isTree, isCover });
+              loopCore(newNodes, l);
+            });
+          }
+        } else {
+          if (multiple) {
+            value.forEach((val) => {
+              const curNode = (0, import_find.default)(getOptions(val.length - 1), { [valueKey]: val[val.length - 1] });
+              if (curNode) {
+                setCheckedNode(val.length - 1, curNode, true);
+              }
+            });
+          }
+        }
+      },
+      [
+        stopLazy,
+        valueKey,
+        loopGetExpandedKeys,
+        setExpandedKeys,
+        setSelectedNode,
+        setLabel,
+        getSelectedLabel,
+        labelFormatter,
+        showAllLevels,
+        allLevel,
+        getOptions,
+        lazyLoad,
+        storeOptionData,
+        multiple,
+        value,
+        setCheckedNode
+      ]
+    );
+    (0, import_react.useEffect)(() => {
+      setFilterList(handleSearch(searchText));
+    }, [searchText]);
+    (0, import_react.useEffect)(() => {
+      var _a2, _b;
+      if (wrapperRef.current) {
+        const height = ((_a2 = wrapperRef.current) == null ? void 0 : _a2.clientHeight) + 4;
+        setInputHeight(height <= 32 ? 32 : height + 32);
+      }
+      if (popperInstRef.current && popperInstRef.current.update) {
+        (_b = popperInstRef.current) == null ? void 0 : _b.update();
+      }
+    }, [multiValue]);
+    const refreshLazy = (isCover = false) => {
+      var _a2;
+      if (lazy && lazyLoad) {
+        if (value instanceof Array && (0, import_Util.isNotEmpty)(value[0])) {
+          if (multiple) {
+            loopLazyLoad(0, null, value[0], { isCover });
+          } else {
+            loopLazyLoad(0, null, value, { isCover });
+          }
+        } else {
+          if ((0, import_Util.isNotEmpty)(lastValueRef.current)) {
+            stopLazyRef.current = true;
+          }
+          setLabel("");
+        }
+      } else {
+        setLabel(getSelectedLabel(labelFormatter == null ? void 0 : labelFormatter.bind(void 0, showAllLevels ? value.length : allLevel)));
+      }
+      (_a2 = popperInstRef.current) == null ? void 0 : _a2.update();
+    };
+    (0, import_react.useEffect)(() => {
+      var _a2;
+      (_a2 = popperInstRef.current) == null ? void 0 : _a2.update();
+    }, [filterList.length]);
+    (0, import_react.useEffect)(() => {
+      refreshLazy((0, import_Util.isNotEmpty)(value));
+    }, [value, lazyLoad, options]);
+    (0, import_react.useEffect)(() => {
+      if (lazy && lazyLoad && (0, import_Util.isEmpty)(value)) {
+        new Promise((resolve, reject) => {
+          lazyLoad({ level: 0 }, resolve, reject);
+        }).then(({ nodes, isTree }) => {
+          storeOptionData(nodes, 0, null, { isTree, isCover: true });
+        });
+      }
+      if ((0, import_Util.isEmpty)(props.lable)) {
+        setLabel(getSelectedLabel(labelFormatter == null ? void 0 : labelFormatter.bind(void 0, showAllLevels ? value.length : allLevel)));
+      }
+    }, [lazyLoad]);
+    (0, import_react.useImperativeHandle)(ref, () => ({
+      ref: containerRef,
+      input: inputRef,
+      setLabel,
+      onClear,
+      resetNodes: () => {
+        resetNodes();
+        setLevel(0);
+      },
+      setVisible
+    }));
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_CascaderContext.CascaderContext.Provider,
+      {
+        value: { menuProps, treeMenuProps, treeProps, onSelect, onCheckedChange, loading, getDataType, getTreeData, getExpandedKeys, setExpandedKeys, searchText }
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          className: (0, import_classnames.default)(b(), is({ disabled }), m({ [size]: size }), props.className),
+          style: props.style,
+          ref: containerRef,
+          onClick: (event) => event.stopPropagation()
+        },
+        /* @__PURE__ */ import_react.default.createElement("div", { className: e`trigger` }, multiple && /* @__PURE__ */ import_react.default.createElement(
+          "div",
+          {
+            className: e`tags`,
+            onClick,
+            onMouseEnter: () => {
+              var _a2;
+              return (_a2 = inputRef.current) == null ? void 0 : _a2.showClear(multiple ? multiValue.join(",") : label);
+            },
+            onMouseLeave: () => {
+              var _a2;
+              return (_a2 = inputRef.current) == null ? void 0 : _a2.hideClear();
+            }
+          },
+          /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b`tags-wrapper`, "has-prefix"), ref: wrapperRef }, (collapseTags ? checkedNodes().slice(0, maxCollapseTags) : checkedNodes()).map((item, i) => {
+            return /* @__PURE__ */ import_react.default.createElement(import_Tag.Tag, { key: i, type: "info", closable: !disabled, onClick, onClose: () => onCloseTag(item), disableTransitions: true }, item.map((node) => node[labelKey]).join(separator));
+          }), collapseTags && ((_a = multiLabel()) == null ? void 0 : _a.length) > maxCollapseTags && /* @__PURE__ */ import_react.default.createElement(
+            import_Tooltip.Tooltip,
+            {
+              popperClass: e`tooltip`,
+              placement: "top",
+              disabled: !collapseTagsTooltip,
+              content: /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, checkedNodes().slice(maxCollapseTags, checkedNodes().length).map((item, i) => /* @__PURE__ */ import_react.default.createElement(import_Tag.Tag, { key: i, type: "info", disableTransitions: true }, item.map((node) => node[labelKey]).join(separator)))),
+              effect: "light",
+              enterable: true
+            },
+            /* @__PURE__ */ import_react.default.createElement(import_Tag.Tag, { type: "info", onClick, disableTransitions: true }, collapseTips ? collapseTips(multiLabel().length - maxCollapseTags, multiLabel().length) : `+ ${multiLabel().length - maxCollapseTags}`)
+          ))
+        ), /* @__PURE__ */ import_react.default.createElement(
+          import_Input.Input,
+          {
+            ref: inputRef,
+            value: multiple ? multiValue.join(separator) : label,
+            placeholder,
+            readOnly: true,
+            hiddenValue: multiple,
+            clearable: clearable && !disabled,
+            disabled,
+            size,
+            onClick,
+            onClear,
+            plain: props.plain,
+            className: is({ active: visible }),
+            error,
+            warning,
+            innerStyle: multiple ? { height: inputHeight } : {},
+            suffix: /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: "fal", name: "angle-down", className: visible ? "fa-rotate-180" : "", onClick }),
+            prefix: props.prefix,
+            append: props.append,
+            prepend: props.prepend,
+            ...(0, import_omit.default)(htmlInputProps, [
+              "value",
+              "defaultValue",
+              "onInput",
+              "size",
+              "prefix",
+              "onChange",
+              "style",
+              "readOnly",
+              "disabled",
+              "className",
+              "type",
+              "maxLength",
+              "minLength",
+              "name"
+            ])
+          }
+        ))
+      ),
+      /* @__PURE__ */ import_react.default.createElement(
+        import_Popper.Popper,
+        {
+          referenceElement: () => {
+            var _a2;
+            return (_a2 = inputRef == null ? void 0 : inputRef.current) == null ? void 0 : _a2.ref;
+          },
+          visible,
+          popperInstRef,
+          popperClass: e`dropdown`,
+          onDestroy: () => setVisible(false),
+          onEnter: () => {
+            var _a2;
+            (_a2 = popperInstRef.current) == null ? void 0 : _a2.update();
+            onEnter == null ? void 0 : onEnter();
+          },
+          afterEnter: () => {
+            for (const key in menuRefs.current) {
+              if (Object.prototype.hasOwnProperty.call(menuRefs.current, key)) {
+                const item = menuRefs.current[key];
+                item == null ? void 0 : item.scrollToSelected();
+              }
+            }
+            afterEnter == null ? void 0 : afterEnter();
+          },
+          afterLeave: handleAfterLeave,
+          placement: "bottom-start",
+          transitionAppear: true,
+          unmountOnExit: true,
+          ...transitionProps,
+          ...popperProps
+        },
+        /* @__PURE__ */ import_react.default.createElement("div", { className: b`panel` }, filterable && /* @__PURE__ */ import_react.default.createElement("div", { className: e`search`, onClick: (event) => event.stopPropagation() }, /* @__PURE__ */ import_react.default.createElement(
+          import_Input.Input,
+          {
+            ref: searchInstance,
+            placeholder: "请输入关键词",
+            clearable: true,
+            plain: true,
+            debounceInput: true,
+            onClear: onClearSearch,
+            onChange: onSearch,
+            prefix: /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: "fal", name: "search" })
+          }
+        ), /* @__PURE__ */ import_react.default.createElement(import_Divider.Divider, { style: { margin: 0 } })), (0, import_Util.isNotEmpty)(searchText) ? /* @__PURE__ */ import_react.default.createElement(import_CascaderDropdown.default, { options: filterList, separator, value, checkedNodes }) : /* @__PURE__ */ import_react.default.createElement("div", { className: e`panels` }, new Array(level + 1).fill(0).map((_, l) => {
+          return /* @__PURE__ */ import_react.default.createElement(
+            import_CascaderMenu.default,
+            {
+              key: getValueOfLevel(l) + "_" + l,
+              ref: (_ref) => menuRefs.current[l] = _ref,
+              data: getOptions(l),
+              level: l,
+              value: getValueOfLevel(l)
+            }
+          );
+        })))
+      )
+    );
+  })
+);
+Cascader.defaultProps = {
+  separator: "/",
+  showAllLevels: true,
+  props: {
+    expandTrigger: "click",
+    emitPath: true,
+    valueKey: "value",
+    labelKey: "label",
+    childrenKey: "children",
+    disabledKey: "disabled",
+    leafKey: "leaf"
+  },
+  treeMenuProps: {
+    valueKey: "key",
+    labelKey: "title",
+    childrenKey: "children",
+    disabledKey: "disabled",
+    leafKey: "leaf"
+  },
+  shouldSelect: () => true,
+  placeholder: "请选择",
+  collapseTags: true,
+  collapseTagsTooltip: true,
+  maxCollapseTags: 1
+};
+Cascader.displayName = "Cascader";
+var Cascader_default = Cascader;

package/dist/Cascader/CascaderContext.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { DataNode, DirectoryTreeProps, Key } from '../Tree';
+import { CascaderMenuProps, TreeMenuProps } from './typings';
+interface CascaderContextProps<T = DataNode> {
+    menuProps: CascaderMenuProps;
+    treeMenuProps?: TreeMenuProps;
+    treeProps?: DirectoryTreeProps<T>;
+    loading?: string;
+    searchText?: string;
+    getExpandedKeys?: (level: number) => Key[];
+    setExpandedKeys?: (level: number, keys: Key[]) => void;
+    onSelect: (level: number, node: object) => void;
+    onCheckedChange: (_level: number, node: object, checked: boolean) => void;
+    getDataType: (level: number) => boolean;
+    getTreeData: (level: number) => DataNode[];
+}
+export declare const CascaderContext: import("react").Context<CascaderContextProps<DataNode<any>>>;
+export {};